├── .gitignore
├── Makefile
├── README.md
├── benchmark
    ├── article.py
    ├── benchmark.h
    ├── fftw.cpp
    ├── graphs.py
    ├── kissfft.cpp
    ├── main.cpp
    └── others
    │   └── contents.txt
├── common
    ├── console-colours.h
    ├── csv.h
    ├── simple-args.h
    ├── sqlite-cpp.h
    └── test
    │   ├── example-test.cpp
    │   ├── main.cpp
    │   └── tests.h
├── comparison.svg
├── signalsmith-fft.h
└── tests
    ├── 00-fft.cpp
    ├── 01-real.cpp
    └── tests-common.h


/.gitignore:
--------------------------------------------------------------------------------
1 | out
2 | benchmark/others
3 | fft-v4/
4 | .DS_Store
5 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | .PHONY: test
 2 | ifndef VERBOSE
 3 | .SILENT:
 4 | endif
 5 | 
 6 | SHARED_PATH := "common"
 7 | 
 8 | clean:
 9 | 	rm -rf out
10 | 
11 | ############## Testing ##############
12 | 
13 | TEST_CPP_FILES := $(shell find tests -iname "*.cpp" | sort)
14 | 
15 | test: out/test
16 | 	./out/test
17 | 
18 | out/test: *.h $(shell find tests -iname "*.h") $(shell find tests -iname "*.cpp")
19 | 	echo "building tests: ${TEST_CPP_FILES}"
20 | 	mkdir -p out
21 | 	g++ -std=c++11 -Wall -Wextra -Wfatal-errors -O0 \
22 |  		-Wpedantic -pedantic-errors \
23 | 		"${SHARED_PATH}/test/main.cpp" -I "${SHARED_PATH}" \
24 | 		-I tests/ ${TEST_CPP_FILES} \
25 | 		-o out/test
26 | 
27 | ############## Benchmarking ##############
28 | 
29 | graphs:
30 | 	python benchmark/graphs.py
31 | 
32 | benchmarks: test benchmark-main benchmark-kissfft benchmark-fftw graphs
33 | 
34 | BENCHMARK_TEST_TIME := 0.05
35 | 
36 | # Generic versions
37 | 
38 | benchmark-%: out/benchmark-%
39 | 	mkdir -p out/results
40 | 	cd out && ./benchmark-$* --test-time=${BENCHMARK_TEST_TIME}
41 | 
42 | out/benchmark-%: *.h $(shell find benchmark -iname "*.h") $(shell find benchmark -iname "*.cpp")
43 | 	mkdir -p out
44 | 	g++ -std=c++11 -msse2 -mavx -Wfatal-errors -O3 \
45 | 		"${SHARED_PATH}/test/main.cpp" -I "${SHARED_PATH}" \
46 | 		-I benchmark/ benchmark/$*.cpp \
47 | 		-o out/benchmark-$*
48 | 
49 | # Custom versions which need more config
50 | 
51 | out/benchmark-fftw: $(shell find benchmark -iname "*.h") $(shell find benchmark -iname "*.cpp")
52 | 	mkdir -p out
53 | 	g++ -std=c++11 -msse2 -mavx -Wfatal-errors -g -O3 \
54 | 		"${SHARED_PATH}/test/main.cpp" -I "${SHARED_PATH}" \
55 | 		-I benchmark/ benchmark/fftw.cpp \
56 | 		-lfftw3 \
57 | 		-o out/benchmark-fftw
58 | 
59 | ############## Development ##############
60 | 
61 | # After an initial "make benchmark", you can continue
62 | dev: test benchmark-main graphs
63 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Signalsmith FFT
 2 | 
 3 | A small and (reasonably) performant C++11 FFT implementation.
 4 | 
 5 | Under development, so things might be a little untidy at the moment, but the API's stable and the tests should build/pass.
 6 | 
 7 | ```cpp
 8 | #include "signalsmith-fft.h"
 9 | 
10 | signalsmith::FFT<double> fft(size);
11 | ```
12 | 
13 | ![speed comparison graph](comparison.svg)
14 | 
15 | ## Setting the size
16 | 
17 | ```cpp
18 | fft.setSize(1024);
19 | ```
20 | 
21 | It is faster for certain sizes (powers of 2, 3 and 5), and it's _strongly_ recommended that you use these.  For convenience there are two methods for finding fast sizes above and below a limit:
22 | 
23 | ```cpp
24 | actualSize = fft.setSizeMinimum(1025); // sets (and returns) a fast size >= 1025
25 | 
26 | actualSize = fft.setSizeMaximum(1025); // sets (and returns) a fast size <= 1025
27 | ```
28 | 
29 | 
30 | ## Forward/reverse FFT
31 | 
32 | ```cpp
33 | fft.fft(complexTime, complexSpectrum);
34 | 
35 | fft.ifft(complexSpectrum, complexTime);
36 | ```
37 | 
38 | These methods are templated, and accept any iterator or container holding a `std::complex`.  This could be a pointer (e.g. `std::complex<double> *`), or a `std::vector`, or whatever.
39 | 
40 | ## Real FFT
41 | 
42 | ```cpp
43 | 
44 | signalsmith::RealFFT<double> fft(size);
45 | 
46 | fft.fft(realTime, complexSpectrum);
47 | fft.ifft(complexSpectrum, realTime);
48 | ```
49 | 
50 | The size _must_ be even.  The complex spectrum is half the size - e.g. 256 real inputs produce 128 complex outputs.
51 | 
52 | Since the 0 and Nyquist frequencies are both real, these are packed into the real/imaginary parts of index 0.
53 | 


--------------------------------------------------------------------------------
/benchmark/article.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | import matplotlib
 4 | from matplotlib import pyplot
 5 | 
 6 | def small(*args, **kwargs):
 7 | 	figure, axes = pyplot.subplots(*args, **kwargs)
 8 | 	figure.set_size_inches(4.5, 3)
 9 | 	return figure, axes
10 | 
11 | def medium(*args, **kwargs):
12 | 	figure, axes = pyplot.subplots(*args, **kwargs)
13 | 	figure.set_size_inches(6.5, 4)
14 | 	return figure, axes
15 | 
16 | def tall(*args, **kwargs):
17 | 	figure, axes = pyplot.subplots(*args, **kwargs)
18 | 	figure.set_size_inches(4.5, 5.5)
19 | 	return figure, axes
20 | 
21 | def short(*args, **kwargs):
22 | 	figure, axes = pyplot.subplots(*args, **kwargs)
23 | 	figure.set_size_inches(7, 3)
24 | 	return figure, axes
25 | 
26 | def wide(*args, **kwargs):
27 | 	figure, axes = pyplot.subplots(*args, **kwargs)
28 | 	figure.set_size_inches(11, 4)
29 | 	return figure, axes
30 | 
31 | def full(*args, **kwargs):
32 | 	figure, axes = pyplot.subplots(*args, **kwargs)
33 | 	figure.set_size_inches(16, 10)
34 | 	return figure, axes
35 | 
36 | def save(prefix, figure, legend_loc=0):
37 | 	dirname = os.path.dirname(prefix)
38 | 	if len(dirname) and not os.path.exists(dirname):
39 | 		os.makedirs(dirname)
40 | 
41 | 	if len(figure.get_axes()) > 1:
42 | 		figure.set_tight_layout(True)
43 | 	for axes in figure.get_axes():
44 | 		if len(axes.get_lines()) > 0 and legend_loc != None:
45 | 			axes.legend(loc=legend_loc)
46 | 
47 | 	print(prefix)
48 | 	figure.savefig(prefix + '.svg', bbox_inches='tight')
49 | 


--------------------------------------------------------------------------------
/benchmark/benchmark.h:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <fstream>
  3 | #include <iostream>
  4 | #include <algorithm>
  5 | 
  6 | #include "../tests/tests-common.h"
  7 | 
  8 | template<typename T>
  9 | class OutOfPlaceRunner {
 10 | 	std::vector<std::complex<T>> inVector, outVector;
 11 | public:
 12 | 	size_t size;
 13 | 
 14 | 	OutOfPlaceRunner(size_t size) : size(size) {}
 15 | 	virtual ~OutOfPlaceRunner() {}
 16 | 	
 17 | 	virtual void getPointers(std::complex<T> **inPointer, std::complex<T> **outPointer) {
 18 | 		inVector.resize(size);
 19 | 		outVector.resize(size);
 20 | 		*inPointer = inVector.data();
 21 | 		*outPointer = outVector.data();
 22 | 	}
 23 | };
 24 | 
 25 | template<typename Implementation, int constMaxSize=INT_MAX>
 26 | struct Benchmark {
 27 | 	static std::vector<int> getSizes(int customMaxSize=16777216) { // 16777216
 28 | 		std::vector<int> possibleSizes(0);
 29 | 		int size = 1;
 30 | 		int maxSize = std::min(constMaxSize, customMaxSize);
 31 | 		while (size <= maxSize) {
 32 | 			possibleSizes.push_back(size);
 33 | 			size *= 2;
 34 | 		}
 35 | 
 36 | 		std::vector<int> result;
 37 | 		for (int size : possibleSizes) {
 38 | 			if (size <= maxSize) {
 39 | 				result.push_back(size);
 40 | 			}
 41 | 
 42 | 			std::vector<int> mults = {3, 5, 7, 9, 11, 15, 23};
 43 | 			mults = {3, 5, 9, 15, 25};
 44 | 			mults = {3, 9};
 45 | 			for (int mult : mults) {
 46 | 				if (size*mult < maxSize) {
 47 | 					result.push_back(size*mult);
 48 | 				}
 49 | 			}
 50 | 		}
 51 | 		return result;
 52 | 	}
 53 | 
 54 | 	template <typename Runner>
 55 | 	static void runBenchmark(Test &test, std::string name, std::string resultPrefix) {
 56 | 		auto sizes = getSizes();
 57 | 		std::sort(sizes.begin(), sizes.end());
 58 | 
 59 | 		std::cout << name << ":\n";
 60 | 		std::vector<double> rates = BenchmarkRate::map<int>(sizes, [](int size, int repeats, Timer &timer) {
 61 | 			auto runner = Runner(size);
 62 | 
 63 | 			// The runner handles input/output allocation
 64 | 			std::complex<double> *input, *output;
 65 | 			runner.getPointers(&input, &output);
 66 | 
 67 | 			for (int i = 0; i < size; i++) {
 68 | 				input[i] = randomComplex<double>();
 69 | 			}
 70 | 
 71 | 			timer.start();
 72 | 			for (int repeat = 0; repeat < repeats; ++repeat) {
 73 | 				runner.forward(input, output);
 74 | 			}
 75 | 			timer.stop();
 76 | 		}, true);
 77 | 		std::vector<double> scaled = rates;
 78 | 		for (size_t i = 0; i < sizes.size(); i++) {
 79 | 			double size = sizes[i];
 80 | 			double scaling = std::max(1.0, size*log(size))*1e-6;
 81 | 			scaled[i] = rates[i]*scaling;
 82 | 		}
 83 | 
 84 | 		std::ofstream outputJs, outputCsv;
 85 | 		outputJs.open(resultPrefix + ".js");
 86 | 		outputCsv.open(resultPrefix + ".csv");
 87 | 
 88 | 		outputJs << "addResults(\"" << name << "\", [";
 89 | 		outputCsv << "size,ops/sec," << name << "\n";
 90 | 		outputCsv.precision(15);
 91 | 
 92 | 		for (size_t i = 0; i < sizes.size(); i++) {
 93 | 			if (i > 0) outputJs << ",";
 94 | 			outputJs << "\n\t{size: " << sizes[i] << ", rate: " << scaled[i] << "}";
 95 | 			outputCsv << sizes[i] << "," << rates[i] << "," << scaled[i] << "\n";
 96 | 		}
 97 | 		outputJs << "\n]);";
 98 | 
 99 | 		return test.pass();
100 | 	}
101 | 
102 | 	TEST_METHOD("double out-of-place", double_out) {
103 | 		std::string resultPrefix = std::string("results/") + Implementation::resultTag();
104 | 		runBenchmark<typename Implementation::DoubleOutOfPlace>(test, Implementation::name(), resultPrefix);
105 | 	}
106 | };
107 | 


--------------------------------------------------------------------------------
/benchmark/fftw.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | 
 3 | #include "benchmark.h"
 4 | 
 5 | #include <fftw3.h>
 6 | 
 7 | template<int searchLevel>
 8 | struct FFTW_Estimate {
 9 | 	static std::string name() {
10 | 		if (searchLevel == FFTW_ESTIMATE) {
11 | 			return "FFTW (estimate)";
12 | 		} else if (searchLevel == FFTW_MEASURE) {
13 | 			return "FFTW (measure)";
14 | 		}
15 | 		return "FFTW";
16 | 	}
17 | 	static std::string resultTag() {
18 | 		if (searchLevel == FFTW_ESTIMATE) {
19 | 			return "fftw-estimate";
20 | 		} else if (searchLevel == FFTW_MEASURE) {
21 | 			return "fftw-measure";
22 | 		}
23 | 		return "fftw";
24 | 	}
25 | 	static std::string version() {
26 | 		return "3.3.8";
27 | 	}
28 | 
29 | 	template <typename T>
30 | 	struct OutOfPlace : public OutOfPlaceRunner<T> {
31 | 		fftw_plan fftForward;
32 | 		fftw_complex *input, *output;
33 | 		
34 | 		OutOfPlace(size_t size) : OutOfPlaceRunner<T>(size) {
35 | 			input = (fftw_complex*)fftw_malloc(size*sizeof(fftw_complex));
36 | 			output = (fftw_complex*)fftw_malloc(size*sizeof(fftw_complex));
37 | 			fftForward = fftw_plan_dft_1d(size, input, output, FFTW_FORWARD, searchLevel);
38 | 		}
39 | 		~OutOfPlace() {
40 | 			fftw_destroy_plan(fftForward);
41 | 			fftw_free(input);
42 | 			fftw_free(output);
43 | 		}
44 | 
45 | 		virtual void getPointers(std::complex<T> **inPointer, std::complex<T> **outPointer) {
46 | 			*inPointer = (std::complex<T>*)input;
47 | 			*outPointer = (std::complex<T>*)output;
48 | 		}
49 | 
50 | 		void forward(std::complex<T> *input, std::complex<T> *output) {
51 | 			fftw_execute(fftForward);
52 | 		}
53 | 	};
54 | 
55 | 	using DoubleOutOfPlace = OutOfPlace<double>;
56 | };
57 | static Benchmark<FFTW_Estimate<FFTW_ESTIMATE>> benchEstimate;
58 | static Benchmark<FFTW_Estimate<FFTW_MEASURE>, 65536> benchMeasure;
59 | 


--------------------------------------------------------------------------------
/benchmark/graphs.py:
--------------------------------------------------------------------------------
 1 | import os.path
 2 | import csv
 3 | import numpy
 4 | import matplotlib
 5 | from matplotlib import pyplot
 6 | 
 7 | import article
 8 | 
 9 | def plot_if_exists(axis, csvFile):
10 | 	axis.set(xlabel="size", ylabel="normalised rate")
11 | 	axis.set_xscale('log', basex=4)
12 | 	axis.xaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(lambda x, pos: ("%i"%x) if (x <= 65536) else ("2^%i"%int(numpy.log2(x)))))
13 | 	if not os.path.exists(csvFile):
14 | 		return False
15 | 	with open(csvFile) as inputCsv:
16 | 		reader = csv.reader(inputCsv)
17 | 		header = next(reader)
18 | 		(_, _, lineName) = header
19 | 
20 | 		sizes = []
21 | 		rates = []
22 | 		for row in reader:
23 | 			(size, rate, scaledRate) = [float(x) for x in row]
24 | 			sizes.append(size)
25 | 			rates.append(scaledRate)
26 | 		axis.plot(sizes, rates, label=lineName)
27 | 
28 | figure, axis = article.wide()
29 | plot_if_exists(axis, "out/results/signalsmith.csv")
30 | plot_if_exists(axis, "out/results/fftw-estimate.csv")
31 | plot_if_exists(axis, "out/results/fftw-measure.csv")
32 | plot_if_exists(axis, "out/results/kissfft.csv")
33 | article.save("out/comparison", figure)
34 | 
35 | figure, axis = article.wide()
36 | plot_if_exists(axis, "out/results/signalsmith.csv")
37 | plot_if_exists(axis, "out/results/previous-v4.csv")
38 | plot_if_exists(axis, "out/results/previous-permute.csv")
39 | plot_if_exists(axis, "out/results/previous.csv")
40 | article.save("out/previous", figure)
41 | 
42 | figure, axis = article.wide()
43 | plot_if_exists(axis, "out/results/signalsmith.csv")
44 | plot_if_exists(axis, "out/results/dev-history-radix234.csv")
45 | plot_if_exists(axis, "out/results/dev-history-radix23.csv")
46 | plot_if_exists(axis, "out/results/dev-history-factorise.csv")
47 | plot_if_exists(axis, "out/results/dev-history-direct.csv")
48 | article.save("out/history", figure)
49 | 


--------------------------------------------------------------------------------
/benchmark/kissfft.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | 
 3 | #include "benchmark.h"
 4 | 
 5 | #include "others/kissfft/kissfft.hh"
 6 | 
 7 | struct Kiss {
 8 | 	static std::string name() {
 9 | 		return "KissFFT";
10 | 	}
11 | 	static std::string resultTag() {
12 | 		return "kissfft";
13 | 	}
14 | 	static std::string version() {
15 | 		return "(?)";
16 | 	}
17 | 
18 | 	template <typename T>
19 | 	struct OutOfPlace : public OutOfPlaceRunner<T> {
20 | 		kissfft<T> fftForward;
21 | 
22 | 		OutOfPlace(size_t size) : OutOfPlaceRunner<T>(size), fftForward(size, false) {}
23 | 
24 | 		void forward(std::complex<T> *input, std::complex<T> *output) {
25 | 			fftForward.transform(input, output);
26 | 		}
27 | 	};
28 | 
29 | 	using DoubleOutOfPlace = OutOfPlace<double>;
30 | };
31 | Benchmark<Kiss> benchKiss;
32 | 


--------------------------------------------------------------------------------
/benchmark/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | 
 3 | #include "benchmark.h"
 4 | 
 5 | struct Signalsmith {
 6 | 	static std::string name() {
 7 | 		return "Signalsmith";
 8 | 	}
 9 | 	static std::string resultTag() {
10 | 		return "signalsmith";
11 | 	}
12 | 	static std::string version() {
13 | 		return "(development)";
14 | 	}
15 | 
16 | 	template <typename T>
17 | 	struct OutOfPlace : public OutOfPlaceRunner<T> {
18 | 		signalsmith::FFT<T> fft;
19 | 		OutOfPlace(size_t size) : OutOfPlaceRunner<T>(size), fft(size) {}
20 | 
21 | 		void forward(std::complex<T> *input, std::complex<T> *output) {
22 | 			fft.fft(input, output);
23 | 		}
24 | 	};
25 | 
26 | 	using DoubleOutOfPlace = OutOfPlace<double>;
27 | };
28 | Benchmark<Signalsmith> benchSignalsmith;
29 | 


--------------------------------------------------------------------------------
/benchmark/others/contents.txt:
--------------------------------------------------------------------------------
 1 | kissfft/
 2 | 	cloned from https://github.com/mborgerding/kissfft.git
 3 | 
 4 | fftw-3.3.8/
 5 | 	downloaded from http://www.fftw.org/fftw-3.3.8.tar.gz
 6 | 	(via http://www.fftw.org/download.html)
 7 | 
 8 | 	compiled as:
 9 | 	./configure --enable-sse2 --enable-avx --enable-avx2
10 | 		(I tried --enable-avx-128-fma --enable-generic-simd128 --enable-generic-simd256 and it came out slower?)
11 | 		(There are more flags on the FFTW site, but I couldn't get them to build)
12 | 


--------------------------------------------------------------------------------
/common/console-colours.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef _CONSOLE_COLOURS_H
 3 | #define _CONSOLE_COLOURS_H
 4 | 
 5 | #include <string>
 6 | 
 7 | namespace Console {
 8 | 	std::string Reset = "\x1b[0m";
 9 | 	std::string Bright = "\x1b[1m";
10 | 	std::string Dim = "\x1b[2m";
11 | 	std::string Underscore = "\x1b[4m";
12 | 	std::string Blink = "\x1b[5m";
13 | 	std::string Reverse = "\x1b[7m";
14 | 	std::string Hidden = "\x1b[8m";
15 | 
16 | 	namespace Foreground {
17 | 		std::string Black = "\x1b[30m";
18 | 		std::string Red = "\x1b[31m";
19 | 		std::string Green = "\x1b[32m";
20 | 		std::string Yellow = "\x1b[33m";
21 | 		std::string Blue = "\x1b[34m";
22 | 		std::string Magenta = "\x1b[35m";
23 | 		std::string Cyan = "\x1b[36m";
24 | 		std::string White = "\x1b[37m";
25 | 	}
26 | 
27 | 	namespace Background {
28 | 		std::string Black = "\x1b[40m";
29 | 		std::string Red = "\x1b[41m";
30 | 		std::string Green = "\x1b[42m";
31 | 		std::string Yellow = "\x1b[43m";
32 | 		std::string Blue = "\x1b[44m";
33 | 		std::string Magenta = "\x1b[45m";
34 | 		std::string Cyan = "\x1b[46m";
35 | 		std::string White = "\x1b[47m";
36 | 	}
37 | 
38 | 	using namespace Foreground;
39 | }
40 | 
41 | #endif


--------------------------------------------------------------------------------
/common/csv.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstring>
 4 | #include <string>
 5 | #include <vector>
 6 | #include <fstream>
 7 | 
 8 | namespace csv {
 9 | 	class RowReader {
10 | 		std::ifstream ifstream;
11 | 		char columnSeparator = ',';
12 | 		char lineSeparator = '\n';
13 | 		char quote = '"';
14 | 
15 | 	public:
16 | 		bool open(std::string filename) {
17 | 			ifstream = std::ifstream(filename.data(), std::ifstream::in);
18 | 			if (ifstream.good()) return true;
19 | 			return false;
20 | 		}
21 | 		
22 | 		bool done() {
23 | 			return !ifstream.good() || ifstream.eof();
24 | 		}
25 | 		
26 | 		std::vector<std::string> next() {
27 | 			std::vector<std::string> result;
28 | 			if (done()) return result;
29 | 			
30 | 			constexpr int N = 1024;
31 | 			char line[N];
32 | 			ifstream.getline(line, N, lineSeparator);
33 | 			// Split line into sections
34 | 			unsigned int length = strlen(line);
35 | 			unsigned int startIndex = 0, index = 0;
36 | 			while (index <= length) {
37 | 				if (index == length || line[index] == columnSeparator) {
38 | 					unsigned int endIndex = index;
39 | 					// Strip quotes
40 | 					if (line[startIndex] == quote) startIndex++;
41 | 					if (endIndex > 0 && line[endIndex - 1] == quote) endIndex--;
42 | 
43 | 					std::string data(line + startIndex, endIndex - startIndex);
44 | 					result.push_back(data);
45 | 
46 | 					index++;
47 | 					startIndex = index;
48 | 				} else {
49 | 					if (line[index] == quote) { // Skip ahead to ending quote
50 | 						index++;
51 | 						while (index < length && line[index] != quote) {
52 | 							index++;
53 | 						}
54 | 					}
55 | 					index++;
56 | 				}
57 | 			}
58 | 			return result;
59 | 		}
60 | 	};
61 | }
62 | 


--------------------------------------------------------------------------------
/common/simple-args.h:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <string>
  3 | #include <cstring>
  4 | #include <vector>
  5 | #include <map>
  6 | 
  7 | #include "console-colours.h"
  8 | 
  9 | /** Expected use:
 10 | 
 11 | 	SimpleArgs args(argc, argv);
 12 | 
 13 | 	std::string foo = args.arg<std::string>("foo");
 14 | 	std::string bar = args.arg<std::string>("bar", "a string for Bar", "default");
 15 | 
 16 | 	// Exits if "foo" not supplied.  "bar" has a default value, so it's fine to omit
 17 | 	if (args.help(std::cerr)) return 1;
 18 | 
 19 | **/
 20 | class SimpleArgs {
 21 | 	int argc;
 22 | 	char** argv;
 23 | 
 24 | 	template<typename T>
 25 | 	T valueFromString(const char *arg);
 26 | 	
 27 | 	std::string parsedCommand;
 28 | 	struct Keywords {
 29 | 		std::string keyword;
 30 | 		std::string description;
 31 | 		bool isHelp;
 32 | 	};
 33 | 	std::vector<Keywords> keywordOptions;
 34 | 	std::vector<Keywords> argDetails;
 35 | 	std::map<std::string, Keywords> flagOptions;
 36 | 	void clearKeywords() {
 37 | 		keywordOptions.resize(0);
 38 | 		flagOptions.clear();
 39 | 	}
 40 | 	
 41 | 	bool helpMode = false;
 42 | 	bool hasError = false;
 43 | 	std::string errorMessage;
 44 | 	void setError(std::string message) {
 45 | 		if (!hasError) {
 46 | 			hasError = true;
 47 | 			errorMessage = message;
 48 | 		}
 49 | 	}
 50 | 
 51 | 	std::map<std::string, std::string> flagMap;
 52 | 	void consumeFlags() {
 53 | 		while (index < argc && std::strlen(argv[index]) > 0 && argv[index][0] == '-') {
 54 | 			const char* arg = argv[index++];
 55 | 			size_t length = strlen(arg);
 56 | 			
 57 | 			size_t keyStart = 1, keyEnd = keyStart + 1;
 58 | 			size_t valueStart = keyEnd;
 59 | 			// If it's "--long-arg" format
 60 | 			if (length > 1 && arg[1] == '-') {
 61 | 				keyStart++;
 62 | 				while (keyEnd < length && arg[keyEnd] != '=') {
 63 | 					keyEnd++;
 64 | 				}
 65 | 				valueStart = keyEnd;
 66 | 				if (keyEnd < length) valueStart++;
 67 | 			}
 68 | 
 69 | 			std::string key = std::string(arg + keyStart, keyEnd - keyStart);
 70 | 			std::string value = std::string(arg + valueStart);
 71 | 
 72 | 			flagMap[key] = value;
 73 | 	 	}
 74 | 	 }
 75 | 	
 76 | 	int index = 1;
 77 | public:
 78 | 	SimpleArgs(int argc, char* argv[]) : argc(argc), argv(argv) {
 79 | 		parsedCommand = argv[0];
 80 | 	}
 81 | 
 82 | 	int help(std::ostream& out=std::cerr) {
 83 | 		if (keywordOptions.size() > 0) {
 84 | 			parsedCommand += std::string(" <command>");
 85 | 		}
 86 | 		out << "Usage:\n\t" <<  parsedCommand << "\n\n";
 87 | 		if (keywordOptions.size() > 0) {
 88 | 			out << "Commands:\n";
 89 | 			for (unsigned int i = 0; i < keywordOptions.size(); i++) {
 90 | 				out << "\t" << keywordOptions[i].keyword;
 91 | 				if (keywordOptions[i].isHelp) out << " ...";
 92 | 				if (keywordOptions[i].description.size()) out << "  -  " << keywordOptions[i].description;
 93 | 				out << "\n";
 94 | 			}
 95 | 			out << "\n";
 96 | 		}
 97 | 		if (argDetails.size() > 0) {
 98 | 			out << "Arguments:\n";
 99 | 			for (auto iter = flagOptions.begin(); iter != flagOptions.end(); iter++) {
100 | 				Keywords &pair = iter->second;
101 | 				out << "\t" << (pair.keyword.length() > 1 ? "--" : "-") << pair.keyword;
102 | 				if (pair.description.size()) out << "  -  " << pair.description;
103 | 				out << "\n";
104 | 			}
105 | 			out << "\n";
106 | 		}
107 | 		if (flagOptions.size() > 0) {
108 | 			out << "Options:\n";
109 | 			for (auto iter = flagOptions.begin(); iter != flagOptions.end(); iter++) {
110 | 				Keywords &pair = iter->second;
111 | 				out << "\t" << (pair.keyword.length() > 1 ? "--" : "-") << pair.keyword;
112 | 				if (pair.description.size()) out << "  -  " << pair.description;
113 | 				out << "\n";
114 | 			}
115 | 			out << "\n";
116 | 		}
117 | 		return hasError ? -1 : 0;
118 | 	}
119 | 
120 | 	bool error(std::ostream& out=std::cerr) {
121 | 		if (!hasError && !helpMode) return false;
122 | 		help(out);
123 | 		if (!helpMode) {
124 | 			out << Console::Red << errorMessage << Console::Reset << "\n";
125 | 		}
126 | 		return true;
127 | 	}
128 | 	bool error(std::string forcedError, std::ostream& out=std::cerr) {
129 | 		if (!hasError) {
130 | 			hasError = true;
131 | 			errorMessage = forcedError;
132 | 		}
133 | 		return error(out);
134 | 	}
135 | 	
136 | 	template<typename T>
137 | 	T arg(std::string name, std::string longName, T defaultValue) {
138 | 		clearKeywords();
139 | 		consumeFlags();
140 | 		parsedCommand += std::string(" [?") + name + "]";
141 | 		argDetails.push_back(Keywords{name, longName, false});
142 | 
143 | 		if (index >= argc) return defaultValue;
144 | 		return valueFromString<T>(argv[index++]);
145 | 	}
146 | 
147 | 	template<typename T>
148 | 	T arg(std::string name, std::string longName="") {
149 | 		clearKeywords();
150 | 		consumeFlags();
151 | 		parsedCommand += std::string(" [") + name + "]";
152 | 		argDetails.push_back(Keywords{name, longName, false});
153 | 
154 | 		if (index >= argc) {
155 | 			if (longName.length() > 0) {
156 | 				setError("Missing " + longName + " <" + name + ">");
157 | 			} else {
158 | 				setError("Missing argument <" + name + ">");
159 | 			}
160 | 			return T();
161 | 		}
162 | 
163 | 		return valueFromString<T>(argv[index++]);
164 | 	}
165 | 
166 | 	bool command(std::string keyword, std::string description="", bool isHelp=false) {
167 | 		consumeFlags();
168 | 		if (index < argc && !keyword.compare(argv[index])) {
169 | 			clearKeywords();
170 | 			index++;
171 | 			if (!isHelp) parsedCommand += std::string(" ") + keyword;
172 | 			return true;
173 | 		}
174 | 		keywordOptions.push_back(Keywords{keyword, description, isHelp});
175 | 		return false;
176 | 	}
177 | 	bool helpCommand(std::string keyword) {
178 | 		helpMode = command(keyword, "", true);
179 | 		if (helpMode) {
180 | 			keywordOptions.insert(keywordOptions.begin(), Keywords{keyword, "", true});
181 | 		}
182 | 		return helpMode;
183 | 	}
184 | 
185 | 	template<typename T=std::string>
186 | 	T flag(std::string key, std::string description, T defaultValue) {
187 | 		consumeFlags();
188 | 		if (!hasFlag(key, description)) return defaultValue;
189 | 
190 | 		auto iterator = flagMap.find(key);
191 | 		return valueFromString<T>(iterator->second.c_str());
192 | 	}
193 | 	template<typename T=std::string>
194 | 	T flag(std::string key, T defaultValue) {
195 | 		consumeFlags();
196 | 		if (!hasFlag(key, "")) return defaultValue;
197 | 
198 | 		auto iterator = flagMap.find(key);
199 | 		return valueFromString<T>(iterator->second.c_str());
200 | 	}
201 | 	template<typename T=std::string>
202 | 	T flag(std::string key) {
203 | 		return flag<T>(key, T());
204 | 	}
205 | 	bool hasFlag(std::string key, std::string description="") {
206 | 		consumeFlags();
207 | 		auto iterator = flagMap.find(key);
208 | 		if (description.length() > 0 || iterator == flagMap.end()) {
209 | 			flagOptions[key] = Keywords{key, description, false};
210 | 		}
211 | 
212 | 		iterator = flagMap.find(key);
213 | 		return iterator != flagMap.end();
214 | 	}
215 | 	bool helpFlag(std::string key, std::string description="") {
216 | 		consumeFlags();
217 | 		flagOptions[key] = Keywords{key, description, true};
218 | 		auto iterator = flagMap.find(key);
219 | 		helpMode = (iterator != flagMap.end());
220 | 		return helpMode;
221 | 	}
222 | };
223 | 
224 | template<>
225 | std::string SimpleArgs::valueFromString(const char *arg) {
226 | 	return arg;
227 | }
228 | template<>
229 | const char * SimpleArgs::valueFromString(const char *arg) {
230 | 	return arg;
231 | }
232 | template<>
233 | int SimpleArgs::valueFromString(const char *arg) {
234 | 	return std::stoi(arg);
235 | }
236 | template<>
237 | long SimpleArgs::valueFromString(const char *arg) {
238 | 	return std::stol(arg);
239 | }
240 | template<>
241 | float SimpleArgs::valueFromString(const char *arg) {
242 | 	return std::stof(arg);
243 | }
244 | template<>
245 | double SimpleArgs::valueFromString(const char *arg) {
246 | 	return std::stod(arg);
247 | }


--------------------------------------------------------------------------------
/common/sqlite-cpp.h:
--------------------------------------------------------------------------------
  1 | //extern C {
  2 | #include <sqlite3.h>
  3 | //}
  4 | 
  5 | #include <memory>
  6 | #include <string>
  7 | 
  8 | #include "console-colours.h"
  9 | 
 10 | /* Expected use:
 11 | 
 12 | 	SQLite3Versioned db("database.sqlite");
 13 | 	// Backwards-compatible structure - append to this as changes are made
 14 | 	db.bumpVersion(1, "CREATE TABLE hello_world (foo INTEGER, bar TEXT)");
 15 | 	
 16 | 	// Template-based query
 17 | 	auto find = db.statement("SELECT bar FROM hello_world WHERE foo=@foo");
 18 | 	// Specify values by index, or by string
 19 | 	find->bind(1, 123);
 20 | 	find->bind<double>("foo", 456); // can explicitly set type
 21 | 	
 22 | 	// Step through result
 23 | 	if (find->step()) {
 24 | 		std::string bar = find->get<std::string>(0);
 25 | 		...
 26 | 	}
 27 | 	
 28 | 	// Transactions are mostly used for efficiency.  If you have multiple threads, re-consider using SQLite.
 29 | 	{
 30 | 		auto transaction = db.transaction();
 31 | 		
 32 | 		auto query = db.statement(...);
 33 | 	}
 34 | */
 35 | 
 36 | class SQLite3 {
 37 | 	std::string filename;
 38 | 	sqlite3* m_db = nullptr;
 39 | 
 40 | 	sqlite3* db() { // Lazy-loading
 41 | 		if (!m_db) {
 42 | #ifdef DEBUG_SQL
 43 | 	std::cout << Console::Blue << "lazy-loading SQL file: " << filename << Console::Reset << "\n";
 44 | #endif
 45 | 			int resultCode = sqlite3_open(filename.c_str(), &m_db);
 46 | 			if (resultCode) {
 47 | 				error = 0;
 48 | 				errorMessage = std::string(sqlite3_errmsg(m_db));
 49 | 				sqlite3_close(m_db);
 50 | 				m_db = nullptr;
 51 | 
 52 | 				std::cerr << Console::Bright << Console::Red << "SQL error: " << error  << " - " << errorMessage << Console::Reset << "\n";
 53 | 			}
 54 | 		}
 55 | 		return m_db;
 56 | 	}
 57 | public:
 58 | 	int error = 0;
 59 | 	std::string errorMessage;
 60 | 
 61 | 	SQLite3(std::string filename) : filename(filename) {}
 62 | 	~SQLite3() {
 63 | 		if (m_db) sqlite3_close(m_db);
 64 | 	}
 65 | 	
 66 | 	class Statement {
 67 | 		SQLite3* db;
 68 | 		sqlite3_stmt* statement = 0;
 69 | 		const char * sqlRemainder = 0;
 70 | 
 71 | 		void getError(int code) {
 72 | 			error = db->error = code;
 73 | 			errorMessage = db->errorMessage = std::string(sqlite3_errmsg(db->db()));
 74 | 		}
 75 | 		void checkForError(int resultCode) {
 76 | 			if (resultCode != SQLITE_OK) {
 77 | 				getError(resultCode);
 78 | 				//statement = nullptr;
 79 | 
 80 | 				std::cerr << Console::Bright << Console::Red << "SQL error: " << error  << " - " << errorMessage << Console::Reset << "\n";
 81 | 			}
 82 | 		}
 83 | 		void customError(std::string message) {
 84 | 			error = -1;
 85 | 			errorMessage = message;
 86 | 			std::cerr << Console::Bright << Console::Red << "Error: " << message << Console::Reset << "\n";
 87 | 		}
 88 | 	public:
 89 | 		int error = 0;
 90 | 		std::string errorMessage;
 91 | 
 92 | 		Statement(SQLite3* db, std::string sqlString) : db(db) {
 93 | #ifdef DEBUG_SQL
 94 | 			std::cout << Console::Dim << sqlString << Console::Reset << "\n";
 95 | #endif
 96 | 			int resultCode = sqlite3_prepare_v2(db->db(), sqlString.c_str(), sqlString.length(), &statement, &sqlRemainder);
 97 | 			if (resultCode != SQLITE_OK) {
 98 | 				getError(resultCode);
 99 | 				statement = nullptr;
100 | 
101 | 				std::cerr << Console::Bright << Console::Red << "SQL error: " << error  << " - " << errorMessage << Console::Reset << "\n";
102 | 			}
103 | 		}
104 | 		~Statement() {
105 | 			if (statement) sqlite3_finalize(statement);
106 | 		}
107 | 		
108 | 		template<typename T>
109 | 		void bind(const char* name, T value) {
110 | 			int index = sqlite3_bind_parameter_index(statement, name);
111 | 			this->bind(index, value);
112 | 		}
113 | 		
114 | 		void bind(int index, std::string value) {
115 | 			checkForError(sqlite3_bind_text(statement, index, value.data(), value.size(), SQLITE_TRANSIENT));
116 | 		}
117 | 		void bind(int index, char const *value) {
118 | 			checkForError(sqlite3_bind_text(statement, index, value, -1, SQLITE_TRANSIENT));
119 | 		}
120 | 		void bind(int index, double value) {
121 | 			checkForError(sqlite3_bind_double(statement, index, value));
122 | 		}
123 | 		void bind(int index, int value) {
124 | 			checkForError(sqlite3_bind_int(statement, index, value));
125 | 		}
126 | 		void bind(int index, long value) {
127 | 			checkForError(sqlite3_bind_int64(statement, index, value));
128 | 		}
129 | 		void bind(int index) {
130 | 			checkForError(sqlite3_bind_null(statement, index));
131 | 		}
132 | 		void reset() {
133 | 			checkForError(sqlite3_reset(statement));
134 | 		}
135 | 
136 | 		bool step() {
137 | 			if (!statement) return false;
138 | 			int queryStatus = sqlite3_step(statement);
139 | 			if (queryStatus != SQLITE_ROW && queryStatus != SQLITE_DONE) {
140 | 				getError(queryStatus);
141 | 			}
142 | 			return queryStatus == SQLITE_ROW;
143 | 		}
144 | 
145 | 		int columns() {
146 | 			return statement ? sqlite3_column_count(statement) : 0;
147 | 		}
148 | 
149 | 		int columnType(int i) {
150 | 			return statement ? sqlite3_column_type(statement, i) : 0;
151 | 		}
152 | 
153 | 		std::string columnName(int i) {
154 | 			if (!statement) return "";
155 | 			const char* cstr = sqlite3_column_name(statement, i);
156 | 			return std::string(reinterpret_cast<const char*>(cstr));
157 | 		}
158 | 
159 | 		template <typename T=std::string>
160 | 		T get(int i);
161 | 
162 | 		template <typename T=int>
163 | 		void bind(int i, T value);
164 | 	};
165 | 
166 | 	std::shared_ptr<Statement> statement(std::string sqlString) {
167 | 		return std::make_shared<Statement>(this, sqlString);
168 | 	}
169 | 	std::shared_ptr<Statement> query(std::string sqlString) {
170 | 		return this->statement(sqlString);
171 | 	}
172 | 
173 | 	sqlite3_int64 insertId() {
174 | 		return sqlite3_last_insert_rowid(db());
175 | 	}
176 | 
177 | 	class Transaction {
178 | 		SQLite3* db;
179 | 		Statement open;
180 | 		Statement close;
181 | 	public:
182 | 		Transaction(SQLite3* db) : db(db), open(db, "BEGIN TRANSACTION"), close(db, "COMMIT TRANSACTION") {
183 | 			open.step();
184 | 		}
185 | 		~Transaction() {
186 | 			close.step();
187 | 			db->currentTransaction = nullptr;
188 | 		}
189 | 	};
190 | 
191 | 	std::shared_ptr<Transaction> transaction() {
192 | 		if (currentTransaction) return nullptr;
193 | 		return currentTransaction = std::make_shared<Transaction>(this);
194 | 	}
195 | private:
196 | 	std::shared_ptr<Transaction> currentTransaction;
197 | };
198 | 
199 | template<>
200 | int SQLite3::Statement::get<int>(int i) {
201 | 	return statement ? sqlite3_column_int(statement, i) : 0;
202 | }
203 | template<>
204 | long SQLite3::Statement::get<long>(int i) {
205 | 	return statement ? sqlite3_column_int64(statement, i) : 0;
206 | }
207 | template<>
208 | double SQLite3::Statement::get<double>(int i) {
209 | 	return statement ? sqlite3_column_double(statement, i) : 0;
210 | }
211 | template<>
212 | std::string SQLite3::Statement::get<std::string>(int i) {
213 | 	if (!statement) return "";
214 | 	const unsigned char* cstr = sqlite3_column_text(statement, i);
215 | 	if (!cstr) return "";
216 | 	return std::string(reinterpret_cast<const char*>(cstr));
217 | }
218 | 
219 | template<>
220 | void SQLite3::Statement::bind<int>(int i, int value) {
221 | 	if (statement) sqlite3_bind_int(statement, i, value);
222 | }
223 | 
224 | /********/
225 | 
226 | class SQLite3Versioned : public SQLite3 {
227 | 	int userVersion = 0;
228 | 	bool versionSuccess = true;
229 | public:
230 | 	SQLite3Versioned(std::string filename) : SQLite3(filename) {
231 | 		auto query = statement("PRAGMA user_version");
232 | 		query->step();
233 | 		userVersion = query->get<int>(0);
234 | 	}
235 | 
236 | 	/* Use to create sequence of changes which upgrade old DBs, like:
237 | 		db.bumpVersion(1, "CREATE TABLE hello_world (foo INTEGER, bar TEXT)");
238 | 		db.bumpVersion(2, "ALTER TABLE hello_world ADD beep FLOAT");
239 | 	*/
240 | 	bool bumpVersion(int version, std::string sql) {
241 | 		if (!versionSuccess) return false; // Fail once, don't continue
242 | 		if (userVersion < version) {
243 | 			userVersion = version;
244 | 			auto query = statement(sql);
245 | 			if (query->error) return versionSuccess = false;
246 | 			query->step();
247 | 			if (query->error) return versionSuccess = false;
248 | 
249 | 			query = statement(std::string("PRAGMA user_version=") + std::to_string(version));
250 | 			if (query->error) return versionSuccess = false;
251 | 			query->step();
252 | 			return true;
253 | 		}
254 | 		return versionSuccess;
255 | 	}
256 | };
257 | 


--------------------------------------------------------------------------------
/common/test/example-test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | #include <vector>
 4 | 
 5 | // from the shared library
 6 | #include <test/tests.h>
 7 | 
 8 | TEST("Example test", example_test) {
 9 | 	if (false) test.fail("it failed");
10 | }
11 | 
12 | struct TestObject {
13 | 	TEST_METHOD("Example method-test", example_test) {
14 | 		if (false) test.fail("it failed");
15 | 	}
16 | };
17 | TestObject myObject; // Can be customised/templated
18 | 
19 | TEST("Example benchmark", example_benchmarks) {
20 | 	std::vector<int> configs = {10, 100, 1000};
21 | 
22 | 	std::cout << "size:\t";
23 | 	BenchmarkRate::print(configs);
24 | 
25 | 	std::cout << "rate:\t";
26 | 	std::vector<double> rates = BenchmarkRate::map<int>(configs, [](int config, int repeats, Timer &timer) {
27 | 		timer.scaleRate(config/1e6); // scale to mega-ops/second
28 | 		timer.start();
29 | 
30 | 		for (int repeat = 0; repeat < repeats; ++repeat) {
31 | 			// Actual test code
32 | 			int sum = 0;
33 | 			for (int i = 0; i < config; ++i) {
34 | 				sum++;
35 | 			}
36 | 		}
37 | 
38 | 		timer.stop();
39 | 	}, true);
40 | 
41 | 	return test.pass();
42 | }


--------------------------------------------------------------------------------
/common/test/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "../simple-args.h"
 2 | #include "../console-colours.h"
 3 | 
 4 | #include "tests.h"
 5 | #include <cstdlib> // srand, rand
 6 | #include <ctime> // time
 7 | 
 8 | TestList _globalTestList;
 9 | 
10 | void Test::run(int depth, bool silent) {
11 | 	if (running) return fail("Re-entered test function");
12 | 	if (!silent) {
13 | 		std::cerr << Console::Dim;
14 | 		for (int i = 0; i < depth - 1; i++) {
15 | 			std::cerr << "  >  ";
16 | 		}
17 | 		std::cerr << Console::Cyan << "Test: "
18 | 			<< Console::Reset << Console::Cyan << testName
19 | 			<< Console::White << " (" << codeLocation << ")" << Console::Reset << std::endl;
20 | 	}
21 | 	running = true;
22 | 
23 | 	runFn(*this);
24 | 
25 | 	running = false;
26 | }
27 | 
28 | void TestList::add(Test& test) {
29 | 	if (currentlyRunning.size() > 0) {
30 | 		Test *latest = currentlyRunning[0];
31 | 		if (!latest->success) return;
32 | 		// This is a sub-test, run it immediately instead of adding it
33 | 		currentlyRunning.push_back(&test);
34 | 		test.run(currentlyRunning.size(), currentlySilent);
35 | 		currentlyRunning.pop_back();
36 | 		return;
37 | 	}
38 | 	tests.push_back(test);
39 | }
40 | 
41 | void TestList::fail(std::string reason) {
42 | 	for (auto testPtr : currentlyRunning) {
43 | 		testPtr->fail(reason);
44 | 	}
45 | }
46 | 
47 | int TestList::run(int repeats) {
48 | 	currentlySilent = false;
49 | 	for (int repeat = 0; repeat < repeats; repeat++) {
50 | 		for (unsigned int i = 0; i < tests.size(); i++) {
51 | 			Test& test = tests[i];
52 | 			currentlyRunning = {&test};
53 | 			test.run(0, currentlySilent);
54 | 			if (!test.success) {
55 | 				std::cerr << Console::Red << Console::Bright << "\nFailed: "
56 | 					<< Console::Reset << test.reason << "\n\n";
57 | 				return 1;
58 | 			}
59 | 		}
60 | 		currentlySilent = true;
61 | 	}
62 | 	currentlyRunning.resize(0);
63 | 	return 0;
64 | }
65 | 
66 | double defaultBenchmarkTime = 1;
67 | int defaultBenchmarkDivisions = 5;
68 | 
69 | int main(int argc, char* argv[]) {
70 | 	SimpleArgs args(argc, argv);
71 | 	args.helpFlag("help");
72 | 
73 | 	int repeats = args.flag<int>("repeats", "loop the tests a certain number of times", 1);
74 | 	defaultBenchmarkTime = args.flag<double>("test-time", "target per-test duration for benchmarks (excluding setup)", 1);
75 | 	defaultBenchmarkDivisions = args.flag<double>("test-divisions", "target number of sub-divisions for benchmarks", 5);
76 | 	if (args.error()) return 1;
77 | 
78 | 	int randomSeed = args.flag<int>("seed", "random seed", time(NULL));
79 | 	srand(randomSeed);
80 | 	std::cout << Console::Dim << "random seed: " << randomSeed << Console::Reset << "\n";
81 | 	return _globalTestList.run(repeats);
82 | }
83 | 


--------------------------------------------------------------------------------
/common/test/tests.h:
--------------------------------------------------------------------------------
  1 | #ifndef _TEST_FRAMEWORK_TESTS_H
  2 | #define _TEST_FRAMEWORK_TESTS_H
  3 | 
  4 | #include <iostream> // std::cout
  5 | #include <string>
  6 | #include <chrono>
  7 | #include <vector>
  8 | #include <functional>
  9 | 
 10 | class Test;
 11 | 
 12 | // A test-runner, defined statically
 13 | class TestList {
 14 | 	std::vector<Test> tests;
 15 | 	std::vector<Test*> currentlyRunning;
 16 | 	bool currentlySilent = false;
 17 | public:
 18 | 	void add(Test& test);
 19 | 	int run(int repeats=1);
 20 | 	void fail(std::string reason);
 21 | };
 22 | 
 23 | // A test object with an associated function, which adds itself to the above list
 24 | class Test {
 25 | 	using TestFn = std::function<void(Test&)>;
 26 | 
 27 | 	TestList& testList;
 28 | 	std::string codeLocation;
 29 | 	std::string testName;
 30 | 	TestFn runFn;
 31 | 
 32 | 	bool running = false;
 33 | public:
 34 | 	Test(TestList& testList, std::string codeLocation, std::string testName, TestFn fn) : testList(testList), codeLocation(codeLocation), testName(testName), runFn(fn) {
 35 | 		testList.add(*this);
 36 | 	}
 37 | 	void run(int depth, bool silent=false);
 38 | 
 39 | 	bool success = true;
 40 | 	std::string reason;
 41 | 	void fail(std::string r="") {
 42 | 		if (!success) return;
 43 | 		success = false;
 44 | 		reason = r;
 45 | 		testList.fail(reason);
 46 | 	}
 47 | 	void pass() {}
 48 | };
 49 | 
 50 | #define TEST_VAR_NAME test
 51 | // A macro to define a new test
 52 | // Use like:	TEST(some_unique_name) {...}
 53 | #define TEST(description, uniqueName) \
 54 | 	static void test_##uniqueName (Test &test); \
 55 | 	static Test Test_##uniqueName {_globalTestList, std::string(__FILE__ ":") + std::to_string(__LINE__), description, test_##uniqueName}; \
 56 | 	static void test_##uniqueName (Test &TEST_VAR_NAME)
 57 | // Use if defining test inside a struct (e.g. for templating)
 58 | #define TEST_METHOD(description, uniqueName) \
 59 | 	static void test_##uniqueName (Test &test) { \
 60 | 		testbody_##uniqueName(test); \
 61 | 	} \
 62 | 	Test Test_##uniqueName {_globalTestList, std::string(__FILE__ ":") + std::to_string(__LINE__), description, test_##uniqueName}; \
 63 | 	static void testbody_##uniqueName (Test &TEST_VAR_NAME)
 64 | 
 65 | #define FAIL(reason) TEST_VAR_NAME.fail(reason)
 66 | 
 67 | extern TestList _globalTestList;
 68 | 
 69 | /***** Benchmarking stuff *****/
 70 | 
 71 | class Timer {
 72 | 	std::chrono::high_resolution_clock::time_point startTime;
 73 | 	double totalTime = 0;
 74 | 	int segmentCount = 0;
 75 | 	double scaleFactor = 1;
 76 | public:
 77 | 	void start() {
 78 | 		startTime = std::chrono::high_resolution_clock::now();
 79 | 	}
 80 | 	double stop() {
 81 | 		std::chrono::duration<double> duration = std::chrono::high_resolution_clock::now() - startTime;
 82 | 		segmentCount++;
 83 | 		return (totalTime += duration.count());
 84 | 	}
 85 | 	void clear() {
 86 | 		totalTime = 0;
 87 | 		segmentCount = 0;
 88 | 		scaleFactor = 1;
 89 | 	}
 90 | 	void scale(double scale) {
 91 | 		scaleFactor *= scale;
 92 | 	}
 93 | 	void scaleRate(double scale) {
 94 | 		scaleFactor /= scale;
 95 | 	}
 96 | 	double time() const {
 97 | 		return totalTime;
 98 | 	}
 99 | 	double scaledTime() const {
100 | 		return totalTime*scaleFactor;
101 | 	}
102 | 	double segments() const {
103 | 		return segmentCount;
104 | 	}
105 | };
106 | 
107 | /*
108 | Executes a test function with an increasing number of repeats
109 | until a certain amount of time is spent on the computation.
110 | 
111 | Performs a few repeated measurements with shorter periods,
112 | and collects the fastest.
113 | 
114 | Example use:
115 | 
116 | 	BenchmarkRate trial([](int repeats, Timer &timer) {
117 | 		timer.start();
118 | 		// test code
119 | 		timer.stop();
120 | 	});
121 | 	trial.run(1); // spend at least a second on it
122 | 	trial.fastest // also returned from .run()
123 | 
124 | Use for a range of configurations
125 | 
126 | 	std::vector<int> configSize = {1, 2, 4, 8, 16};
127 | 	std::vector<double> rates = BenchmarkRate::map(configSize, [](int configSize, int repeats, Timer &timer) {
128 | 	
129 | 	});
130 | 
131 | */
132 | 
133 | extern double defaultBenchmarkTime;
134 | extern int defaultBenchmarkDivisions;
135 | 
136 | struct BenchmarkRate {
137 | 	using TestFunction = std::function<void(int, Timer&)>;
138 | 
139 | 	TestFunction fn;
140 | 	std::vector<double> rates;
141 | 	double fastest = 0;
142 | 	double optimistic = 0;
143 | 
144 | 	BenchmarkRate(TestFunction fn) : fn(fn) {}
145 | 
146 | 	void clear() {
147 | 		rates.resize(0);
148 | 		fastest = 0;
149 | 	}
150 | 
151 | 	double run(double targetTotalTime=0, int divisions=0) {
152 | 		if (targetTotalTime == 0) targetTotalTime = defaultBenchmarkTime;
153 | 		if (divisions == 0) divisions = defaultBenchmarkDivisions;
154 | 
155 | 		Timer timer;
156 | 		double totalTime = 0;
157 | 
158 | 		int repeats = 1;
159 | 		double targetBlockTime = std::min(targetTotalTime/(divisions + 1), 0.05); // 50ms blocks or less
160 | 		while (repeats < 1e10) {
161 | 			timer.clear();
162 | 			fn(repeats, timer);
163 | 			if (timer.segments() == 0) {
164 | 				std::cerr << "Benchmark function didn't call timer.start()/.stop()\n";
165 | 				// The test isn't calling the timer
166 | 				return 0;
167 | 			}
168 | 
169 | 			double time = timer.time();
170 | 			totalTime += time;
171 | 			if (time >= targetBlockTime) {
172 | 				break;
173 | 			} else {
174 | 				int estimatedRepeats = repeats*targetBlockTime/(time + targetBlockTime*0.01);
175 | 				repeats = std::max(repeats*2, (int)estimatedRepeats);
176 | 			}
177 | 		}
178 | 
179 | 		rates.push_back(repeats/timer.scaledTime());
180 | 
181 | 		while (totalTime < targetTotalTime) {
182 | 			timer.clear();
183 | 			fn(repeats, timer);
184 | 
185 | 			double time = timer.time();
186 | 			totalTime += time;
187 | 			rates.push_back(repeats/timer.scaledTime());
188 | 		}
189 | 
190 | 		double sum = 0;
191 | 		for (double rate : rates) {
192 | 			fastest = std::max(fastest, rate);
193 | 			sum += rate;
194 | 		}
195 | 		double mean = sum/rates.size();
196 | 
197 | 		double optimisticSum = 0;
198 | 		int optimisticCount = 0;
199 | 		for (double rate : rates) {
200 | 			if (rate >= mean) {
201 | 				optimisticSum += rate;
202 | 				optimisticCount++;
203 | 			}
204 | 		}
205 | 		optimistic = optimisticSum/optimisticCount;
206 | 		return optimistic;
207 | 	}
208 | 
209 | 	template<typename Arg>
210 | 	static std::vector<double> map(std::vector<Arg> &args, std::function<void(Arg,int,Timer&)> fn, bool print=false) {
211 | 		std::vector<double> results;
212 | 		for (Arg& arg : args) {
213 | 			BenchmarkRate trial([&, arg, fn](int repeats, Timer &timer) {
214 | 				fn(arg, repeats, timer);
215 | 			});
216 | 			results.push_back(trial.run());
217 | 		}
218 | 		if (print) {
219 | 			BenchmarkRate::print(results, true);
220 | 		}
221 | 		return results;
222 | 	}
223 | 
224 | 	template<typename T>
225 | 	static void print(std::vector<T> array, bool newline=true) {
226 | 		for (unsigned int i = 0; i < array.size(); ++i) {
227 | 			if (i > 0) std::cout << "\t";
228 | 			std::cout << array[i];
229 | 		}
230 | 		if (newline) std::cout << std::endl;
231 | 	}
232 | };
233 | 
234 | #endif


--------------------------------------------------------------------------------
/comparison.svg:
--------------------------------------------------------------------------------
   1 | <?xml version="1.0" encoding="utf-8" standalone="no"?>
   2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
   3 |   "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
   4 | <!-- Created with matplotlib (http://matplotlib.org/) -->
   5 | <svg height="279pt" version="1.1" viewBox="0 0 686 279" width="686pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
   6 |  <defs>
   7 |   <style type="text/css">
   8 | *{stroke-linecap:butt;stroke-linejoin:round;}
   9 |   </style>
  10 |  </defs>
  11 |  <g id="figure_1">
  12 |   <g id="patch_1">
  13 |    <path d="
  14 | M0 279.877
  15 | L686.941 279.877
  16 | L686.941 0
  17 | L0 0
  18 | z
  19 | " style="fill:none;"/>
  20 |   </g>
  21 |   <g id="axes_1">
  22 |    <g id="patch_2">
  23 |     <path d="
  24 | M53.5819 243.087
  25 | L667.382 243.087
  26 | L667.382 12.6872
  27 | L53.5819 12.6872
  28 | z
  29 | " style="fill:#ffffff;opacity:0.7;"/>
  30 |    </g>
  31 |    <g id="line2d_1">
  32 |     <path clip-path="url(#pda7e10456e)" d="
  33 | M53.5819 237.979
  34 | L79.1569 233.894
  35 | L94.1173 234.937
  36 | L104.732 228.718
  37 | L119.692 233.185
  38 | L130.307 229.215
  39 | L134.653 234.044
  40 | L145.267 230.71
  41 | L155.882 226.062
  42 | L160.228 232.159
  43 | L170.842 229.336
  44 | L181.457 226.346
  45 | L185.803 230.416
  46 | L196.417 227.449
  47 | L207.032 223.072
  48 | L211.378 229.641
  49 | L221.992 227.09
  50 | L232.607 224.425
  51 | L236.953 228.35
  52 | L247.567 225.407
  53 | L258.182 221.439
  54 | L262.528 227.532
  55 | L273.142 225.233
  56 | L283.757 222.697
  57 | L288.103 226.495
  58 | L298.717 224.122
  59 | L309.332 220.991
  60 | L313.678 226.392
  61 | L324.292 224.276
  62 | L334.907 222.596
  63 | L339.253 225.645
  64 | L349.867 223.286
  65 | L360.482 220.743
  66 | L364.828 225.292
  67 | L375.442 223.923
  68 | L386.057 222.57
  69 | L390.403 225.254
  70 | L401.017 223.829
  71 | L411.632 222.769
  72 | L415.978 226.151
  73 | L426.592 224.657
  74 | L437.207 224.869
  75 | L441.553 227.317
  76 | L452.167 227.843
  77 | L462.782 226.986
  78 | L467.128 230.206
  79 | L477.742 231.764
  80 | L488.357 232.238
  81 | L492.703 234.026
  82 | L503.317 234.113
  83 | L513.932 233.973
  84 | L518.278 235.249
  85 | L528.892 235.778
  86 | L539.507 236.94
  87 | L543.853 236.555
  88 | L554.467 236.659
  89 | L565.082 237.754
  90 | L569.428 237.922
  91 | L580.042 236.965
  92 | L590.657 236.781
  93 | L595.003 237.211
  94 | L605.617 237.407
  95 | L616.232 236.974
  96 | L620.578 237.449
  97 | L631.192 237.508
  98 | L641.807 238.084
  99 | L646.153 237.725
 100 | L656.767 238.293
 101 | L667.382 237.91" style="fill:none;stroke:#87694f;stroke-dasharray:5.932374,4.745900;stroke-dashoffset:0.0;stroke-width:1.1864749;"/>
 102 |    </g>
 103 |    <g id="line2d_2">
 104 |     <path clip-path="url(#pda7e10456e)" d="
 105 | M53.5819 235.908
 106 | L79.1569 229.025
 107 | L94.1173 214.7
 108 | L104.732 192.361
 109 | L119.692 169.105
 110 | L130.307 146.437
 111 | L134.653 173.658
 112 | L145.267 132.962
 113 | L155.882 125.115
 114 | L160.228 155.297
 115 | L170.842 113.989
 116 | L181.457 89.9332
 117 | L185.803 100.924
 118 | L196.417 66.9304
 119 | L207.032 58.568
 120 | L211.378 62.926
 121 | L221.992 32.9177
 122 | L232.607 32.1275
 123 | L236.953 39.7813
 124 | L247.567 31.2334
 125 | L258.182 23.7971
 126 | L262.528 79.5801
 127 | L273.142 27.2159
 128 | L283.757 37.7076
 129 | L288.103 76.6098
 130 | L298.717 48.3585
 131 | L309.332 58.1046
 132 | L313.678 80.9058
 133 | L324.292 83.8217
 134 | L334.907 81.2754
 135 | L339.253 75.442
 136 | L349.867 90.4907
 137 | L360.482 96.6295
 138 | L364.828 90.2699
 139 | L375.442 100.535
 140 | L386.057 111.907
 141 | L390.403 115.845
 142 | L401.017 121.264
 143 | L411.632 127.349
 144 | L415.978 129.339
 145 | L426.592 132.29
 146 | L437.207 134.948
 147 | L441.553 133.59
 148 | L452.167 141.577
 149 | L462.782 138.981" style="fill:none;stroke:#44a730;stroke-dasharray:3.424876,1.957072;stroke-dashoffset:0.0;stroke-width:1.22317;"/>
 150 |    </g>
 151 |    <g id="line2d_3">
 152 |     <path clip-path="url(#pda7e10456e)" d="
 153 | M53.5819 239.957
 154 | L79.1569 233.655
 155 | L94.1173 218.111
 156 | L104.732 195.14
 157 | L119.692 190.785
 158 | L130.307 168.903
 159 | L134.653 188.702
 160 | L145.267 136.176
 161 | L155.882 126.167
 162 | L160.228 190.735
 163 | L170.842 135.367
 164 | L181.457 114.148
 165 | L185.803 192.71
 166 | L196.417 158.162
 167 | L207.032 150.006
 168 | L211.378 163.257
 169 | L221.992 146.649
 170 | L232.607 142.097
 171 | L236.953 184.219
 172 | L247.567 153.104
 173 | L258.182 139.332
 174 | L262.528 180.107
 175 | L273.142 150.049
 176 | L283.757 137.928
 177 | L288.103 182.978
 178 | L298.717 160.07
 179 | L309.332 138.158
 180 | L313.678 183.289
 181 | L324.292 164.137
 182 | L334.907 146.023
 183 | L339.253 167.016
 184 | L349.867 160.222
 185 | L360.482 175.842
 186 | L364.828 180.464
 187 | L375.442 166.447
 188 | L386.057 184.146
 189 | L390.403 178.849
 190 | L401.017 182.184
 191 | L411.632 183.575
 192 | L415.978 180.069
 193 | L426.592 188.028
 194 | L437.207 193.895
 195 | L441.553 193.599
 196 | L452.167 190.481
 197 | L462.782 199.16
 198 | L467.128 194.099
 199 | L477.742 200.532
 200 | L488.357 205.306
 201 | L492.703 204.705
 202 | L503.317 210.387
 203 | L513.932 217.627
 204 | L518.278 212.48
 205 | L528.892 215.518
 206 | L539.507 221.871
 207 | L543.853 221.66
 208 | L554.467 220.555
 209 | L565.082 225.618
 210 | L569.428 226.777
 211 | L580.042 220.611
 212 | L590.657 225.588
 213 | L595.003 226.964
 214 | L605.617 220.817
 215 | L616.232 226.667
 216 | L620.578 227.247
 217 | L631.192 221.455
 218 | L641.807 227.611
 219 | L646.153 227.391
 220 | L656.767 223.071
 221 | L667.382 229.117" style="fill:none;stroke:#bb102b;stroke-dasharray:1.513200,1.513200;stroke-dashoffset:0.0;stroke-width:1.261;"/>
 222 |    </g>
 223 |    <g id="line2d_4">
 224 |     <path clip-path="url(#pda7e10456e)" d="
 225 | M53.5819 227.405
 226 | L79.1569 235.532
 227 | L94.1173 228.964
 228 | L104.732 222.967
 229 | L119.692 221.756
 230 | L130.307 215.663
 231 | L134.653 217.397
 232 | L145.267 211.587
 233 | L155.882 205.239
 234 | L160.228 212.578
 235 | L170.842 207.682
 236 | L181.457 204.275
 237 | L185.803 206.617
 238 | L196.417 202.988
 239 | L207.032 198.978
 240 | L211.378 205.182
 241 | L221.992 202.047
 242 | L232.607 200.127
 243 | L236.953 201.936
 244 | L247.567 199.052
 245 | L258.182 196.033
 246 | L262.528 201.53
 247 | L273.142 199.24
 248 | L283.757 198.38
 249 | L288.103 200.248
 250 | L298.717 198.973
 251 | L309.332 198.124
 252 | L313.678 201.606
 253 | L324.292 200.733
 254 | L334.907 201.168
 255 | L339.253 200.378
 256 | L349.867 200.326
 257 | L360.482 199.828
 258 | L364.828 201.877
 259 | L375.442 202.287
 260 | L386.057 201.096
 261 | L390.403 201.822
 262 | L401.017 201.093
 263 | L411.632 201.355
 264 | L415.978 202.634
 265 | L426.592 202.102
 266 | L437.207 200.841
 267 | L441.553 202.863
 268 | L452.167 203.593
 269 | L462.782 204.615
 270 | L467.128 207.361
 271 | L477.742 207.795
 272 | L488.357 207.691
 273 | L492.703 208.932
 274 | L503.317 209.111
 275 | L513.932 208.093
 276 | L518.278 210.789
 277 | L528.892 209.291
 278 | L539.507 209.407
 279 | L543.853 209.851
 280 | L554.467 208.633
 281 | L565.082 208.462
 282 | L569.428 210.069
 283 | L580.042 210.407
 284 | L590.657 210.511
 285 | L595.003 212.815
 286 | L605.617 211.138
 287 | L616.232 210.826
 288 | L620.578 212.262
 289 | L631.192 210.791
 290 | L641.807 211.532
 291 | L646.153 213.317
 292 | L656.767 212.626
 293 | L667.382 212.681" style="fill:none;stroke:#007ab0;stroke-linecap:square;"/>
 294 |    </g>
 295 |    <g id="matplotlib.axis_1">
 296 |     <g id="xtick_1">
 297 |      <g id="line2d_5">
 298 |       <path clip-path="url(#pda7e10456e)" d="
 299 | M53.5819 243.087
 300 | L53.5819 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 301 |      </g>
 302 |      <g id="line2d_6">
 303 |       <defs>
 304 |        <path d="
 305 | M0 0
 306 | L0 -4" id="m93b0483c22" style="stroke:#000000;stroke-width:0.5;"/>
 307 |       </defs>
 308 |       <g>
 309 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m93b0483c22" y="243.0871875"/>
 310 |       </g>
 311 |      </g>
 312 |      <g id="text_1">
 313 |       <!-- 1 -->
 314 |       <defs>
 315 |        <path d="
 316 | M37.25 0
 317 | L28.4688 0
 318 | L28.4688 56
 319 | Q25.2969 52.9844 20.1406 49.9531
 320 | Q14.9844 46.9219 10.8906 45.4062
 321 | L10.8906 53.9062
 322 | Q18.2656 57.375 23.7812 62.2969
 323 | Q29.2969 67.2344 31.5938 71.875
 324 | L37.25 71.875
 325 | z
 326 | " id="ArialMT-31"/>
 327 |       </defs>
 328 |       <g transform="translate(52.0003125 255.6765625)scale(0.12 -0.12)">
 329 |        <use xlink:href="#ArialMT-31"/>
 330 |       </g>
 331 |      </g>
 332 |     </g>
 333 |     <g id="xtick_2">
 334 |      <g id="line2d_7">
 335 |       <path clip-path="url(#pda7e10456e)" d="
 336 | M104.732 243.087
 337 | L104.732 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 338 |      </g>
 339 |      <g id="line2d_8">
 340 |       <g>
 341 |        <use style="stroke:#000000;stroke-width:0.5;" x="104.731875" xlink:href="#m93b0483c22" y="243.0871875"/>
 342 |       </g>
 343 |      </g>
 344 |      <g id="text_2">
 345 |       <!-- 4 -->
 346 |       <defs>
 347 |        <path d="
 348 | M32.3281 0
 349 | L32.3281 17.1406
 350 | L1.26562 17.1406
 351 | L1.26562 25.2031
 352 | L33.9375 71.5781
 353 | L41.1094 71.5781
 354 | L41.1094 25.2031
 355 | L50.7812 25.2031
 356 | L50.7812 17.1406
 357 | L41.1094 17.1406
 358 | L41.1094 0
 359 | z
 360 | 
 361 | M32.3281 25.2031
 362 | L32.3281 57.4688
 363 | L9.90625 25.2031
 364 | z
 365 | " id="ArialMT-34"/>
 366 |       </defs>
 367 |       <g transform="translate(101.7609375 255.6765625)scale(0.12 -0.12)">
 368 |        <use xlink:href="#ArialMT-34"/>
 369 |       </g>
 370 |      </g>
 371 |     </g>
 372 |     <g id="xtick_3">
 373 |      <g id="line2d_9">
 374 |       <path clip-path="url(#pda7e10456e)" d="
 375 | M155.882 243.087
 376 | L155.882 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 377 |      </g>
 378 |      <g id="line2d_10">
 379 |       <g>
 380 |        <use style="stroke:#000000;stroke-width:0.5;" x="155.881875" xlink:href="#m93b0483c22" y="243.0871875"/>
 381 |       </g>
 382 |      </g>
 383 |      <g id="text_3">
 384 |       <!-- 16 -->
 385 |       <defs>
 386 |        <path d="
 387 | M49.75 54.0469
 388 | L41.0156 53.375
 389 | Q39.8438 58.5469 37.7031 60.8906
 390 | Q34.125 64.6562 28.9062 64.6562
 391 | Q24.7031 64.6562 21.5312 62.3125
 392 | Q17.3906 59.2812 14.9844 53.4688
 393 | Q12.5938 47.6562 12.5 36.9219
 394 | Q15.6719 41.75 20.2656 44.0938
 395 | Q24.8594 46.4375 29.8906 46.4375
 396 | Q38.6719 46.4375 44.8438 39.9688
 397 | Q51.0312 33.5 51.0312 23.25
 398 | Q51.0312 16.5 48.125 10.7188
 399 | Q45.2188 4.9375 40.1406 1.85938
 400 | Q35.0625 -1.21875 28.6094 -1.21875
 401 | Q17.625 -1.21875 10.6875 6.85938
 402 | Q3.76562 14.9375 3.76562 33.5
 403 | Q3.76562 54.25 11.4219 63.6719
 404 | Q18.1094 71.875 29.4375 71.875
 405 | Q37.8906 71.875 43.2812 67.1406
 406 | Q48.6875 62.4062 49.75 54.0469
 407 | M13.875 23.1875
 408 | Q13.875 18.6562 15.7969 14.5
 409 | Q17.7188 10.3594 21.1875 8.17188
 410 | Q24.6562 6 28.4688 6
 411 | Q34.0312 6 38.0312 10.4844
 412 | Q42.0469 14.9844 42.0469 22.7031
 413 | Q42.0469 30.125 38.0781 34.3906
 414 | Q34.125 38.6719 28.125 38.6719
 415 | Q22.1719 38.6719 18.0156 34.3906
 416 | Q13.875 30.125 13.875 23.1875" id="ArialMT-36"/>
 417 |       </defs>
 418 |       <g transform="translate(150.136875 255.6765625)scale(0.12 -0.12)">
 419 |        <use xlink:href="#ArialMT-31"/>
 420 |        <use x="55.615234375" xlink:href="#ArialMT-36"/>
 421 |       </g>
 422 |      </g>
 423 |     </g>
 424 |     <g id="xtick_4">
 425 |      <g id="line2d_11">
 426 |       <path clip-path="url(#pda7e10456e)" d="
 427 | M207.032 243.087
 428 | L207.032 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 429 |      </g>
 430 |      <g id="line2d_12">
 431 |       <g>
 432 |        <use style="stroke:#000000;stroke-width:0.5;" x="207.031875" xlink:href="#m93b0483c22" y="243.0871875"/>
 433 |       </g>
 434 |      </g>
 435 |      <g id="text_4">
 436 |       <!-- 64 -->
 437 |       <g transform="translate(200.874375 255.6765625)scale(0.12 -0.12)">
 438 |        <use xlink:href="#ArialMT-36"/>
 439 |        <use x="55.615234375" xlink:href="#ArialMT-34"/>
 440 |       </g>
 441 |      </g>
 442 |     </g>
 443 |     <g id="xtick_5">
 444 |      <g id="line2d_13">
 445 |       <path clip-path="url(#pda7e10456e)" d="
 446 | M258.182 243.087
 447 | L258.182 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 448 |      </g>
 449 |      <g id="line2d_14">
 450 |       <g>
 451 |        <use style="stroke:#000000;stroke-width:0.5;" x="258.181875" xlink:href="#m93b0483c22" y="243.0871875"/>
 452 |       </g>
 453 |      </g>
 454 |      <g id="text_5">
 455 |       <!-- 256 -->
 456 |       <defs>
 457 |        <path d="
 458 | M50.3438 8.45312
 459 | L50.3438 0
 460 | L3.03125 0
 461 | Q2.9375 3.17188 4.04688 6.10938
 462 | Q5.85938 10.9375 9.82812 15.625
 463 | Q13.8125 20.3125 21.3438 26.4688
 464 | Q33.0156 36.0312 37.1094 41.625
 465 | Q41.2188 47.2188 41.2188 52.2031
 466 | Q41.2188 57.4219 37.4688 61
 467 | Q33.7344 64.5938 27.7344 64.5938
 468 | Q21.3906 64.5938 17.5781 60.7812
 469 | Q13.7656 56.9844 13.7188 50.25
 470 | L4.6875 51.1719
 471 | Q5.60938 61.2812 11.6562 66.5781
 472 | Q17.7188 71.875 27.9375 71.875
 473 | Q38.2344 71.875 44.2344 66.1562
 474 | Q50.25 60.4531 50.25 52
 475 | Q50.25 47.7031 48.4844 43.5469
 476 | Q46.7344 39.4062 42.6562 34.8125
 477 | Q38.5781 30.2188 29.1094 22.2188
 478 | Q21.1875 15.5781 18.9375 13.2031
 479 | Q16.7031 10.8438 15.2344 8.45312
 480 | z
 481 | " id="ArialMT-32"/>
 482 |        <path d="
 483 | M4.15625 18.75
 484 | L13.375 19.5312
 485 | Q14.4062 12.7969 18.1406 9.39062
 486 | Q21.875 6 27.1562 6
 487 | Q33.5 6 37.8906 10.7812
 488 | Q42.2812 15.5781 42.2812 23.4844
 489 | Q42.2812 31 38.0625 35.3438
 490 | Q33.8438 39.7031 27 39.7031
 491 | Q22.75 39.7031 19.3281 37.7656
 492 | Q15.9219 35.8438 13.9688 32.7656
 493 | L5.71875 33.8438
 494 | L12.6406 70.6094
 495 | L48.25 70.6094
 496 | L48.25 62.2031
 497 | L19.6719 62.2031
 498 | L15.8281 42.9688
 499 | Q22.2656 47.4688 29.3438 47.4688
 500 | Q38.7188 47.4688 45.1562 40.9688
 501 | Q51.6094 34.4688 51.6094 24.2656
 502 | Q51.6094 14.5469 45.9531 7.46875
 503 | Q39.0625 -1.21875 27.1562 -1.21875
 504 | Q17.3906 -1.21875 11.2031 4.25
 505 | Q5.03125 9.71875 4.15625 18.75" id="ArialMT-35"/>
 506 |       </defs>
 507 |       <g transform="translate(248.623125 255.6765625)scale(0.12 -0.12)">
 508 |        <use xlink:href="#ArialMT-32"/>
 509 |        <use x="55.615234375" xlink:href="#ArialMT-35"/>
 510 |        <use x="111.23046875" xlink:href="#ArialMT-36"/>
 511 |       </g>
 512 |      </g>
 513 |     </g>
 514 |     <g id="xtick_6">
 515 |      <g id="line2d_15">
 516 |       <path clip-path="url(#pda7e10456e)" d="
 517 | M309.332 243.087
 518 | L309.332 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 519 |      </g>
 520 |      <g id="line2d_16">
 521 |       <g>
 522 |        <use style="stroke:#000000;stroke-width:0.5;" x="309.331875" xlink:href="#m93b0483c22" y="243.0871875"/>
 523 |       </g>
 524 |      </g>
 525 |      <g id="text_6">
 526 |       <!-- 1024 -->
 527 |       <defs>
 528 |        <path d="
 529 | M4.15625 35.2969
 530 | Q4.15625 48 6.76562 55.7344
 531 | Q9.375 63.4844 14.5156 67.6719
 532 | Q19.6719 71.875 27.4844 71.875
 533 | Q33.25 71.875 37.5938 69.5469
 534 | Q41.9375 67.2344 44.7656 62.8594
 535 | Q47.6094 58.5 49.2188 52.2188
 536 | Q50.8281 45.9531 50.8281 35.2969
 537 | Q50.8281 22.7031 48.2344 14.9688
 538 | Q45.6562 7.23438 40.5 3
 539 | Q35.3594 -1.21875 27.4844 -1.21875
 540 | Q17.1406 -1.21875 11.2344 6.20312
 541 | Q4.15625 15.1406 4.15625 35.2969
 542 | M13.1875 35.2969
 543 | Q13.1875 17.6719 17.3125 11.8281
 544 | Q21.4375 6 27.4844 6
 545 | Q33.5469 6 37.6719 11.8594
 546 | Q41.7969 17.7188 41.7969 35.2969
 547 | Q41.7969 52.9844 37.6719 58.7812
 548 | Q33.5469 64.5938 27.3906 64.5938
 549 | Q21.3438 64.5938 17.7188 59.4688
 550 | Q13.1875 52.9375 13.1875 35.2969" id="ArialMT-30"/>
 551 |       </defs>
 552 |       <g transform="translate(296.92875 255.6765625)scale(0.12 -0.12)">
 553 |        <use xlink:href="#ArialMT-31"/>
 554 |        <use x="55.615234375" xlink:href="#ArialMT-30"/>
 555 |        <use x="111.23046875" xlink:href="#ArialMT-32"/>
 556 |        <use x="166.845703125" xlink:href="#ArialMT-34"/>
 557 |       </g>
 558 |      </g>
 559 |     </g>
 560 |     <g id="xtick_7">
 561 |      <g id="line2d_17">
 562 |       <path clip-path="url(#pda7e10456e)" d="
 563 | M360.482 243.087
 564 | L360.482 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 565 |      </g>
 566 |      <g id="line2d_18">
 567 |       <g>
 568 |        <use style="stroke:#000000;stroke-width:0.5;" x="360.481875" xlink:href="#m93b0483c22" y="243.0871875"/>
 569 |       </g>
 570 |      </g>
 571 |      <g id="text_7">
 572 |       <!-- 4096 -->
 573 |       <defs>
 574 |        <path d="
 575 | M5.46875 16.5469
 576 | L13.9219 17.3281
 577 | Q14.9844 11.375 18.0156 8.6875
 578 | Q21.0469 6 25.7812 6
 579 | Q29.8281 6 32.875 7.85938
 580 | Q35.9375 9.71875 37.8906 12.8125
 581 | Q39.8438 15.9219 41.1562 21.1875
 582 | Q42.4844 26.4688 42.4844 31.9375
 583 | Q42.4844 32.5156 42.4375 33.6875
 584 | Q39.7969 29.5 35.2344 26.875
 585 | Q30.6719 24.2656 25.3438 24.2656
 586 | Q16.4531 24.2656 10.2969 30.7031
 587 | Q4.15625 37.1562 4.15625 47.7031
 588 | Q4.15625 58.5938 10.5781 65.2344
 589 | Q17 71.875 26.6562 71.875
 590 | Q33.6406 71.875 39.4219 68.1094
 591 | Q45.2188 64.3594 48.2188 57.3906
 592 | Q51.2188 50.4375 51.2188 37.25
 593 | Q51.2188 23.5312 48.2344 15.4062
 594 | Q45.2656 7.28125 39.375 3.03125
 595 | Q33.5 -1.21875 25.5938 -1.21875
 596 | Q17.1875 -1.21875 11.8594 3.4375
 597 | Q6.54688 8.10938 5.46875 16.5469
 598 | M41.4531 48.1406
 599 | Q41.4531 55.7188 37.4219 60.1562
 600 | Q33.4062 64.5938 27.7344 64.5938
 601 | Q21.875 64.5938 17.5312 59.8125
 602 | Q13.1875 55.0312 13.1875 47.4062
 603 | Q13.1875 40.5781 17.3125 36.2969
 604 | Q21.4375 32.0312 27.4844 32.0312
 605 | Q33.5938 32.0312 37.5156 36.2969
 606 | Q41.4531 40.5781 41.4531 48.1406" id="ArialMT-39"/>
 607 |       </defs>
 608 |       <g transform="translate(347.48625 255.6765625)scale(0.12 -0.12)">
 609 |        <use xlink:href="#ArialMT-34"/>
 610 |        <use x="55.615234375" xlink:href="#ArialMT-30"/>
 611 |        <use x="111.23046875" xlink:href="#ArialMT-39"/>
 612 |        <use x="166.845703125" xlink:href="#ArialMT-36"/>
 613 |       </g>
 614 |      </g>
 615 |     </g>
 616 |     <g id="xtick_8">
 617 |      <g id="line2d_19">
 618 |       <path clip-path="url(#pda7e10456e)" d="
 619 | M411.632 243.087
 620 | L411.632 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 621 |      </g>
 622 |      <g id="line2d_20">
 623 |       <g>
 624 |        <use style="stroke:#000000;stroke-width:0.5;" x="411.631875" xlink:href="#m93b0483c22" y="243.0871875"/>
 625 |       </g>
 626 |      </g>
 627 |      <g id="text_8">
 628 |       <!-- 16384 -->
 629 |       <defs>
 630 |        <path d="
 631 | M17.6719 38.8125
 632 | Q12.2031 40.8281 9.5625 44.5312
 633 | Q6.9375 48.25 6.9375 53.4219
 634 | Q6.9375 61.2344 12.5469 66.5469
 635 | Q18.1719 71.875 27.4844 71.875
 636 | Q36.8594 71.875 42.5781 66.4219
 637 | Q48.2969 60.9844 48.2969 53.1719
 638 | Q48.2969 48.1875 45.6719 44.5
 639 | Q43.0625 40.8281 37.75 38.8125
 640 | Q44.3438 36.6719 47.7812 31.875
 641 | Q51.2188 27.0938 51.2188 20.4531
 642 | Q51.2188 11.2812 44.7188 5.03125
 643 | Q38.2344 -1.21875 27.6406 -1.21875
 644 | Q17.0469 -1.21875 10.5469 5.04688
 645 | Q4.04688 11.3281 4.04688 20.7031
 646 | Q4.04688 27.6875 7.59375 32.3906
 647 | Q11.1406 37.1094 17.6719 38.8125
 648 | M15.9219 53.7188
 649 | Q15.9219 48.6406 19.1875 45.4062
 650 | Q22.4688 42.1875 27.6875 42.1875
 651 | Q32.7656 42.1875 36.0156 45.375
 652 | Q39.2656 48.5781 39.2656 53.2188
 653 | Q39.2656 58.0625 35.9062 61.3594
 654 | Q32.5625 64.6562 27.5938 64.6562
 655 | Q22.5625 64.6562 19.2344 61.4219
 656 | Q15.9219 58.2031 15.9219 53.7188
 657 | M13.0938 20.6562
 658 | Q13.0938 16.8906 14.875 13.375
 659 | Q16.6562 9.85938 20.1719 7.92188
 660 | Q23.6875 6 27.7344 6
 661 | Q34.0312 6 38.125 10.0469
 662 | Q42.2344 14.1094 42.2344 20.3594
 663 | Q42.2344 26.7031 38.0156 30.8594
 664 | Q33.7969 35.0156 27.4375 35.0156
 665 | Q21.2344 35.0156 17.1562 30.9062
 666 | Q13.0938 26.8125 13.0938 20.6562" id="ArialMT-38"/>
 667 |        <path d="
 668 | M4.20312 18.8906
 669 | L12.9844 20.0625
 670 | Q14.5 12.5938 18.1406 9.29688
 671 | Q21.7812 6 27 6
 672 | Q33.2031 6 37.4688 10.2969
 673 | Q41.75 14.5938 41.75 20.9531
 674 | Q41.75 27 37.7969 30.9219
 675 | Q33.8438 34.8594 27.7344 34.8594
 676 | Q25.25 34.8594 21.5312 33.8906
 677 | L22.5156 41.6094
 678 | Q23.3906 41.5 23.9219 41.5
 679 | Q29.5469 41.5 34.0312 44.4219
 680 | Q38.5312 47.3594 38.5312 53.4688
 681 | Q38.5312 58.2969 35.25 61.4688
 682 | Q31.9844 64.6562 26.8125 64.6562
 683 | Q21.6875 64.6562 18.2656 61.4219
 684 | Q14.8438 58.2031 13.875 51.7656
 685 | L5.07812 53.3281
 686 | Q6.6875 62.1562 12.3906 67.0156
 687 | Q18.1094 71.875 26.6094 71.875
 688 | Q32.4688 71.875 37.3906 69.3594
 689 | Q42.3281 66.8438 44.9375 62.5
 690 | Q47.5625 58.1562 47.5625 53.2656
 691 | Q47.5625 48.6406 45.0625 44.8281
 692 | Q42.5781 41.0156 37.7031 38.7656
 693 | Q44.0469 37.3125 47.5625 32.6875
 694 | Q51.0781 28.0781 51.0781 21.1406
 695 | Q51.0781 11.7656 44.2344 5.25
 696 | Q37.4062 -1.26562 26.9531 -1.26562
 697 | Q17.5312 -1.26562 11.2969 4.34375
 698 | Q5.07812 9.96875 4.20312 18.8906" id="ArialMT-33"/>
 699 |       </defs>
 700 |       <g transform="translate(395.8921875 255.6765625)scale(0.12 -0.12)">
 701 |        <use xlink:href="#ArialMT-31"/>
 702 |        <use x="55.615234375" xlink:href="#ArialMT-36"/>
 703 |        <use x="111.23046875" xlink:href="#ArialMT-33"/>
 704 |        <use x="166.845703125" xlink:href="#ArialMT-38"/>
 705 |        <use x="222.4609375" xlink:href="#ArialMT-34"/>
 706 |       </g>
 707 |      </g>
 708 |     </g>
 709 |     <g id="xtick_9">
 710 |      <g id="line2d_21">
 711 |       <path clip-path="url(#pda7e10456e)" d="
 712 | M462.782 243.087
 713 | L462.782 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 714 |      </g>
 715 |      <g id="line2d_22">
 716 |       <g>
 717 |        <use style="stroke:#000000;stroke-width:0.5;" x="462.781875" xlink:href="#m93b0483c22" y="243.0871875"/>
 718 |       </g>
 719 |      </g>
 720 |      <g id="text_9">
 721 |       <!-- 65536 -->
 722 |       <g transform="translate(446.5996875 255.6765625)scale(0.12 -0.12)">
 723 |        <use xlink:href="#ArialMT-36"/>
 724 |        <use x="55.615234375" xlink:href="#ArialMT-35"/>
 725 |        <use x="111.23046875" xlink:href="#ArialMT-35"/>
 726 |        <use x="166.845703125" xlink:href="#ArialMT-33"/>
 727 |        <use x="222.4609375" xlink:href="#ArialMT-36"/>
 728 |       </g>
 729 |      </g>
 730 |     </g>
 731 |     <g id="xtick_10">
 732 |      <g id="line2d_23">
 733 |       <path clip-path="url(#pda7e10456e)" d="
 734 | M513.932 243.087
 735 | L513.932 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 736 |      </g>
 737 |      <g id="line2d_24">
 738 |       <g>
 739 |        <use style="stroke:#000000;stroke-width:0.5;" x="513.931875" xlink:href="#m93b0483c22" y="243.0871875"/>
 740 |       </g>
 741 |      </g>
 742 |      <g id="text_10">
 743 |       <!-- 2^18 -->
 744 |       <defs>
 745 |        <path d="
 746 | M11.6719 33.6875
 747 | L2.64062 33.6875
 748 | L19.875 72.7969
 749 | L26.9531 72.7969
 750 | L44.2812 33.6875
 751 | L35.4531 33.6875
 752 | L23.3906 62.8438
 753 | z
 754 | " id="ArialMT-5e"/>
 755 |       </defs>
 756 |       <g transform="translate(501.5465625 255.6765625)scale(0.12 -0.12)">
 757 |        <use xlink:href="#ArialMT-32"/>
 758 |        <use x="55.615234375" xlink:href="#ArialMT-5e"/>
 759 |        <use x="102.5390625" xlink:href="#ArialMT-31"/>
 760 |        <use x="158.154296875" xlink:href="#ArialMT-38"/>
 761 |       </g>
 762 |      </g>
 763 |     </g>
 764 |     <g id="xtick_11">
 765 |      <g id="line2d_25">
 766 |       <path clip-path="url(#pda7e10456e)" d="
 767 | M565.082 243.087
 768 | L565.082 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 769 |      </g>
 770 |      <g id="line2d_26">
 771 |       <g>
 772 |        <use style="stroke:#000000;stroke-width:0.5;" x="565.081875" xlink:href="#m93b0483c22" y="243.0871875"/>
 773 |       </g>
 774 |      </g>
 775 |      <g id="text_11">
 776 |       <!-- 2^20 -->
 777 |       <g transform="translate(552.72 255.6765625)scale(0.12 -0.12)">
 778 |        <use xlink:href="#ArialMT-32"/>
 779 |        <use x="55.615234375" xlink:href="#ArialMT-5e"/>
 780 |        <use x="102.5390625" xlink:href="#ArialMT-32"/>
 781 |        <use x="158.154296875" xlink:href="#ArialMT-30"/>
 782 |       </g>
 783 |      </g>
 784 |     </g>
 785 |     <g id="xtick_12">
 786 |      <g id="line2d_27">
 787 |       <path clip-path="url(#pda7e10456e)" d="
 788 | M616.232 243.087
 789 | L616.232 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 790 |      </g>
 791 |      <g id="line2d_28">
 792 |       <g>
 793 |        <use style="stroke:#000000;stroke-width:0.5;" x="616.231875" xlink:href="#m93b0483c22" y="243.0871875"/>
 794 |       </g>
 795 |      </g>
 796 |      <g id="text_12">
 797 |       <!-- 2^22 -->
 798 |       <g transform="translate(603.8990625 255.6765625)scale(0.12 -0.12)">
 799 |        <use xlink:href="#ArialMT-32"/>
 800 |        <use x="55.615234375" xlink:href="#ArialMT-5e"/>
 801 |        <use x="102.5390625" xlink:href="#ArialMT-32"/>
 802 |        <use x="158.154296875" xlink:href="#ArialMT-32"/>
 803 |       </g>
 804 |      </g>
 805 |     </g>
 806 |     <g id="xtick_13">
 807 |      <g id="line2d_29">
 808 |       <path clip-path="url(#pda7e10456e)" d="
 809 | M667.382 243.087
 810 | L667.382 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
 811 |      </g>
 812 |      <g id="line2d_30">
 813 |       <g>
 814 |        <use style="stroke:#000000;stroke-width:0.5;" x="667.381875" xlink:href="#m93b0483c22" y="243.0871875"/>
 815 |       </g>
 816 |      </g>
 817 |      <g id="text_13">
 818 |       <!-- 2^24 -->
 819 |       <g transform="translate(655.0228125 255.6765625)scale(0.12 -0.12)">
 820 |        <use xlink:href="#ArialMT-32"/>
 821 |        <use x="55.615234375" xlink:href="#ArialMT-5e"/>
 822 |        <use x="102.5390625" xlink:href="#ArialMT-32"/>
 823 |        <use x="158.154296875" xlink:href="#ArialMT-34"/>
 824 |       </g>
 825 |      </g>
 826 |     </g>
 827 |     <g id="xtick_14">
 828 |      <g id="line2d_31">
 829 |       <defs>
 830 |        <path d="
 831 | M0 0
 832 | L0 -2" id="m177f7580d0" style="stroke:#000000;stroke-width:0.5;"/>
 833 |       </defs>
 834 |       <g>
 835 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m177f7580d0" y="243.0871875"/>
 836 |       </g>
 837 |      </g>
 838 |     </g>
 839 |     <g id="xtick_15">
 840 |      <g id="line2d_32">
 841 |       <g>
 842 |        <use style="stroke:#000000;stroke-width:0.5;" x="104.731875" xlink:href="#m177f7580d0" y="243.0871875"/>
 843 |       </g>
 844 |      </g>
 845 |     </g>
 846 |     <g id="xtick_16">
 847 |      <g id="line2d_33">
 848 |       <g>
 849 |        <use style="stroke:#000000;stroke-width:0.5;" x="155.881875" xlink:href="#m177f7580d0" y="243.0871875"/>
 850 |       </g>
 851 |      </g>
 852 |     </g>
 853 |     <g id="xtick_17">
 854 |      <g id="line2d_34">
 855 |       <g>
 856 |        <use style="stroke:#000000;stroke-width:0.5;" x="207.031875" xlink:href="#m177f7580d0" y="243.0871875"/>
 857 |       </g>
 858 |      </g>
 859 |     </g>
 860 |     <g id="xtick_18">
 861 |      <g id="line2d_35">
 862 |       <g>
 863 |        <use style="stroke:#000000;stroke-width:0.5;" x="258.181875" xlink:href="#m177f7580d0" y="243.0871875"/>
 864 |       </g>
 865 |      </g>
 866 |     </g>
 867 |     <g id="xtick_19">
 868 |      <g id="line2d_36">
 869 |       <g>
 870 |        <use style="stroke:#000000;stroke-width:0.5;" x="309.331875" xlink:href="#m177f7580d0" y="243.0871875"/>
 871 |       </g>
 872 |      </g>
 873 |     </g>
 874 |     <g id="xtick_20">
 875 |      <g id="line2d_37">
 876 |       <g>
 877 |        <use style="stroke:#000000;stroke-width:0.5;" x="360.481875" xlink:href="#m177f7580d0" y="243.0871875"/>
 878 |       </g>
 879 |      </g>
 880 |     </g>
 881 |     <g id="xtick_21">
 882 |      <g id="line2d_38">
 883 |       <g>
 884 |        <use style="stroke:#000000;stroke-width:0.5;" x="411.631875" xlink:href="#m177f7580d0" y="243.0871875"/>
 885 |       </g>
 886 |      </g>
 887 |     </g>
 888 |     <g id="xtick_22">
 889 |      <g id="line2d_39">
 890 |       <g>
 891 |        <use style="stroke:#000000;stroke-width:0.5;" x="462.781875" xlink:href="#m177f7580d0" y="243.0871875"/>
 892 |       </g>
 893 |      </g>
 894 |     </g>
 895 |     <g id="xtick_23">
 896 |      <g id="line2d_40">
 897 |       <g>
 898 |        <use style="stroke:#000000;stroke-width:0.5;" x="513.931875" xlink:href="#m177f7580d0" y="243.0871875"/>
 899 |       </g>
 900 |      </g>
 901 |     </g>
 902 |     <g id="xtick_24">
 903 |      <g id="line2d_41">
 904 |       <g>
 905 |        <use style="stroke:#000000;stroke-width:0.5;" x="565.081875" xlink:href="#m177f7580d0" y="243.0871875"/>
 906 |       </g>
 907 |      </g>
 908 |     </g>
 909 |     <g id="xtick_25">
 910 |      <g id="line2d_42">
 911 |       <g>
 912 |        <use style="stroke:#000000;stroke-width:0.5;" x="616.231875" xlink:href="#m177f7580d0" y="243.0871875"/>
 913 |       </g>
 914 |      </g>
 915 |     </g>
 916 |     <g id="xtick_26">
 917 |      <g id="line2d_43">
 918 |       <g>
 919 |        <use style="stroke:#000000;stroke-width:0.5;" x="667.381875" xlink:href="#m177f7580d0" y="243.0871875"/>
 920 |       </g>
 921 |      </g>
 922 |     </g>
 923 |     <g id="text_14">
 924 |      <!-- size -->
 925 |      <defs>
 926 |       <path d="
 927 | M52.9062 25.7031
 928 | L52.9062 24.4062
 929 | L14.0938 24.4062
 930 | Q14.5 16 18.8906 11.5469
 931 | Q23.2969 7.09375 30.2969 7.09375
 932 | Q37.9062 7.09375 43.5 11.7969
 933 | L48.7031 5.29688
 934 | Q45 2 40.2969 0.140625
 935 | Q35.5938 -1.70312 30.4062 -1.70312
 936 | Q24.0938 -1.70312 19.1406 0.59375
 937 | Q14.2031 2.90625 10.8438 7
 938 | Q7.5 11.0938 5.75 16.6406
 939 | Q4 22.2031 4 28.7031
 940 | Q4 35 5.64062 40.4531
 941 | Q7.29688 45.9062 10.4375 49.8438
 942 | Q13.5938 53.7969 18.1875 56.0469
 943 | Q22.7969 58.2969 28.5938 58.2969
 944 | Q35.0938 58.2969 39.75 55.8438
 945 | Q44.4062 53.4062 47.4062 49.0469
 946 | Q50.4062 44.7031 51.75 38.7031
 947 | Q53.0938 32.7031 52.9062 25.7031
 948 | M43.2969 32.4062
 949 | Q43.2969 36.5938 42.25 39.7969
 950 | Q41.2031 43 39.25 45.1406
 951 | Q37.2969 47.2969 34.5469 48.4375
 952 | Q31.7969 49.5938 28.5938 49.5938
 953 | Q25.4062 49.5938 22.7031 48.3438
 954 | Q20 47.0938 18.0938 44.7969
 955 | Q16.2031 42.5 15.1406 39.3438
 956 | Q14.0938 36.2031 14.0938 32.4062
 957 | z
 958 | " id="TransportNew-Light-65"/>
 959 |       <path d="
 960 | M45 0
 961 | L3 0
 962 | L3 8.09375
 963 | L31.7031 48.4062
 964 | L4.5 48.4062
 965 | L4.5 56.7969
 966 | L43.5 56.7969
 967 | L43.5 48.7969
 968 | L14.5938 8.29688
 969 | L45 8.29688
 970 | z
 971 | " id="TransportNew-Light-7a"/>
 972 |       <path d="
 973 | M46.5 15.2031
 974 | Q46.5 10.9062 44.75 7.70312
 975 | Q43 4.5 40.0469 2.39062
 976 | Q37.0938 0.296875 33.1406 -0.75
 977 | Q29.2031 -1.79688 24.7969 -1.79688
 978 | Q18.7969 -1.79688 13.4375 -0.046875
 979 | Q8.09375 1.70312 3.5 5.59375
 980 | L9.40625 12.7031
 981 | Q13.2031 9.70312 17.4531 8.34375
 982 | Q21.7031 7 25.2031 7
 983 | Q27.4062 7 29.4062 7.39062
 984 | Q31.4062 7.79688 32.9062 8.6875
 985 | Q34.4062 9.59375 35.2969 11.0938
 986 | Q36.2031 12.5938 36.2031 14.7969
 987 | Q36.2031 16.4062 35.3906 17.75
 988 | Q34.5938 19.0938 33.3438 20.0469
 989 | Q32.0938 21 30.4375 21.7031
 990 | Q28.7969 22.4062 27.0938 22.9062
 991 | L17.2031 25.5
 992 | Q14.5938 26.2031 12.25 27.3906
 993 | Q9.90625 28.5938 8.09375 30.4375
 994 | Q6.29688 32.2969 5.1875 34.8438
 995 | Q4.09375 37.4062 4.09375 40.7031
 996 | Q4.09375 45 5.84375 48.3438
 997 | Q7.59375 51.7031 10.4375 53.8906
 998 | Q13.2969 56.0938 17.0469 57.25
 999 | Q20.7969 58.4062 24.9062 58.4062
1000 | Q30.2969 58.4062 35.3438 56.75
1001 | Q40.4062 55.0938 44.7031 51.9062
1002 | L39 45.2031
1003 | Q36.4062 46.9062 32.9531 48.25
1004 | Q29.5 49.5938 25.7031 49.5938
1005 | Q23.5 49.5938 21.4531 49.0938
1006 | Q19.4062 48.5938 17.8438 47.5938
1007 | Q16.2969 46.5938 15.3438 45.0469
1008 | Q14.4062 43.5 14.4062 41.4062
1009 | Q14.4062 39.0938 16 37.0938
1010 | Q17.5938 35.0938 21.7969 34
1011 | L32.2031 31.2969
1012 | Q35.0938 30.5 37.6875 29.2969
1013 | Q40.2969 28.0938 42.25 26.1875
1014 | Q44.2031 24.2969 45.3438 21.5938
1015 | Q46.5 18.9062 46.5 15.2031" id="TransportNew-Light-73"/>
1016 |       <path d="
1017 | M18.2969 73.0938
1018 | Q18.2969 70.5 16.5469 68.6406
1019 | Q14.7969 66.7969 12.2969 66.7969
1020 | Q9.70312 66.7969 7.95312 68.6406
1021 | Q6.20312 70.5 6.20312 73.0938
1022 | Q6.20312 75.7031 7.95312 77.5469
1023 | Q9.70312 79.4062 12.2969 79.4062
1024 | Q14.7969 79.4062 16.5469 77.5469
1025 | Q18.2969 75.7031 18.2969 73.0938
1026 | M17.0938 0
1027 | L7.5 0
1028 | L7.5 56.7031
1029 | L17.0938 56.7031
1030 | z
1031 | " id="TransportNew-Light-69"/>
1032 |      </defs>
1033 |      <g transform="translate(350.180625 270.4215625)scale(0.12 -0.12)">
1034 |       <use xlink:href="#TransportNew-Light-73"/>
1035 |       <use x="50.4999847412" xlink:href="#TransportNew-Light-69"/>
1036 |       <use x="75.0999755859" xlink:href="#TransportNew-Light-7a"/>
1037 |       <use x="122.099960327" xlink:href="#TransportNew-Light-65"/>
1038 |      </g>
1039 |     </g>
1040 |    </g>
1041 |    <g id="matplotlib.axis_2">
1042 |     <g id="ytick_1">
1043 |      <g id="line2d_44">
1044 |       <path clip-path="url(#pda7e10456e)" d="
1045 | M53.5819 243.087
1046 | L667.382 243.087" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
1047 |      </g>
1048 |      <g id="line2d_45">
1049 |       <defs>
1050 |        <path d="
1051 | M0 0
1052 | L4 0" id="m728421d6d4" style="stroke:#000000;stroke-width:0.5;"/>
1053 |       </defs>
1054 |       <g>
1055 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m728421d6d4" y="243.0871875"/>
1056 |       </g>
1057 |      </g>
1058 |      <g id="text_15">
1059 |       <!-- 0 -->
1060 |       <g transform="translate(43.98125 246.189375)scale(0.12 -0.12)">
1061 |        <use xlink:href="#ArialMT-30"/>
1062 |       </g>
1063 |      </g>
1064 |     </g>
1065 |     <g id="ytick_2">
1066 |      <g id="line2d_46">
1067 |       <path clip-path="url(#pda7e10456e)" d="
1068 | M53.5819 210.173
1069 | L667.382 210.173" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
1070 |      </g>
1071 |      <g id="line2d_47">
1072 |       <g>
1073 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m728421d6d4" y="210.172901786"/>
1074 |       </g>
1075 |      </g>
1076 |      <g id="text_16">
1077 |       <!-- 500 -->
1078 |       <g transform="translate(30.635 213.275089286)scale(0.12 -0.12)">
1079 |        <use xlink:href="#ArialMT-35"/>
1080 |        <use x="55.615234375" xlink:href="#ArialMT-30"/>
1081 |        <use x="111.23046875" xlink:href="#ArialMT-30"/>
1082 |       </g>
1083 |      </g>
1084 |     </g>
1085 |     <g id="ytick_3">
1086 |      <g id="line2d_48">
1087 |       <path clip-path="url(#pda7e10456e)" d="
1088 | M53.5819 177.259
1089 | L667.382 177.259" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
1090 |      </g>
1091 |      <g id="line2d_49">
1092 |       <g>
1093 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m728421d6d4" y="177.258616071"/>
1094 |       </g>
1095 |      </g>
1096 |      <g id="text_17">
1097 |       <!-- 1000 -->
1098 |       <g transform="translate(24.77 180.360803571)scale(0.12 -0.12)">
1099 |        <use xlink:href="#ArialMT-31"/>
1100 |        <use x="55.615234375" xlink:href="#ArialMT-30"/>
1101 |        <use x="111.23046875" xlink:href="#ArialMT-30"/>
1102 |        <use x="166.845703125" xlink:href="#ArialMT-30"/>
1103 |       </g>
1104 |      </g>
1105 |     </g>
1106 |     <g id="ytick_4">
1107 |      <g id="line2d_50">
1108 |       <path clip-path="url(#pda7e10456e)" d="
1109 | M53.5819 144.344
1110 | L667.382 144.344" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
1111 |      </g>
1112 |      <g id="line2d_51">
1113 |       <g>
1114 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m728421d6d4" y="144.344330357"/>
1115 |       </g>
1116 |      </g>
1117 |      <g id="text_18">
1118 |       <!-- 1500 -->
1119 |       <g transform="translate(24.77 147.446517857)scale(0.12 -0.12)">
1120 |        <use xlink:href="#ArialMT-31"/>
1121 |        <use x="55.615234375" xlink:href="#ArialMT-35"/>
1122 |        <use x="111.23046875" xlink:href="#ArialMT-30"/>
1123 |        <use x="166.845703125" xlink:href="#ArialMT-30"/>
1124 |       </g>
1125 |      </g>
1126 |     </g>
1127 |     <g id="ytick_5">
1128 |      <g id="line2d_52">
1129 |       <path clip-path="url(#pda7e10456e)" d="
1130 | M53.5819 111.43
1131 | L667.382 111.43" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
1132 |      </g>
1133 |      <g id="line2d_53">
1134 |       <g>
1135 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m728421d6d4" y="111.430044643"/>
1136 |       </g>
1137 |      </g>
1138 |      <g id="text_19">
1139 |       <!-- 2000 -->
1140 |       <g transform="translate(23.815625 114.532232143)scale(0.12 -0.12)">
1141 |        <use xlink:href="#ArialMT-32"/>
1142 |        <use x="55.615234375" xlink:href="#ArialMT-30"/>
1143 |        <use x="111.23046875" xlink:href="#ArialMT-30"/>
1144 |        <use x="166.845703125" xlink:href="#ArialMT-30"/>
1145 |       </g>
1146 |      </g>
1147 |     </g>
1148 |     <g id="ytick_6">
1149 |      <g id="line2d_54">
1150 |       <path clip-path="url(#pda7e10456e)" d="
1151 | M53.5819 78.5158
1152 | L667.382 78.5158" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
1153 |      </g>
1154 |      <g id="line2d_55">
1155 |       <g>
1156 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m728421d6d4" y="78.5157589286"/>
1157 |       </g>
1158 |      </g>
1159 |      <g id="text_20">
1160 |       <!-- 2500 -->
1161 |       <g transform="translate(23.815625 81.6179464286)scale(0.12 -0.12)">
1162 |        <use xlink:href="#ArialMT-32"/>
1163 |        <use x="55.615234375" xlink:href="#ArialMT-35"/>
1164 |        <use x="111.23046875" xlink:href="#ArialMT-30"/>
1165 |        <use x="166.845703125" xlink:href="#ArialMT-30"/>
1166 |       </g>
1167 |      </g>
1168 |     </g>
1169 |     <g id="ytick_7">
1170 |      <g id="line2d_56">
1171 |       <path clip-path="url(#pda7e10456e)" d="
1172 | M53.5819 45.6015
1173 | L667.382 45.6015" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
1174 |      </g>
1175 |      <g id="line2d_57">
1176 |       <g>
1177 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m728421d6d4" y="45.6014732143"/>
1178 |       </g>
1179 |      </g>
1180 |      <g id="text_21">
1181 |       <!-- 3000 -->
1182 |       <g transform="translate(23.9675 48.7036607143)scale(0.12 -0.12)">
1183 |        <use xlink:href="#ArialMT-33"/>
1184 |        <use x="55.615234375" xlink:href="#ArialMT-30"/>
1185 |        <use x="111.23046875" xlink:href="#ArialMT-30"/>
1186 |        <use x="166.845703125" xlink:href="#ArialMT-30"/>
1187 |       </g>
1188 |      </g>
1189 |     </g>
1190 |     <g id="ytick_8">
1191 |      <g id="line2d_58">
1192 |       <path clip-path="url(#pda7e10456e)" d="
1193 | M53.5819 12.6872
1194 | L667.382 12.6872" style="fill:none;opacity:0.15;stroke:#000000;stroke-dasharray:1.000000,3.000000;stroke-dashoffset:0.0;stroke-width:0.5;"/>
1195 |      </g>
1196 |      <g id="line2d_59">
1197 |       <g>
1198 |        <use style="stroke:#000000;stroke-width:0.5;" x="53.581875" xlink:href="#m728421d6d4" y="12.6871875"/>
1199 |       </g>
1200 |      </g>
1201 |      <g id="text_22">
1202 |       <!-- 3500 -->
1203 |       <g transform="translate(23.9675 15.789375)scale(0.12 -0.12)">
1204 |        <use xlink:href="#ArialMT-33"/>
1205 |        <use x="55.615234375" xlink:href="#ArialMT-35"/>
1206 |        <use x="111.23046875" xlink:href="#ArialMT-30"/>
1207 |        <use x="166.845703125" xlink:href="#ArialMT-30"/>
1208 |       </g>
1209 |      </g>
1210 |     </g>
1211 |     <g id="text_23">
1212 |      <!-- normalised rate -->
1213 |      <defs>
1214 |       <path d="
1215 | M33.9062 47.5938
1216 | L33 47.5938
1217 | Q29.7969 47.7031 26.75 46.6406
1218 | Q23.7031 45.5938 21.3438 43.5
1219 | Q19 41.4062 17.5938 38.2969
1220 | Q16.2031 35.2031 16.2031 31.2031
1221 | L16.2031 0
1222 | L6.5 0
1223 | L6.5 56.7969
1224 | L16.2031 56.7969
1225 | L16.2031 47.7031
1226 | Q18.7031 53.0938 23.2969 55.9375
1227 | Q27.9062 58.7969 33.9062 58.2969
1228 | z
1229 | " id="TransportNew-Light-72"/>
1230 |       <path d="
1231 | M36.2031 -0.296875
1232 | Q34.2031 -0.796875 32.0469 -1.29688
1233 | Q29.9062 -1.79688 26.5 -1.79688
1234 | Q23.4062 -1.79688 20.6562 -0.796875
1235 | Q17.9062 0.203125 15.8438 2.20312
1236 | Q13.7969 4.20312 12.5938 7.14062
1237 | Q11.4062 10.0938 11.4062 14.0938
1238 | L11.4062 48.9062
1239 | L2 48.9062
1240 | L2 56.7969
1241 | L11.4062 56.7969
1242 | L11.4062 71.5
1243 | L20.9062 75.7969
1244 | L20.9062 56.7969
1245 | L35.5938 56.7969
1246 | L35.5938 48.9062
1247 | L20.9062 48.9062
1248 | L20.9062 16.2969
1249 | Q20.9062 11.0938 22.9531 9.09375
1250 | Q25 7.09375 29.4062 7.09375
1251 | Q32 7.09375 34.7031 7.90625
1252 | z
1253 | " id="TransportNew-Light-74"/>
1254 |       <path d="
1255 | M53.0938 0
1256 | L43.5 0
1257 | L43.5 5.59375
1258 | Q40.7969 2 37 0.09375
1259 | Q33.2031 -1.79688 28.0938 -1.79688
1260 | Q22.5 -1.79688 18.0469 0.640625
1261 | Q13.5938 3.09375 10.4375 7.1875
1262 | Q7.29688 11.2969 5.64062 16.5469
1263 | Q4 21.7969 4 27.4062
1264 | Q4 33.7969 5.70312 39.25
1265 | Q7.40625 44.7031 10.5 48.75
1266 | Q13.5938 52.7969 17.9375 55.0938
1267 | Q22.2969 57.4062 27.5938 57.4062
1268 | Q32.7969 57.4062 36.75 55.5469
1269 | Q40.7031 53.7031 43.5 50.4062
1270 | L43.5 78
1271 | L53.0938 78
1272 | z
1273 | 
1274 | M43.5938 19.5938
1275 | L43.5938 35.7969
1276 | Q43.5938 38.7969 42.3438 41.0938
1277 | Q41.0938 43.4062 39.1406 44.9062
1278 | Q37.2031 46.4062 34.8906 47.2031
1279 | Q32.5938 48 30.5 48
1280 | Q26.4062 48 23.2969 46.3438
1281 | Q20.2031 44.7031 18.0938 41.8906
1282 | Q16 39.0938 14.9531 35.3906
1283 | Q13.9062 31.7031 13.9062 27.5938
1284 | Q13.9062 24 14.9531 20.3906
1285 | Q16 16.7969 18.0469 14
1286 | Q20.0938 11.2031 23.1406 9.45312
1287 | Q26.2031 7.70312 30.2031 7.70312
1288 | Q32 7.70312 34.2969 8.39062
1289 | Q36.5938 9.09375 38.6406 10.5
1290 | Q40.7031 11.9062 42.1406 14.1562
1291 | Q43.5938 16.4062 43.5938 19.5938" id="TransportNew-Light-64"/>
1292 |       <path d="
1293 | M51.7031 5.90625
1294 | L47.2969 -1.90625
1295 | Q44.4062 -1.20312 42.75 0.046875
1296 | Q41.0938 1.29688 39.4062 3.90625
1297 | Q36.5938 1.20312 32.8906 -0.25
1298 | Q29.2031 -1.70312 23.7031 -1.70312
1299 | Q19.7969 -1.70312 16.25 -0.546875
1300 | Q12.7031 0.59375 9.95312 2.75
1301 | Q7.20312 4.90625 5.59375 8.04688
1302 | Q4 11.2031 4 15.2969
1303 | Q4 21.0938 6.25 24.6406
1304 | Q8.5 28.2031 11.5938 30.1406
1305 | Q14.7031 32.0938 18.0469 32.8906
1306 | Q21.4062 33.7031 23.5938 33.9062
1307 | Q24.7969 34 26.4375 34.1406
1308 | Q28.0938 34.2969 29.9375 34.4375
1309 | Q31.7969 34.5938 33.7969 34.75
1310 | Q35.7969 34.9062 37.7031 35
1311 | L37.7031 38.4062
1312 | Q37.7031 44.4062 35.1406 46.9531
1313 | Q32.5938 49.5 27 49.5
1314 | Q23.2031 49.5 19.0469 48.3438
1315 | Q14.9062 47.2031 11.5 45.2031
1316 | L7.90625 53.0938
1317 | Q12.4062 55.5938 17.5 57
1318 | Q22.5938 58.4062 28 58.4062
1319 | Q37.5938 58.4062 42.3906 53.3438
1320 | Q47.2031 48.2969 47.2031 37.7031
1321 | L47.2031 14.7969
1322 | Q47.2031 11 48.2969 9.04688
1323 | Q49.4062 7.09375 51.7031 5.90625
1324 | M37.5938 16.2031
1325 | L37.5938 27.0938
1326 | Q34.4062 26.9062 31.5469 26.75
1327 | Q28.7031 26.5938 26.9062 26.4062
1328 | Q24.5938 26.0938 22.2969 25.6406
1329 | Q20 25.2031 18.0938 24.0938
1330 | Q16.2031 23 15 21.0469
1331 | Q13.7969 19.0938 13.7969 15.9062
1332 | Q13.7969 13.4062 14.8906 11.6562
1333 | Q16 9.90625 17.6406 8.75
1334 | Q19.2969 7.59375 21.2969 7.04688
1335 | Q23.2969 6.5 25.0938 6.5
1336 | Q30.7969 6.5 34.1875 9.09375
1337 | Q37.5938 11.7031 37.5938 16.2031" id="TransportNew-Light-61"/>
1338 |       <path id="TransportNew-Light-20"/>
1339 |       <path d="
1340 | M55 27.7031
1341 | Q55 21.2031 53.2031 15.7969
1342 | Q51.4062 10.4062 48.0938 6.5
1343 | Q44.7969 2.59375 40.0938 0.4375
1344 | Q35.4062 -1.70312 29.5938 -1.70312
1345 | Q23.7969 -1.70312 19.0938 0.4375
1346 | Q14.4062 2.59375 11.0469 6.5
1347 | Q7.70312 10.4062 5.84375 15.75
1348 | Q4 21.0938 4 27.5938
1349 | Q4 34.4062 5.70312 40.0469
1350 | Q7.40625 45.7031 10.6562 49.7969
1351 | Q13.9062 53.9062 18.6562 56.2031
1352 | Q23.4062 58.5 29.5938 58.5
1353 | Q35.7031 58.5 40.4531 56.2031
1354 | Q45.2031 53.9062 48.3906 49.7969
1355 | Q51.5938 45.7031 53.2969 40.0469
1356 | Q55 34.4062 55 27.7031
1357 | M45.5 27.5938
1358 | Q45.5 31.7031 44.4531 35.6406
1359 | Q43.4062 39.5938 41.4062 42.6875
1360 | Q39.4062 45.7969 36.4531 47.6875
1361 | Q33.5 49.5938 29.5938 49.5938
1362 | Q25.7031 49.5938 22.7031 47.6875
1363 | Q19.7031 45.7969 17.6406 42.6875
1364 | Q15.5938 39.5938 14.5938 35.6406
1365 | Q13.5938 31.7031 13.5938 27.5938
1366 | Q13.5938 23.4062 14.6406 19.7031
1367 | Q15.7031 16 17.75 13.25
1368 | Q19.7969 10.5 22.7969 8.84375
1369 | Q25.7969 7.20312 29.5938 7.20312
1370 | Q33.4062 7.20312 36.3438 8.84375
1371 | Q39.2969 10.5 41.3438 13.25
1372 | Q43.4062 16 44.4531 19.7031
1373 | Q45.5 23.4062 45.5 27.5938" id="TransportNew-Light-6f"/>
1374 |       <path d="
1375 | M80.2031 39.4062
1376 | L80.2031 0
1377 | L70.5938 0
1378 | L70.5938 38.5
1379 | Q70.5938 41.2031 69.7969 43.1406
1380 | Q69 45.0938 67.6406 46.3438
1381 | Q66.2969 47.5938 64.4375 48.25
1382 | Q62.5938 48.9062 60.5938 48.9062
1383 | Q58.5 48.9062 56.2969 47.9531
1384 | Q54.0938 47 52.2969 45.2031
1385 | Q50.5 43.4062 49.3438 40.9062
1386 | Q48.2031 38.4062 48.2031 35.2969
1387 | L48.2031 0
1388 | L38.5938 0
1389 | L38.5 38.5938
1390 | Q38.5 43.7031 36 46.3438
1391 | Q33.5 49 29 49
1392 | Q26.5 49 24.2031 48
1393 | Q21.9062 47 20.0938 45.2031
1394 | Q18.2969 43.4062 17.1875 40.9062
1395 | Q16.0938 38.4062 16.0938 35.2969
1396 | L16.0938 0
1397 | L6.5 0
1398 | L6.5 56.7969
1399 | L16.0938 56.7969
1400 | L16.0938 50.5938
1401 | Q19.5938 54.7969 23.3438 56.5469
1402 | Q27.0938 58.2969 31.2031 58.2969
1403 | Q36 58.2969 39.75 56.1875
1404 | Q43.5 54.0938 45.9062 49.9062
1405 | Q49.5938 54.5 53.4375 56.4531
1406 | Q57.2969 58.4062 61.7969 58.4062
1407 | Q66.0938 58.4062 69.5 57
1408 | Q72.9062 55.5938 75.2969 53.0938
1409 | Q77.7031 50.5938 78.9531 47.0938
1410 | Q80.2031 43.5938 80.2031 39.4062" id="TransportNew-Light-6d"/>
1411 |       <path d="
1412 | M50.2031 0
1413 | L40.5 0
1414 | L40.5 36.2031
1415 | Q40.5 42.4062 37.5938 45.7031
1416 | Q34.7031 49 29.2969 49
1417 | Q27 49 24.6406 48.2969
1418 | Q22.2969 47.5938 20.4375 45.9375
1419 | Q18.5938 44.2969 17.3906 41.6875
1420 | Q16.2031 39.0938 16.2031 35.2969
1421 | L16.2031 0
1422 | L6.5 0
1423 | L6.5 56.7969
1424 | L16.2031 56.7969
1425 | L16.2031 50.5938
1426 | Q19.4062 54.5938 23.3438 56.5
1427 | Q27.2969 58.4062 31.7031 58.4062
1428 | Q35.7969 58.4062 39.1875 56.9062
1429 | Q42.5938 55.4062 45.0469 52.75
1430 | Q47.5 50.0938 48.8438 46.4375
1431 | Q50.2031 42.7969 50.2031 38.5
1432 | z
1433 | " id="TransportNew-Light-6e"/>
1434 |       <path d="
1435 | M28.5938 -0.703125
1436 | Q26.5938 -1.20312 24.8906 -1.45312
1437 | Q23.2031 -1.70312 21 -1.70312
1438 | Q17.7031 -1.70312 15 -0.5
1439 | Q12.2969 0.703125 10.3906 2.84375
1440 | Q8.5 5 7.5 7.95312
1441 | Q6.5 10.9062 6.5 14.4062
1442 | L6.5 78
1443 | L16 78
1444 | L16 15.2969
1445 | Q16 11.4062 17.7969 9.25
1446 | Q19.5938 7.09375 23.2031 7.09375
1447 | Q24.5 7.09375 25.4531 7.25
1448 | Q26.4062 7.40625 27.5 7.70312
1449 | z
1450 | " id="TransportNew-Light-6c"/>
1451 |      </defs>
1452 |      <g transform="translate(16.56 171.57375)rotate(-90.0)scale(0.12 -0.12)">
1453 |       <use xlink:href="#TransportNew-Light-6e"/>
1454 |       <use x="56.1999969482" xlink:href="#TransportNew-Light-6f"/>
1455 |       <use x="115.199981689" xlink:href="#TransportNew-Light-72"/>
1456 |       <use x="151.099975586" xlink:href="#TransportNew-Light-6d"/>
1457 |       <use x="237.299957275" xlink:href="#TransportNew-Light-61"/>
1458 |       <use x="291.999954224" xlink:href="#TransportNew-Light-6c"/>
1459 |       <use x="322.099945068" xlink:href="#TransportNew-Light-69"/>
1460 |       <use x="346.699935913" xlink:href="#TransportNew-Light-73"/>
1461 |       <use x="397.199920654" xlink:href="#TransportNew-Light-65"/>
1462 |       <use x="454.099914551" xlink:href="#TransportNew-Light-64"/>
1463 |       <use x="513.699905396" xlink:href="#TransportNew-Light-20"/>
1464 |       <use x="545.699890137" xlink:href="#TransportNew-Light-72"/>
1465 |       <use x="581.599884033" xlink:href="#TransportNew-Light-61"/>
1466 |       <use x="636.299880981" xlink:href="#TransportNew-Light-74"/>
1467 |       <use x="674.99987793" xlink:href="#TransportNew-Light-65"/>
1468 |      </g>
1469 |     </g>
1470 |    </g>
1471 |    <g id="patch_3">
1472 |     <path d="
1473 | M53.5819 243.087
1474 | L667.382 243.087" style="fill:none;stroke:#000000;"/>
1475 |    </g>
1476 |    <g id="patch_4">
1477 |     <path d="
1478 | M53.5819 243.087
1479 | L53.5819 12.6872" style="fill:none;stroke:#000000;"/>
1480 |    </g>
1481 |    <g id="legend_1">
1482 |     <g id="patch_5">
1483 |      <path d="
1484 | M525.263 92.9184
1485 | L661.382 92.9184
1486 | L661.382 18.6872
1487 | L525.263 18.6872
1488 | L525.263 92.9184
1489 | z
1490 | " style="fill:#ffffff;opacity:0.9;stroke:#000000;stroke-width:0.3;"/>
1491 |     </g>
1492 |     <g id="line2d_60">
1493 |      <path d="
1494 | M533.663 28.8159
1495 | L550.462 28.8159" style="fill:none;stroke:#007ab0;stroke-linecap:square;"/>
1496 |     </g>
1497 |     <g id="line2d_61"/>
1498 |     <g id="text_24">
1499 |      <!-- Signalsmith -->
1500 |      <defs>
1501 |       <path d="
1502 | M61.5938 20.2969
1503 | Q61.5938 15.4062 59.7969 11.3438
1504 | Q58 7.29688 54.4531 4.39062
1505 | Q50.9062 1.5 45.5938 -0.09375
1506 | Q40.2969 -1.70312 33.2031 -1.70312
1507 | Q24.5938 -1.70312 17.1406 1.75
1508 | Q9.70312 5.20312 4 11.5
1509 | L12 18.5
1510 | Q13.7969 16.2031 16.2969 14.25
1511 | Q18.7969 12.2969 21.5938 10.8438
1512 | Q24.4062 9.40625 27.4062 8.54688
1513 | Q30.4062 7.70312 33.2031 7.70312
1514 | Q37.0938 7.70312 40.3438 8.39062
1515 | Q43.5938 9.09375 45.9375 10.5938
1516 | Q48.2969 12.0938 49.6406 14.3438
1517 | Q51 16.5938 51 19.5938
1518 | Q51 22.9062 49.75 25.2031
1519 | Q48.5 27.5 46.5469 29.0938
1520 | Q44.5938 30.7031 42.1875 31.5938
1521 | Q39.7969 32.5 37.5 33.0938
1522 | L26.2031 36
1523 | Q22.0938 37 18.3906 38.5938
1524 | Q14.7031 40.2031 11.7969 42.75
1525 | Q8.90625 45.2969 7.20312 49
1526 | Q5.5 52.7031 5.5 57.9062
1527 | Q5.5 62.2969 7.29688 66.1875
1528 | Q9.09375 70.0938 12.5469 73.0469
1529 | Q16 76 21 77.7031
1530 | Q26 79.4062 32.5 79.4062
1531 | Q36.2031 79.4062 39.8906 78.7969
1532 | Q43.5938 78.2031 47 76.9531
1533 | Q50.4062 75.7031 53.4062 73.6406
1534 | Q56.4062 71.5938 58.7969 68.5938
1535 | L50.7969 61.7969
1536 | Q47.4062 66.0938 42.5 68.0469
1537 | Q37.5938 70 32.5 70
1538 | Q29.5 70 26.5469 69.3438
1539 | Q23.5938 68.7031 21.2969 67.25
1540 | Q19 65.7969 17.5469 63.6406
1541 | Q16.0938 61.5 16.0938 58.5
1542 | Q16.0938 55.7031 17.1875 53.7031
1543 | Q18.2969 51.7031 20.25 50.2031
1544 | Q22.2031 48.7031 24.8906 47.6406
1545 | Q27.5938 46.5938 30.7031 45.7969
1546 | L40.5938 43.2031
1547 | Q51.5938 40.2969 56.5938 34.7969
1548 | Q61.5938 29.2969 61.5938 20.2969" id="TransportNew-Light-53"/>
1549 |       <path d="
1550 | M49.9062 0.5
1551 | Q49.9062 -4.79688 48.0938 -8.4375
1552 | Q46.2969 -12.0938 43.1406 -14.3906
1553 | Q40 -16.7031 35.7031 -17.75
1554 | Q31.4062 -18.7969 26.4062 -18.7969
1555 | Q21.2969 -18.7969 16.8438 -17.6875
1556 | Q12.4062 -16.5938 7.90625 -14.0938
1557 | L11.5 -5.90625
1558 | Q15.2031 -7.70312 18.8438 -8.79688
1559 | Q22.5 -9.90625 26.7969 -9.90625
1560 | Q29.5 -9.90625 32 -9.45312
1561 | Q34.5 -9 36.4531 -7.70312
1562 | Q38.4062 -6.40625 39.5469 -4.20312
1563 | Q40.7031 -2 40.7031 1.5
1564 | L40.7031 11.2031
1565 | Q38.0938 8 34.1875 6.25
1566 | Q30.2969 4.5 25.5 4.5
1567 | Q20.2969 4.5 16.2969 6.54688
1568 | Q12.2969 8.59375 9.54688 12.1875
1569 | Q6.79688 15.7969 5.39062 20.7969
1570 | Q4 25.7969 4 31.7969
1571 | Q4 37.0938 5.64062 41.9375
1572 | Q7.29688 46.7969 10.1875 50.4375
1573 | Q13.0938 54.0938 17 56.25
1574 | Q20.9062 58.4062 25.5 58.4062
1575 | Q30.9062 58.4062 34.7031 56.3438
1576 | Q38.5 54.2969 40.7031 51.0938
1577 | L40.7031 56.7031
1578 | L49.9062 56.7031
1579 | z
1580 | 
1581 | M41 31.4062
1582 | Q41 34.7969 40.1406 38
1583 | Q39.2969 41.2031 37.5938 43.6406
1584 | Q35.9062 46.0938 33.2969 47.5469
1585 | Q30.7031 49 27.2969 49
1586 | Q24 49 21.4531 47.5469
1587 | Q18.9062 46.0938 17.0938 43.6875
1588 | Q15.2969 41.2969 14.3906 38.0938
1589 | Q13.5 34.9062 13.5 31.4062
1590 | Q13.5 27.9062 14.3438 24.7031
1591 | Q15.2031 21.5 16.8906 19.0938
1592 | Q18.5938 16.7031 21.1875 15.25
1593 | Q23.7969 13.7969 27.2969 13.7969
1594 | Q31 13.7969 33.5938 15.25
1595 | Q36.2031 16.7031 37.8438 19.1406
1596 | Q39.5 21.5938 40.25 24.75
1597 | Q41 27.9062 41 31.4062" id="TransportNew-Light-67"/>
1598 |       <path d="
1599 | M49.7031 37.2969
1600 | L49.7031 0
1601 | L40 0
1602 | L40 36.4062
1603 | Q40 42.2031 37.0938 45.2031
1604 | Q34.2031 48.2031 29.2031 48.2031
1605 | Q26.5 48.2031 24.1406 47.3438
1606 | Q21.7969 46.5 20 44.7969
1607 | Q18.2031 43.0938 17.1406 40.5938
1608 | Q16.0938 38.0938 16.0938 34.9062
1609 | L16.0938 0
1610 | L6.5 0
1611 | L6.5 78
1612 | L16.0938 78
1613 | L16.0938 50.5
1614 | Q22.5 57.5938 32.0938 57.5938
1615 | Q35.7031 57.5938 38.8906 56.1406
1616 | Q42.0938 54.7031 44.5 52
1617 | Q46.9062 49.2969 48.2969 45.5469
1618 | Q49.7031 41.7969 49.7031 37.2969" id="TransportNew-Light-68"/>
1619 |      </defs>
1620 |      <g transform="translate(563.6625 33.0159375)scale(0.12 -0.12)">
1621 |       <use xlink:href="#TransportNew-Light-53"/>
1622 |       <use x="67.0999908447" xlink:href="#TransportNew-Light-69"/>
1623 |       <use x="91.6999816895" xlink:href="#TransportNew-Light-67"/>
1624 |       <use x="148.099975586" xlink:href="#TransportNew-Light-6e"/>
1625 |       <use x="204.299972534" xlink:href="#TransportNew-Light-61"/>
1626 |       <use x="258.999969482" xlink:href="#TransportNew-Light-6c"/>
1627 |       <use x="289.099960327" xlink:href="#TransportNew-Light-73"/>
1628 |       <use x="339.599945068" xlink:href="#TransportNew-Light-6d"/>
1629 |       <use x="425.799926758" xlink:href="#TransportNew-Light-69"/>
1630 |       <use x="450.399917603" xlink:href="#TransportNew-Light-74"/>
1631 |       <use x="489.099914551" xlink:href="#TransportNew-Light-68"/>
1632 |      </g>
1633 |     </g>
1634 |     <g id="line2d_62">
1635 |      <path d="
1636 | M533.663 46.4316
1637 | L550.462 46.4316" style="fill:none;stroke:#bb102b;stroke-dasharray:1.513200,1.513200;stroke-dashoffset:0.0;stroke-width:1.261;"/>
1638 |     </g>
1639 |     <g id="line2d_63"/>
1640 |     <g id="text_25">
1641 |      <!-- FFTW (estimate) -->
1642 |      <defs>
1643 |       <path d="
1644 | M53.7031 68.5938
1645 | L18.4062 68.5938
1646 | L18.4062 44.2031
1647 | L50.7031 44.2031
1648 | L50.7031 34.7969
1649 | L18.4062 34.7969
1650 | L18.4062 0
1651 | L8 0
1652 | L8 78
1653 | L53.7031 78
1654 | z
1655 | " id="TransportNew-Light-46"/>
1656 |       <path d="
1657 | M32.9062 38.9062
1658 | Q32.9062 32.2031 31.4062 25.4531
1659 | Q29.9062 18.7031 27.0469 12.5
1660 | Q24.2031 6.29688 20.0469 0.890625
1661 | Q15.9062 -4.5 10.7031 -8.59375
1662 | L6 -3.29688
1663 | Q13.9062 5 17.9531 15.8438
1664 | Q22 26.7031 22 38.9062
1665 | Q22 44.9062 20.9531 50.7969
1666 | Q19.9062 56.7031 17.9062 62.1406
1667 | Q15.9062 67.5938 12.9531 72.4375
1668 | Q10 77.2969 6.20312 81.0938
1669 | L10.9062 86.2969
1670 | Q16.0938 82.2031 20.1875 76.7969
1671 | Q24.2969 71.4062 27.1406 65.2031
1672 | Q30 59 31.4531 52.2969
1673 | Q32.9062 45.5938 32.9062 38.9062" id="TransportNew-Light-29"/>
1674 |       <path d="
1675 | M90.2969 78
1676 | L72.9062 0
1677 | L60.9062 0
1678 | L46.4062 63.5938
1679 | L31.9062 0
1680 | L19.7969 0
1681 | L2.5 78
1682 | L13.2031 78
1683 | L26.7969 16
1684 | L40.5938 78
1685 | L52.2969 78
1686 | L66 16
1687 | L79.5938 78
1688 | z
1689 | " id="TransportNew-Light-57"/>
1690 |       <path d="
1691 | M31.9062 -3.29688
1692 | L27.2031 -8.59375
1693 | Q21.9062 -4.5 17.7969 0.890625
1694 | Q13.7031 6.29688 10.8438 12.5
1695 | Q8 18.7031 6.5 25.4531
1696 | Q5 32.2031 5 38.9062
1697 | Q5 45.5938 6.45312 52.2969
1698 | Q7.90625 59 10.75 65.2031
1699 | Q13.5938 71.4062 17.6406 76.7969
1700 | Q21.7031 82.2031 27 86.2969
1701 | L31.7031 81.0938
1702 | Q27.9062 77.2969 24.9531 72.4375
1703 | Q22 67.5938 19.9531 62.1406
1704 | Q17.9062 56.7031 16.8438 50.7969
1705 | Q15.7969 44.9062 15.7969 38.9062
1706 | Q15.7969 26.7031 19.8906 15.8438
1707 | Q24 5 31.9062 -3.29688" id="TransportNew-Light-28"/>
1708 |       <path d="
1709 | M55.0938 68.5938
1710 | L33.7031 68.5938
1711 | L33.7031 0
1712 | L23.2969 0
1713 | L23.2969 68.5938
1714 | L2 68.5938
1715 | L2 78
1716 | L55.0938 78
1717 | z
1718 | " id="TransportNew-Light-54"/>
1719 |      </defs>
1720 |      <g transform="translate(563.6625 50.6315625)scale(0.12 -0.12)">
1721 |       <use xlink:href="#TransportNew-Light-46"/>
1722 |       <use x="57.1999969482" xlink:href="#TransportNew-Light-46"/>
1723 |       <use x="114.399993896" xlink:href="#TransportNew-Light-54"/>
1724 |       <use x="171.499984741" xlink:href="#TransportNew-Light-57"/>
1725 |       <use x="264.299972534" xlink:href="#TransportNew-Light-20"/>
1726 |       <use x="296.299957275" xlink:href="#TransportNew-Light-28"/>
1727 |       <use x="334.199951172" xlink:href="#TransportNew-Light-65"/>
1728 |       <use x="391.099945068" xlink:href="#TransportNew-Light-73"/>
1729 |       <use x="441.59992981" xlink:href="#TransportNew-Light-74"/>
1730 |       <use x="480.299926758" xlink:href="#TransportNew-Light-69"/>
1731 |       <use x="504.899917603" xlink:href="#TransportNew-Light-6d"/>
1732 |       <use x="591.099899292" xlink:href="#TransportNew-Light-61"/>
1733 |       <use x="645.79989624" xlink:href="#TransportNew-Light-74"/>
1734 |       <use x="684.499893188" xlink:href="#TransportNew-Light-65"/>
1735 |       <use x="741.399887085" xlink:href="#TransportNew-Light-29"/>
1736 |      </g>
1737 |     </g>
1738 |     <g id="line2d_64">
1739 |      <path d="
1740 | M533.663 64.0472
1741 | L550.462 64.0472" style="fill:none;stroke:#44a730;stroke-dasharray:3.424876,1.957072;stroke-dashoffset:0.0;stroke-width:1.22317;"/>
1742 |     </g>
1743 |     <g id="line2d_65"/>
1744 |     <g id="text_26">
1745 |      <!-- FFTW (measure) -->
1746 |      <defs>
1747 |       <path d="
1748 | M49.7031 0
1749 | L40 0
1750 | L40 6.09375
1751 | Q36.7969 2.29688 32.8438 0.296875
1752 | Q28.9062 -1.70312 24.5 -1.70312
1753 | Q20.4062 -1.70312 17 -0.203125
1754 | Q13.5938 1.29688 11.1406 4
1755 | Q8.70312 6.70312 7.34375 10.3438
1756 | Q6 14 6 18.2969
1757 | L6 56.7969
1758 | L15.7031 56.7969
1759 | L15.7031 20.5938
1760 | Q15.7031 14.4062 18.5938 11.0938
1761 | Q21.5 7.79688 26.9062 7.79688
1762 | Q29.0938 7.79688 31.4375 8.5
1763 | Q33.7969 9.20312 35.6875 10.8438
1764 | Q37.5938 12.5 38.7969 15.0938
1765 | Q40 17.7031 40 21.5
1766 | L40 56.7969
1767 | L49.7031 56.7969
1768 | z
1769 | " id="TransportNew-Light-75"/>
1770 |      </defs>
1771 |      <g transform="translate(563.6625 68.2471875)scale(0.12 -0.12)">
1772 |       <use xlink:href="#TransportNew-Light-46"/>
1773 |       <use x="57.1999969482" xlink:href="#TransportNew-Light-46"/>
1774 |       <use x="114.399993896" xlink:href="#TransportNew-Light-54"/>
1775 |       <use x="171.499984741" xlink:href="#TransportNew-Light-57"/>
1776 |       <use x="264.299972534" xlink:href="#TransportNew-Light-20"/>
1777 |       <use x="296.299957275" xlink:href="#TransportNew-Light-28"/>
1778 |       <use x="334.199951172" xlink:href="#TransportNew-Light-6d"/>
1779 |       <use x="420.399932861" xlink:href="#TransportNew-Light-65"/>
1780 |       <use x="477.299926758" xlink:href="#TransportNew-Light-61"/>
1781 |       <use x="531.999923706" xlink:href="#TransportNew-Light-73"/>
1782 |       <use x="582.499908447" xlink:href="#TransportNew-Light-75"/>
1783 |       <use x="638.699905396" xlink:href="#TransportNew-Light-72"/>
1784 |       <use x="674.599899292" xlink:href="#TransportNew-Light-65"/>
1785 |       <use x="731.499893188" xlink:href="#TransportNew-Light-29"/>
1786 |      </g>
1787 |     </g>
1788 |     <g id="line2d_66">
1789 |      <path d="
1790 | M533.663 81.6628
1791 | L550.462 81.6628" style="fill:none;stroke:#87694f;stroke-dasharray:5.932374,4.745900;stroke-dashoffset:0.0;stroke-width:1.1864749;"/>
1792 |     </g>
1793 |     <g id="line2d_67"/>
1794 |     <g id="text_27">
1795 |      <!-- KissFFT -->
1796 |      <defs>
1797 |       <path d="
1798 | M64.4062 0
1799 | L53 0
1800 | L29.9062 38.9062
1801 | L18.4062 25
1802 | L18.4062 0
1803 | L8 0
1804 | L8 78
1805 | L18.4062 78
1806 | L18.4062 39.2031
1807 | L49.9062 78
1808 | L62.5 78
1809 | L36.4062 46.0938
1810 | z
1811 | " id="TransportNew-Light-4b"/>
1812 |      </defs>
1813 |      <g transform="translate(563.6625 85.8628125)scale(0.12 -0.12)">
1814 |       <use xlink:href="#TransportNew-Light-4b"/>
1815 |       <use x="66.3999938965" xlink:href="#TransportNew-Light-69"/>
1816 |       <use x="90.9999847412" xlink:href="#TransportNew-Light-73"/>
1817 |       <use x="141.499969482" xlink:href="#TransportNew-Light-73"/>
1818 |       <use x="191.999954224" xlink:href="#TransportNew-Light-46"/>
1819 |       <use x="249.199951172" xlink:href="#TransportNew-Light-46"/>
1820 |       <use x="306.39994812" xlink:href="#TransportNew-Light-54"/>
1821 |      </g>
1822 |     </g>
1823 |    </g>
1824 |   </g>
1825 |  </g>
1826 |  <defs>
1827 |   <clipPath id="pda7e10456e">
1828 |    <rect height="231.4" width="614.8" x="53.581875" y="11.6871875"/>
1829 |   </clipPath>
1830 |  </defs>
1831 | </svg>
1832 | 


--------------------------------------------------------------------------------
/signalsmith-fft.h:
--------------------------------------------------------------------------------
  1 | #ifndef SIGNALSMITH_FFT_V5
  2 | #define SIGNALSMITH_FFT_V5
  3 | // So we can easily include multiple versions by redefining this
  4 | #ifndef SIGNALSMITH_FFT_NAMESPACE
  5 | #define SIGNALSMITH_FFT_NAMESPACE signalsmith
  6 | #endif
  7 | 
  8 | #include <vector>
  9 | #include <complex>
 10 | #include <cmath>
 11 | #include <array>
 12 | #include <memory>
 13 | 
 14 | #ifndef SIGNALSMITH_INLINE
 15 | #ifdef __GNUC__
 16 | #define SIGNALSMITH_INLINE __attribute__((always_inline)) inline
 17 | #elif defined(__MSVC__)
 18 | #define SIGNALSMITH_INLINE __forceinline inline
 19 | #else
 20 | #define SIGNALSMITH_INLINE inline
 21 | #endif
 22 | #endif
 23 | 
 24 | #ifndef M_PI
 25 | #define M_PI 3.14159265358979323846264338327950288
 26 | #endif
 27 | 
 28 | namespace SIGNALSMITH_FFT_NAMESPACE {
 29 | 
 30 | 	namespace perf {
 31 | 		// Complex multiplication has edge-cases around Inf/NaN - handling those properly makes std::complex non-inlineable, so we use our own
 32 | 		template <bool conjugateSecond, typename V>
 33 | 		SIGNALSMITH_INLINE std::complex<V> complexMul(const std::complex<V> &a, const std::complex<V> &b) {
 34 | 			return conjugateSecond ? std::complex<V>{
 35 | 				b.real()*a.real() + b.imag()*a.imag(),
 36 | 				b.real()*a.imag() - b.imag()*a.real()
 37 | 			} : std::complex<V>{
 38 | 				a.real()*b.real() - a.imag()*b.imag(),
 39 | 				a.real()*b.imag() + a.imag()*b.real()
 40 | 			};
 41 | 		}
 42 | 
 43 | 		template<bool flipped, typename V>
 44 | 		SIGNALSMITH_INLINE std::complex<V> complexAddI(const std::complex<V> &a, const std::complex<V> &b) {
 45 | 			return flipped ? std::complex<V>{
 46 | 				a.real() + b.imag(),
 47 | 				a.imag() - b.real()
 48 | 			} : std::complex<V>{
 49 | 				a.real() - b.imag(),
 50 | 				a.imag() + b.real()
 51 | 			};
 52 | 		}
 53 | 	}
 54 | 	
 55 | 	// Use SFINAE to get an iterator from std::begin(), if supported - otherwise assume the value itself is an iterator
 56 | 	template<typename T, typename=void>
 57 | 	struct GetIterator {
 58 | 		static T get(const T &t) {
 59 | 			return t;
 60 | 		}
 61 | 	};
 62 | 	template<typename T>
 63 | 	struct GetIterator<T, decltype((void)std::begin(std::declval<T>()))> {
 64 | 		static auto get(const T &t) -> decltype(std::begin(t)) {
 65 | 			return std::begin(t);
 66 | 		}
 67 | 	};
 68 | 
 69 | 	template<typename V>
 70 | 	class FFT {
 71 | 		using complex = std::complex<V>;
 72 | 		size_t _size;
 73 | 		std::vector<complex> workingVector;
 74 | 		
 75 | 		enum class StepType {
 76 | 			generic, step2, step3, step4
 77 | 		};
 78 | 		struct Step {
 79 | 			StepType type;
 80 | 			size_t factor;
 81 | 			size_t startIndex;
 82 | 			size_t innerRepeats;
 83 | 			size_t outerRepeats;
 84 | 			size_t twiddleIndex;
 85 | 		};
 86 | 		std::vector<size_t> factors;
 87 | 		std::vector<Step> plan;
 88 | 		std::vector<complex> twiddleVector;
 89 | 		
 90 | 		struct PermutationPair {size_t from, to;};
 91 | 		std::vector<PermutationPair> permutation;
 92 | 		
 93 | 		void addPlanSteps(size_t factorIndex, size_t start, size_t length, size_t repeats) {
 94 | 			if (factorIndex >= factors.size()) return;
 95 | 			
 96 | 			size_t factor = factors[factorIndex];
 97 | 			if (factorIndex + 1 < factors.size()) {
 98 | 				if (factors[factorIndex] == 2 && factors[factorIndex + 1] == 2) {
 99 | 					++factorIndex;
100 | 					factor = 4;
101 | 				}
102 | 			}
103 | 
104 | 			size_t subLength = length/factor;
105 | 			Step mainStep{StepType::generic, factor, start, subLength, repeats, twiddleVector.size()};
106 | 
107 | 			if (factor == 2) mainStep.type = StepType::step2;
108 | 			if (factor == 3) mainStep.type = StepType::step3;
109 | 			if (factor == 4) mainStep.type = StepType::step4;
110 | 
111 | 			// Twiddles
112 | 			bool foundStep = false;
113 | 			for (const Step &existingStep : plan) {
114 | 				if (existingStep.factor == mainStep.factor && existingStep.innerRepeats == mainStep.innerRepeats) {
115 | 					foundStep = true;
116 | 					mainStep.twiddleIndex = existingStep.twiddleIndex;
117 | 					break;
118 | 				}
119 | 			}
120 | 			if (!foundStep) {
121 | 				for (size_t i = 0; i < subLength; ++i) {
122 | 					for (size_t f = 0; f < factor; ++f) {
123 | 						V phase = 2*M_PI*i*f/length;
124 | 						complex twiddle = {cos(phase), -sin(phase)};
125 | 						twiddleVector.push_back(twiddle);
126 | 					}
127 | 				}
128 | 			}
129 | 
130 | 			if (repeats == 1 && sizeof(complex)*subLength > 65536) {
131 | 				for (size_t i = 0; i < factor; ++i) {
132 | 					addPlanSteps(factorIndex + 1, start + i*subLength, subLength, 1);
133 | 				}
134 | 			} else {
135 | 				addPlanSteps(factorIndex + 1, start, subLength, repeats*factor);
136 | 			}
137 | 			plan.push_back(mainStep);
138 | 		}
139 | 		void setPlan() {
140 | 			factors.resize(0);
141 | 			size_t size = _size, f = 2;
142 | 			while (size > 1) {
143 | 				if (size%f == 0) {
144 | 					factors.push_back(f);
145 | 					size /= f;
146 | 				} else if (f > sqrt(size)) {
147 | 					f = size;
148 | 				} else {
149 | 					++f;
150 | 				}
151 | 			}
152 | 
153 | 			plan.resize(0);
154 | 			twiddleVector.resize(0);
155 | 			addPlanSteps(0, 0, _size, 1);
156 | 			
157 | 			permutation.resize(0);
158 | 			permutation.push_back(PermutationPair{0, 0});
159 | 			size_t indexLow = 0, indexHigh = factors.size();
160 | 			size_t inputStepLow = _size, outputStepLow = 1;
161 | 			size_t inputStepHigh = 1, outputStepHigh = _size;
162 | 			while (outputStepLow*inputStepHigh < _size) {
163 | 				size_t f, inputStep, outputStep;
164 | 				if (outputStepLow <= inputStepHigh) {
165 | 					f = factors[indexLow++];
166 | 					inputStep = (inputStepLow /= f);
167 | 					outputStep = outputStepLow;
168 | 					outputStepLow *= f;
169 | 				} else {
170 | 					f = factors[--indexHigh];
171 | 					inputStep = inputStepHigh;
172 | 					inputStepHigh *= f;
173 | 					outputStep = (outputStepHigh /= f);
174 | 				}
175 | 				size_t oldSize = permutation.size();
176 | 				for (size_t i = 1; i < f; ++i) {
177 | 					for (size_t j = 0; j < oldSize; ++j) {
178 | 						PermutationPair pair = permutation[j];
179 | 						pair.from += i*inputStep;
180 | 						pair.to += i*outputStep;
181 | 						permutation.push_back(pair);
182 | 					}
183 | 				}
184 | 			}
185 | 		}
186 | 
187 | 		template<bool inverse, typename RandomAccessIterator>
188 | 		void fftStepGeneric(RandomAccessIterator &&origData, const Step &step) {
189 | 			complex *working = workingVector.data();
190 | 			const size_t stride = step.innerRepeats;
191 | 
192 | 			for (size_t outerRepeat = 0; outerRepeat < step.outerRepeats; ++outerRepeat) {
193 | 				RandomAccessIterator data = origData;
194 | 				
195 | 				const complex *twiddles = twiddleVector.data() + step.twiddleIndex;
196 | 				const size_t factor = step.factor;
197 | 				for (size_t repeat = 0; repeat < step.innerRepeats; ++repeat) {
198 | 					for (size_t i = 0; i < step.factor; ++i) {
199 | 						working[i] = perf::complexMul<inverse>(data[i*stride], twiddles[i]);
200 | 					}
201 | 					for (size_t f = 0; f < factor; ++f) {
202 | 						complex sum = working[0];
203 | 						for (size_t i = 1; i < factor; ++i) {
204 | 							V phase = 2*M_PI*f*i/factor;
205 | 							complex factor = {cos(phase), -sin(phase)};
206 | 							sum += perf::complexMul<inverse>(working[i], factor);
207 | 						}
208 | 						data[f*stride] = sum;
209 | 					}
210 | 					++data;
211 | 					twiddles += factor;
212 | 				}
213 | 				origData += step.factor*step.innerRepeats;
214 | 			}
215 | 		}
216 | 
217 | 		template<bool inverse, typename RandomAccessIterator>
218 | 		void fftStep2(RandomAccessIterator &&origData, const Step &step) {
219 | 			const size_t stride = step.innerRepeats;
220 | 			const complex *origTwiddles = twiddleVector.data() + step.twiddleIndex;
221 | 			for (size_t outerRepeat = 0; outerRepeat < step.outerRepeats; ++outerRepeat) {
222 | 				const complex* twiddles = origTwiddles;
223 | 				for (RandomAccessIterator data = origData; data < origData + stride; ++data) {
224 | 					complex A = data[0];
225 | 					complex B = perf::complexMul<inverse>(data[stride], twiddles[1]);
226 | 					
227 | 					data[0] = A + B;
228 | 					data[stride] = A - B;
229 | 					twiddles += 2;
230 | 				}
231 | 				origData += 2*stride;
232 | 			}
233 | 		}
234 | 
235 | 		template<bool inverse, typename RandomAccessIterator>
236 | 		void fftStep3(RandomAccessIterator &&origData, const Step &step) {
237 | 			constexpr complex factor3 = {-0.5, inverse ? 0.8660254037844386 : -0.8660254037844386};
238 | 			const size_t stride = step.innerRepeats;
239 | 			const complex *origTwiddles = twiddleVector.data() + step.twiddleIndex;
240 | 			
241 | 			for (size_t outerRepeat = 0; outerRepeat < step.outerRepeats; ++outerRepeat) {
242 | 				const complex* twiddles = origTwiddles;
243 | 				for (RandomAccessIterator data = origData; data < origData + stride; ++data) {
244 | 					complex A = data[0];
245 | 					complex B = perf::complexMul<inverse>(data[stride], twiddles[1]);
246 | 					complex C = perf::complexMul<inverse>(data[stride*2], twiddles[2]);
247 | 					
248 | 					complex realSum = A + (B + C)*factor3.real();
249 | 					complex imagSum = (B - C)*factor3.imag();
250 | 
251 | 					data[0] = A + B + C;
252 | 					data[stride] = perf::complexAddI<false>(realSum, imagSum);
253 | 					data[stride*2] = perf::complexAddI<true>(realSum, imagSum);
254 | 
255 | 					twiddles += 3;
256 | 				}
257 | 				origData += 3*stride;
258 | 			}
259 | 		}
260 | 
261 | 		template<bool inverse, typename RandomAccessIterator>
262 | 		void fftStep4(RandomAccessIterator &&origData, const Step &step) {
263 | 			const size_t stride = step.innerRepeats;
264 | 			const complex *origTwiddles = twiddleVector.data() + step.twiddleIndex;
265 | 			
266 | 			for (size_t outerRepeat = 0; outerRepeat < step.outerRepeats; ++outerRepeat) {
267 | 				const complex* twiddles = origTwiddles;
268 | 				for (RandomAccessIterator data = origData; data < origData + stride; ++data) {
269 | 					complex A = data[0];
270 | 					complex C = perf::complexMul<inverse>(data[stride], twiddles[2]);
271 | 					complex B = perf::complexMul<inverse>(data[stride*2], twiddles[1]);
272 | 					complex D = perf::complexMul<inverse>(data[stride*3], twiddles[3]);
273 | 
274 | 					complex sumAC = A + C, sumBD = B + D;
275 | 					complex diffAC = A - C, diffBD = B - D;
276 | 
277 | 					data[0] = sumAC + sumBD;
278 | 					data[stride] = perf::complexAddI<!inverse>(diffAC, diffBD);
279 | 					data[stride*2] = sumAC - sumBD;
280 | 					data[stride*3] = perf::complexAddI<inverse>(diffAC, diffBD);
281 | 
282 | 					twiddles += 4;
283 | 				}
284 | 				origData += 4*stride;
285 | 			}
286 | 		}
287 | 		
288 | 		template<typename InputIterator, typename OutputIterator>
289 | 		void permute(InputIterator input, OutputIterator data) {
290 | 			for (auto pair : permutation) {
291 | 				data[pair.from] = input[pair.to];
292 | 			}
293 | 		}
294 | 
295 | 		template<bool inverse, typename InputIterator, typename OutputIterator>
296 | 		void run(InputIterator &&input, OutputIterator &&data) {
297 | 			permute(input, data);
298 | 			
299 | 			for (const Step &step : plan) {
300 | 				switch (step.type) {
301 | 					case StepType::generic:
302 | 						fftStepGeneric<inverse>(data + step.startIndex, step);
303 | 						break;
304 | 					case StepType::step2:
305 | 						fftStep2<inverse>(data + step.startIndex, step);
306 | 						break;
307 | 					case StepType::step3:
308 | 						fftStep3<inverse>(data + step.startIndex, step);
309 | 						break;
310 | 					case StepType::step4:
311 | 						fftStep4<inverse>(data + step.startIndex, step);
312 | 						break;
313 | 				}
314 | 			}
315 | 		}
316 | 
317 | 		static bool validSize(size_t size) {
318 | 			constexpr static bool filter[32] = {
319 | 				1, 1, 1, 1, 1, 0, 1, 0, 1, 1, // 0-9
320 | 				0, 0, 1, 0, 0, 0, 1, 0, 1, 0, // 10-19
321 | 				0, 0, 0, 0, 1, 0, 0, 0, 0, 0, // 20-29
322 | 				0, 0
323 | 			};
324 | 			return filter[size];
325 | 		}
326 | 	public:
327 | 		static size_t sizeMinimum(size_t size) {
328 | 			size_t power2 = 1;
329 | 			while (size >= 32) {
330 | 				size = (size - 1)/2 + 1;
331 | 				power2 *= 2;
332 | 			}
333 | 			while (size < 32 && !validSize(size)) {
334 | 				++size;
335 | 			}
336 | 			return power2*size;
337 | 		}
338 | 		static size_t sizeMaximum(size_t size) {
339 | 			size_t power2 = 1;
340 | 			while (size >= 32) {
341 | 				size /= 2;
342 | 				power2 *= 2;
343 | 			}
344 | 			while (size > 1 && !validSize(size)) {
345 | 				--size;
346 | 			}
347 | 			return power2*size;
348 | 		}
349 | 
350 | 		FFT(size_t size, int fastDirection=0) : _size(0) {
351 | 			if (fastDirection > 0) size = sizeMinimum(size);
352 | 			if (fastDirection < 0) size = sizeMaximum(size);
353 | 			this->setSize(size);
354 | 		}
355 | 
356 | 		size_t setSize(size_t size) {
357 | 			if (size != _size) {
358 | 				_size = size;
359 | 				workingVector.resize(size);
360 | 				setPlan();
361 | 			}
362 | 			return _size;
363 | 		}
364 | 		size_t setSizeMinimum(size_t size) {
365 | 			return setSize(sizeMinimum(size));
366 | 		}
367 | 		size_t setSizeMaximum(size_t size) {
368 | 			return setSize(sizeMaximum(size));
369 | 		}
370 | 		const size_t & size() const {
371 | 			return _size;
372 | 		}
373 | 
374 | 		template<typename InputIterator, typename OutputIterator>
375 | 		void fft(InputIterator &&input, OutputIterator &&output) {
376 | 			auto inputIter = GetIterator<InputIterator>::get(input);
377 | 			auto outputIter = GetIterator<OutputIterator>::get(output);
378 | 			return run<false>(inputIter, outputIter);
379 | 		}
380 | 
381 | 		template<typename InputIterator, typename OutputIterator>
382 | 		void ifft(InputIterator &&input, OutputIterator &&output) {
383 | 			auto inputIter = GetIterator<InputIterator>::get(input);
384 | 			auto outputIter = GetIterator<OutputIterator>::get(output);
385 | 			return run<true>(inputIter, outputIter);
386 | 		}
387 | 	};
388 | 
389 | 	struct FFTOptions {
390 | 		static constexpr int halfFreqShift = 1;
391 | 	};
392 | 
393 | 	template<typename V, int optionFlags=0>
394 | 	class RealFFT {
395 | 		static constexpr bool modified = (optionFlags&FFTOptions::halfFreqShift);
396 | 
397 | 		using complex = std::complex<V>;
398 | 		std::vector<complex> complexBuffer1, complexBuffer2;
399 | 		std::vector<complex> twiddlesMinusI;
400 | 		std::vector<complex> modifiedRotations;
401 | 		FFT<V> complexFft;
402 | 	public:
403 | 		static size_t sizeMinimum(size_t size) {
404 | 			return (FFT<V>::sizeMinimum((size - 1)/2) + 1)*2;
405 | 		}
406 | 		static size_t sizeMaximum(size_t size) {
407 | 			return FFT<V>::sizeMinimum(size/2)*2;
408 | 		}
409 | 
410 | 		RealFFT(size_t size, int fastDirection=0) : complexFft(0) {
411 | 			if (fastDirection > 0) size = sizeMinimum(size);
412 | 			if (fastDirection < 0) size = sizeMaximum(size);
413 | 			this->setSize(size);
414 | 		}
415 | 
416 | 		size_t setSize(size_t size) {
417 | 			complexBuffer1.resize(size/2);
418 | 			complexBuffer2.resize(size/2);
419 | 
420 | 			size_t hhSize = size/4 + 1;
421 | 			twiddlesMinusI.resize(hhSize);
422 | 			for (size_t i = 0; i < hhSize; ++i) {
423 | 				double rotPhase = -2*M_PI*(modified ? i + 0.5 : i)/size;
424 | 				twiddlesMinusI[i] = {sin(rotPhase), -cos(rotPhase)};
425 | 			}
426 | 			if (modified) {
427 | 				modifiedRotations.resize(size/2);
428 | 				for (size_t i = 0; i < size/2; ++i) {
429 | 					double rotPhase = -2*M_PI*i/size;
430 | 					modifiedRotations[i] = {cos(rotPhase), sin(rotPhase)};
431 | 				}
432 | 			}
433 | 			
434 | 			return complexFft.setSize(size/2);
435 | 		}
436 | 		size_t setSizeMinimum(size_t size) {
437 | 			return setSize(sizeMinimum(size));
438 | 		}
439 | 		size_t setSizeMaximum(size_t size) {
440 | 			return setSize(sizeMaximum(size));
441 | 		}
442 | 		size_t size() const {
443 | 			return complexFft.size()*2;
444 | 		}
445 | 
446 | 		template<typename InputIterator, typename OutputIterator>
447 | 		void fft(InputIterator &&input, OutputIterator &&output) {
448 | 			size_t hSize = complexFft.size();
449 | 			for (size_t i = 0; i < hSize; ++i) {
450 | 				if (modified) {
451 | 					complexBuffer1[i] = perf::complexMul<false>({input[2*i], input[2*i + 1]}, modifiedRotations[i]);
452 | 				} else {
453 | 					complexBuffer1[i] = {input[2*i], input[2*i + 1]};
454 | 				}
455 | 			}
456 | 			
457 | 			complexFft.fft(complexBuffer1.data(), complexBuffer2.data());
458 | 			
459 | 			if (!modified) output[0] = {
460 | 				complexBuffer2[0].real() + complexBuffer2[0].imag(),
461 | 				complexBuffer2[0].real() - complexBuffer2[0].imag()
462 | 			};
463 | 			for (size_t i = modified ? 0 : 1; i <= hSize/2; ++i) {
464 | 				size_t conjI = modified ? (hSize  - 1 - i) : (hSize - i);
465 | 				
466 | 				complex odd = (complexBuffer2[i] + conj(complexBuffer2[conjI]))*(V)0.5;
467 | 				complex evenI = (complexBuffer2[i] - conj(complexBuffer2[conjI]))*(V)0.5;
468 | 				complex evenRotMinusI = perf::complexMul<false>(evenI, twiddlesMinusI[i]);
469 | 
470 | 				output[i] = odd + evenRotMinusI;
471 | 				output[conjI] = conj(odd - evenRotMinusI);
472 | 			}
473 | 		}
474 | 
475 | 		template<typename InputIterator, typename OutputIterator>
476 | 		void ifft(InputIterator &&input, OutputIterator &&output) {
477 | 			size_t hSize = complexFft.size();
478 | 			if (!modified) complexBuffer1[0] = {
479 | 				input[0].real() + input[0].imag(),
480 | 				input[0].real() - input[0].imag()
481 | 			};
482 | 			for (size_t i = modified ? 0 : 1; i <= hSize/2; ++i) {
483 | 				size_t conjI = modified ? (hSize  - 1 - i) : (hSize - i);
484 | 				complex v = input[i], v2 = input[conjI];
485 | 
486 | 				complex odd = v + conj(v2);
487 | 				complex evenRotMinusI = v - conj(v2);
488 | 				complex evenI = perf::complexMul<true>(evenRotMinusI, twiddlesMinusI[i]);
489 | 				
490 | 				complexBuffer1[i] = odd + evenI;
491 | 				complexBuffer1[conjI] = conj(odd - evenI);
492 | 			}
493 | 			
494 | 			complexFft.ifft(complexBuffer1.data(), complexBuffer2.data());
495 | 			
496 | 			for (size_t i = 0; i < hSize; ++i) {
497 | 				complex v = complexBuffer2[i];
498 | 				if (modified) v = perf::complexMul<true>(v, modifiedRotations[i]);
499 | 				output[2*i] = v.real();
500 | 				output[2*i + 1] = v.imag();
501 | 			}
502 | 		}
503 | 	};
504 | 
505 | 	template<typename V>
506 | 	struct ModifiedRealFFT : public RealFFT<V, FFTOptions::halfFreqShift> {
507 | 		using RealFFT<V, FFTOptions::halfFreqShift>::RealFFT;
508 | 	};
509 | }
510 | 
511 | #undef SIGNALSMITH_FFT_NAMESPACE
512 | #endif // SIGNALSMITH_FFT_V5
513 | 


--------------------------------------------------------------------------------
/tests/00-fft.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <vector>
  3 | #include <cmath>
  4 | #include <complex>
  5 | 
  6 | #include "tests-common.h"
  7 | 
  8 | std::vector<int> testSizes() {
  9 | 	return {
 10 | 		1, 2, 4, 8, 16, 32, 64, 128, 256,
 11 | 		3, 6, 9, 12, 18, 24,
 12 | 		5, 10, 15, 20, 25,
 13 | 		7, 14, 21, 28, 49,
 14 | 		11, 13, 17, 19, 22, 23
 15 | 	};
 16 | }
 17 | 
 18 | 
 19 | TEST("Individual bins", test_2N_bins) {
 20 | 	using signalsmith::FFT;
 21 | 	using std::vector;
 22 | 	using std::complex;
 23 | 
 24 | 	std::vector<int> sizes = testSizes();
 25 | 	
 26 | 	for (int size : sizes) {
 27 | 		vector<complex<double>> input(size);
 28 | 		vector<complex<double>> inputCopy(size);
 29 | 		vector<complex<double>> output(size);
 30 | 		vector<complex<double>> expected(size);
 31 | 
 32 | 		FFT<double> fft(size);
 33 | 
 34 | 		// Test each bin
 35 | 		for (int bin = 0; bin < size; bin++) {
 36 | 			for (int i = 0; i < size; i++) {
 37 | 				double phase = 2*M_PI*i*bin/size;
 38 | 				input[i] = inputCopy[i] = complex<double>{cos(phase), sin(phase)};
 39 | 				expected[i] = (i == bin) ? size : 0;
 40 | 			}
 41 | 
 42 | 			fft.fft(input, output);
 43 | 
 44 | 			if (!closeEnough(input, inputCopy)) {
 45 | 				return test.fail("input was changed");
 46 | 			}
 47 | 			if (!closeEnough(output, expected)) {
 48 | 				std::cout << "N = " << size << "\n";
 49 | 				std::cout << "   input:\t";
 50 | 				printArray(input);
 51 | 				std::cout << "  output:\t";
 52 | 				printArray(output);
 53 | 				std::cout << "expected:\t";
 54 | 				printArray(expected);
 55 | 
 56 | 				return test.fail("output != expected");
 57 | 			}
 58 | 		}
 59 | 	}
 60 | }
 61 | 
 62 | TEST("Linearity", test_2N_linearity) {
 63 | 	using signalsmith::FFT;
 64 | 	using std::vector;
 65 | 	using std::complex;
 66 | 
 67 | 	std::vector<int> sizes = testSizes();
 68 | 	
 69 | 	for (int size : sizes) {
 70 | 		vector<complex<double>> inputA(size);
 71 | 		vector<complex<double>> inputB(size);
 72 | 		vector<complex<double>> inputAB(size);
 73 | 		vector<complex<double>> outputA(size);
 74 | 		vector<complex<double>> outputB(size);
 75 | 		vector<complex<double>> outputAB(size);
 76 | 		vector<complex<double>> outputSummed(size);
 77 | 
 78 | 		FFT<double> fft(size);
 79 | 
 80 | 		// Test linearity
 81 | 		for (int i = 0; i < size; i++) {
 82 | 			inputA[i] = randomComplex<double>();
 83 | 			inputB[i] = randomComplex<double>();
 84 | 			inputAB[i] = inputA[i] + inputB[i];
 85 | 		}
 86 | 
 87 | 		fft.fft(inputA, outputA);
 88 | 		fft.fft(inputB, outputB);
 89 | 		fft.fft(inputAB, outputAB);
 90 | 
 91 | 		for (int i = 0; i < size; i++) {
 92 | 			outputSummed[i] = outputA[i] + outputB[i];
 93 | 		}
 94 | 
 95 | 		if (!closeEnough(outputAB, outputSummed)) {
 96 | 			return test.fail("result was not linear");
 97 | 		}
 98 | 	}
 99 | }
100 | 
101 | template<int fixedHarmonics=-1>
102 | void inverseTest(Test test) {
103 | 	using signalsmith::FFT;
104 | 
105 | 	std::vector<int> sizes = testSizes();
106 | 	
107 | 	for (int size : sizes) {
108 | 		std::vector<std::complex<double>> input(size);
109 | 		std::vector<std::complex<double>> spectrum(size);
110 | 		std::vector<std::complex<double>> output(size);
111 | 		std::vector<std::complex<double>> expected(size);
112 | 
113 | 		for (int i = 0; i < size; i++) {
114 | 			if (fixedHarmonics >= 0) {
115 | 				double freq = fixedHarmonics;
116 | 				double phase = 2*M_PI*i*freq/size;
117 | 				input[i] = {cos(phase), sin(phase)};
118 | 			} else {
119 | 				input[i] = randomComplex<double>();
120 | 			}
121 | 			expected[i] = input[i]*(double)size;
122 | 		}
123 | 
124 | 		FFT<double> fft(size);
125 | 		fft.fft(input, spectrum);
126 | 		fft.ifft(spectrum, output);
127 | 
128 | 		if (!closeEnough(output, expected)) {
129 | 			printArray(input);
130 | 			printArray(spectrum);
131 | 			std::cout << size << "\n";
132 | 			printArray(output);
133 | 			printArray(expected);
134 | 			return test.fail("inverse did not match");
135 | 		}
136 | 	}
137 | }
138 | 
139 | TEST("Inverse (first harmonic)", inverse_f1) {
140 | 	return inverseTest<1>(test);
141 | }
142 | 
143 | TEST("Inverse (random)", inverse_random) {
144 | 	return inverseTest<-1>(test);
145 | }
146 | 
147 | struct Powers {
148 | 	size_t two = 0, three = 0, five = 0, remainder = 1;
149 | };
150 | Powers factorise(size_t size) {
151 | 	Powers powers;
152 | 	while (size%2 == 0) {
153 | 		size /= 2;
154 | 		powers.two++;
155 | 	}
156 | 	while (size%3 == 0) {
157 | 		size /= 3;
158 | 		powers.three++;
159 | 	}
160 | 	while (size%5 == 0) {
161 | 		size /= 5;
162 | 		powers.five++;
163 | 	}
164 | 	powers.remainder = size;
165 | 	return powers;
166 | }
167 | 
168 | TEST("Sizes", sizes) {
169 | 	using signalsmith::FFT;
170 | 
171 | 	for (size_t i = 1; i < 1000; ++i) {
172 | 		size_t above = FFT<double>::sizeMinimum(i);
173 | 		size_t below = FFT<double>::sizeMaximum(i);
174 | 
175 | 		if (above < i) return test.fail("above < i");
176 | 		if (below > i) return test.fail("below > i");
177 | 
178 | 		auto factorsAbove = factorise(above);
179 | 		auto factorsBelow = factorise(below);
180 | 
181 | 		if (factorsAbove.remainder != 1) return test.fail("non-fast above remainder");
182 | 		if (factorsBelow.remainder != 1) return test.fail("non-fast below remainder");
183 | 
184 | 		if (factorsAbove.three + factorsAbove.five > 2) return test.fail("above is too complex");
185 | 		if (factorsBelow.three + factorsBelow.five > 2) return test.fail("below is too complex");
186 | 	}
187 | }
188 | 


--------------------------------------------------------------------------------
/tests/01-real.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <vector>
  3 | #include <cmath>
  4 | #include <complex>
  5 | 
  6 | #include "tests-common.h"
  7 | 
  8 | #define LOG_VALUE(expr) \
  9 | 	(std::cout << #expr << " = " << (expr) << "\n")
 10 | 
 11 | #define FAIL_VALUE_PAIR(expr1, expr2) \
 12 | 	( \
 13 | 		LOG_VALUE(expr1), LOG_VALUE(expr2), \
 14 | 		test.fail(#expr1 " and " #expr2) \
 15 | 	)
 16 | 
 17 | template<bool modified=false>
 18 | void test_real(Test &test) {
 19 | 	using signalsmith::FFT;
 20 | 	using signalsmith::RealFFT;
 21 | 	using signalsmith::ModifiedRealFFT;
 22 | 	using std::vector;
 23 | 	using std::complex;
 24 | 
 25 | 	for (int size = 2; size < 100; size += 2) {
 26 | 		vector<complex<double>> complexInput(size);
 27 | 		vector<complex<double>> complexMid(size);
 28 | 		vector<complex<double>> complexOutput(size);
 29 | 		vector<double> realInput(size);
 30 | 		vector<complex<double>> realMid(size); // Only need half, but check it's undisturbed
 31 | 		vector<double> realOutput(size);
 32 | 		
 33 | 		FFT<double> fft(size);
 34 | 		typename std::conditional<modified, ModifiedRealFFT<double>, RealFFT<double>>::type realFft(size);
 35 | 
 36 | 		// Random inputs
 37 | 		for (int i = 0; i < size; ++i) {
 38 | 			double v = rand()/(double)RAND_MAX - 0.5;
 39 | 			complexInput[i] = v;
 40 | 			realInput[i] = v;
 41 | 		}
 42 | 		if (modified) {
 43 | 			for (int i = 0; i < size; ++i) {
 44 | 				double rotPhase = -M_PI*i/size;
 45 | 				complex<double> rot = {cos(rotPhase), sin(rotPhase)};
 46 | 				complexInput[i] *= rot;
 47 | 			}
 48 | 		}
 49 | 		for (int i = size/2; i < size; ++i) {
 50 | 			// Should be undisturbed - fill with known value
 51 | 			realMid[i] = complex<double>{52, 21};
 52 | 		}
 53 | 		
 54 | 		fft.fft(complexInput, complexMid);
 55 | 		realFft.fft(realInput, realMid);
 56 | 		
 57 | 		// Check complex spectrum matches
 58 | 		if (!modified) {
 59 | 			if (complexMid[0].imag() > 1e-6) return test.fail("complexMid[0].imag()");
 60 | 			if (abs(complexMid[0].real() - realMid[0].real()) > 1e-6) return FAIL_VALUE_PAIR(complexMid[0].real(), realMid[0].real());
 61 | 			if (abs(complexMid[size/2].real() - realMid[0].imag()) > 1e-6) return FAIL_VALUE_PAIR(complexMid[size/2].real(), realMid[0].imag());
 62 | 		}
 63 | 		for (int i = modified ? 0 : 1; i < size/2; ++i) {
 64 | 			complex<double> diff = complexMid[i] - realMid[i];
 65 | 			if (abs(diff) > size*1e-6) {
 66 | 				LOG_VALUE(i);
 67 | 				return FAIL_VALUE_PAIR(complexMid[i], realMid[i]);
 68 | 			}
 69 | 		}
 70 | 		for (int i = size/2; i < size; ++i) {
 71 | 			// It should have left the second half of realMid completely alone
 72 | 			if (realMid[i] != complex<double>{52, 21}) return test.fail("realMid second half");
 73 | 		}
 74 | 		
 75 | 		fft.ifft(complexMid, complexOutput);
 76 | 		realFft.ifft(realMid, realOutput);
 77 | 
 78 | 		if (modified) {
 79 | 			for (int i = 0; i < size; ++i) {
 80 | 				double rotPhase = M_PI*i/size;
 81 | 				complex<double> rot = {cos(rotPhase), sin(rotPhase)};
 82 | 				complexOutput[i] *= rot;
 83 | 			}
 84 | 		}
 85 | 
 86 | 		for (int i = 0; i < size; ++i) {
 87 | 			if (complexOutput[i].imag() > size*1e-6) return test.fail("complexOutput[i].imag");
 88 | 
 89 | 			if (abs(complexOutput[i].real() - realOutput[i]) > size*1e-6) {
 90 | 				LOG_VALUE(size);
 91 | 				LOG_VALUE(i);
 92 | 				return FAIL_VALUE_PAIR(complexOutput[i], realOutput[i]);
 93 | 			}
 94 | 		}
 95 | 	}
 96 | }
 97 | 
 98 | TEST("Random real", random_real) {
 99 | 	test_real<false>(test);
100 | }
101 | 
102 | TEST("Modified real", random_modified_real) {
103 | 	test_real<true>(test);
104 | }
105 | 


--------------------------------------------------------------------------------
/tests/tests-common.h:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <complex>
 3 | 
 4 | // from the shared library
 5 | #include <test/tests.h>
 6 | 
 7 | #include "../signalsmith-fft.h"
 8 | 
 9 | template<typename T>
10 | std::complex<T> randomComplex() {
11 | 	std::complex<T> r;
12 | 	r.real(rand()/(double)RAND_MAX - 0.5);
13 | 	r.imag(rand()/(double)RAND_MAX - 0.5);
14 | 	return r;
15 | }
16 | 
17 | template<typename T>
18 | bool closeEnough(std::vector<std::complex<T>> vectorA, std::vector<std::complex<T>> vectorB) {
19 | 	double totalEnergy = 0;
20 | 	double totalError = 0;
21 | 	if (vectorA.size() != vectorB.size()) return false;
22 | 
23 | 	for (unsigned int i = 0; i < vectorA.size(); ++i) {
24 | 		T error = norm(vectorA[i] - vectorB[i]);
25 | 		T energy = norm(vectorA[i]*vectorA[i]) + norm(vectorB[i]*vectorB[i]);
26 | 		totalEnergy += energy;
27 | 		totalError += error;
28 | 	}
29 | 
30 | 	if (!totalEnergy) return true;
31 | 	T errorRatio = sqrt(totalError/totalEnergy);
32 | 	return errorRatio < 1e-6;
33 | }
34 | 
35 | template<typename T>
36 | static void printArray(std::vector<T> array, bool newline=true) {
37 | 	for (unsigned int i = 0; i < array.size(); ++i) {
38 | 		if (i > 0) std::cout << "\t";
39 | 		std::cout << array[i];
40 | 	}
41 | 	if (newline) std::cout << std::endl;
42 | }
43 | 


--------------------------------------------------------------------------------