VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1347 Commits
4 Branches
540MB
Tree: 5b7b40e992
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5b7b40e992'
${ noResults }
Rack/plugins/community/repos/squinkylabs-plug1/test/testSaw.cpp

358 lines
8.4KB
Raw Blame History 

  1. #include <assert.h>

  2. #include <iostream>

  3. 

  4. #include "asserts.h"

  5. #include "MultiModOsc.h"

  6. #include "AudioMath.h"

  7. #include "SawOscillator.h"

  8. #include "TestSignal.h"

  9. 

  10. using namespace std;

  11. 

  12. // do objects exist?

  13. template<typename T>

  14. static void testSaw1()

  15. {

  16.     SawOscillatorParams<T> params;

  17.     SawOscillator<T, false>::setFrequency(params, (T(.1)));

  18.     SawOscillatorState<T> state;

  19.     SawOscillator<T, false>::runSaw(state, params);

  20. 

  21.     using osc = MultiModOsc<T, 4, 3>;

  22.     typename osc::State mstate;

  23.     typename osc::Params mparams;

  24.     T output[3];

  25.     osc::run(output, mstate, mparams);

  26. }

  27. 

  28. /**

  29.  * Does parameter calculation do anything?

  30.  */

  31. template<typename T>

  32. static void testSaw2()

  33. {

  34.     SawOscillatorParams<T> params;

  35.     assert(params.phaseIncrement == 0);

  36.     SawOscillator<T, false>::setFrequency(params, (T(.1)));

  37.     assert(params.phaseIncrement > 0);

  38. }

  39. 

  40. /**

  41.  * Does something come out?

  42.  */

  43. template<typename T>

  44. static void testSaw3()

  45. {

  46.     SawOscillatorParams<T> params;

  47.     SawOscillator<T, true>::setFrequency(params, (T(.2)));

  48.     SawOscillatorState<T> state;

  49.     SawOscillator<T, true>::runSaw(state, params);

  50.     const T out = SawOscillator<T, true>::runSaw(state, params);

  51.     assert(out > 0);

  52.     assert(out < 1);

  53. }

  54. 

  55. /**

  56. * Does something come out?

  57. */

  58. template<typename T>

  59. static void testTri3()

  60. {

  61.     SawOscillatorParams<T> params;

  62.     SawOscillator<T, true>::setFrequency(params, (T(.2)));

  63.     SawOscillatorState<T> state;

  64.     SawOscillator<T, true>::runSaw(state, params);

  65.     const T out = SawOscillator<T, true>::runTri(state, params);

  66.     assert(out > 0);

  67.     assert(out < 1);

  68. }

  69. 

  70. /**

  71. * Does something come out?

  72. */

  73. template<typename T>

  74. static void testMulti3()

  75. {

  76.     using osc = MultiModOsc<T, 4, 3>;

  77.     typename osc::State state;

  78.     typename osc::Params params;

  79.     T output[3] = {0, 0, 0};

  80.     T output2[3] = {0, 0, 0};

  81. 

  82.     osc::run(output, state, params);

  83.     osc::run(output, state, params);

  84.     osc::run(output2, state, params);

  85.     for (int i = 0; i < 3; ++i) {

  86.         assert(output[i] != 0);

  87.         assert(output2[i] != 0);

  88.         assert(output[i] != output2[i]);

  89. 

  90.         if (i > 0) {

  91.             assert(output[i] != output[i - 1]);

  92.             assert(output2[i] != output2[i - 1]);

  93.         }

  94.     }

  95. }

  96. 

  97. /**

  98.  * Does it look like a triangle?

  99.  */

  100. 

  101. template<typename T>

  102. static void testTri4()

  103. {

  104.     const T freq = T(.1);     // was .01

  105.     const T delta = 2 * freq;

  106.     SawOscillatorParams<T> params;

  107.     SawOscillator<T, true>::setFrequency(params, (T(.01)));

  108.     SawOscillatorState<T> state;

  109. 

  110.     T last = -freq;

  111.     bool increasing = true;

  112.     for (int i = 0; i < 1000; ++i) {

  113.         const T output = SawOscillator<T, true>::runTri(state, params);

  114. 

  115.         assert(output >= -1);

  116.         assert(output <= 1);

  117.         if (increasing) {

  118.             if (output > last) {

  119.                 // still increasing

  120.             } else {

  121.                 // started decreasing

  122. 

  123.                 assert(AudioMath::closeTo(output, 1, delta));

  124.                 increasing = false;

  125.             }

  126.         } else {

  127.             if (output < last) {

  128.                 // still decreasing

  129.             } else {

  130.                 // started increasing

  131.                 assert(AudioMath::closeTo(output, -1, delta));

  132.                 increasing = true;

  133.             }

  134.         }

  135. 

  136.         last = output;

  137.     }

  138. }

  139. 

  140. /**

  141. * Does it look like a saw?

  142. */

  143. template<typename T>

  144. static void testSaw4()

  145. {

  146.     const T freq = T(.01);

  147.     const T delta = freq / 1000;

  148.     SawOscillatorParams<T> params;

  149.     SawOscillator<T, true>::setFrequency(params, (T(.01)));

  150.     SawOscillatorState<T> state;

  151. 

  152.     T last = 0;

  153.     for (int i = 0; i < 1000; ++i) {

  154.         const T output = SawOscillator<T, true>::runSaw(state, params);

  155. 

  156.         assert(output >= 0);

  157.         assert(output < 1);

  158. 

  159.         if (output < last) {

  160.             assert(last > .99);

  161.             assert(output < .01);

  162.         } else {

  163.             assert(output < (last + freq + delta));

  164.         }

  165. 

  166.         last = output;

  167.     }

  168. }

  169. 

  170. /**

  171. * Is the quadrature really 90 out of phase?

  172. */

  173. template<typename T>

  174. static void testSaw5()

  175. {

  176.     SawOscillatorParams<T> params;

  177.     SawOscillator<T, true>::setFrequency(params, (T(.01)));

  178.     SawOscillatorState<T> state;

  179. 

  180.     T output;

  181.     T quadratureOutput;

  182.     for (int i = 0; i < 1000; ++i) {

  183.         SawOscillator<T, true>::runQuadrature(output, quadratureOutput, state, params);

  184. 

  185.         // normalize output (unwrap)

  186.         if (quadratureOutput < output) {

  187.             quadratureOutput += 1;

  188.         }

  189.         assert(quadratureOutput = (output + T(.25)));

  190.     }

  191. }

  192. 

  193. 

  194. /**

  195. * Does it look like a negative saw?

  196. */

  197. template<typename T>

  198. static void testSaw6()

  199. {

  200.     const T freq = T(-.01);

  201.     const T delta = freq / 1000;

  202.     SawOscillatorParams<T> params;

  203.     SawOscillator<T, true>::setFrequency(params, freq);

  204.     SawOscillatorState<T> state;

  205. 

  206.     T last = 0;

  207.     for (int i = 0; i < 1000; ++i) {

  208.         const T output = SawOscillator<T, true>::runSaw(state, params);

  209. 

  210.         assert(output >= 0);

  211.         assert(output < 1);

  212. 

  213.         if (output > last) {

  214.             // wrap case - did we more or less wrap?

  215.             assert(last < .01);

  216.             assert(output > .98);

  217.         } else {

  218.             // no-wrap - are we decreasing

  219.             assert(output > (last + freq + delta));

  220.         }

  221.         last = output;

  222.     }

  223. }

  224. 

  225. /**

  226.  * IS the RMS for triangle as expected?

  227.  */

  228. template <typename T>

  229. static void testTri7()

  230. {

  231.     const int div = 1024;

  232.     const T freq = T(1.0 / T(div));

  233.     SawOscillatorParams<T> params;

  234.     SawOscillator<T, true>::setFrequency(params, freq);

  235.     SawOscillatorState<T> state;

  236.     double amplitude = TestSignal<T>::measureOutput(div, [&state, &params]() {

  237.         return SawOscillator<T, true>::runTri(state, params);

  238.         });

  239. 

  240.     // RMS of tri wave is 1 / cube root 3

  241.     assert(AudioMath::closeTo(amplitude, 0.57735, .0001));

  242. }

  243. 

  244. template <typename T>

  245. static void testSaw7()

  246. {

  247.     const int div = 1024;

  248.     const T freq = T(1.0 / T(div));

  249.     SawOscillatorParams<T> params;

  250.     SawOscillator<T, true>::setFrequency(params, freq);

  251.     SawOscillatorState<T> state;

  252.     double amplitude = TestSignal<T>::measureOutput(div * 16, [&state, &params]() {

  253.         // normalize to 1V pp

  254.         return 2 * SawOscillator<T, true>::runSaw(state, params) - 1;

  255.         });

  256. 

  257. 

  258.     // RMS of saw wave is 1 / cube root 3

  259.     assert(AudioMath::closeTo(amplitude, 0.57735, .0001));

  260. }

  261. 

  262. template <typename T>

  263. static void testSawFreq_old(bool neg)

  264. {

  265.    // assert(!neg);

  266.     const T freq = neg ? T(-.1) : T(.1);

  267.     SawOscillatorParams<T> params;

  268.     SawOscillator<T, true>::setFrequency(params, freq);

  269.     SawOscillatorState<T> state;

  270. 

  271.     T lastValue = neg ? T(-100) : T(100);

  272.     for (int i = 0; i < 100; ++i) {

  273.         T saw = SawOscillator<T, true>::runSaw(state, params);

  274. 

  275.         if (!neg) {

  276.             if (0 == (i % 10)) {

  277.                 assertLT(saw, lastValue);

  278.             } else {

  279.                 assertGT(saw, lastValue);

  280.             }

  281.         } else {

  282. #if 0

  283.             if (0 == (i % 10)) {

  284.                 assertGT(saw, lastValue);

  285.             } else {

  286.                 assertLT(saw, lastValue);

  287.             }

  288. #endif

  289.             printf("i = %d out=%.2f\n", i, saw);

  290.             fflush(stdout);

  291.         }

  292.         lastValue = saw;

  293.     }

  294. 

  295. }

  296. 

  297. template <typename T>

  298. static void testSawFreq(bool neg)

  299. {

  300. 

  301.     int period = 10000;

  302.     if (sizeof(T) > 4) {

  303.         

  304.         period *= 1000;

  305.     }

  306.     T freq = T(1.0 / period);

  307.     if (neg) {

  308.         freq *= -1;

  309.    }

  310.     SawOscillatorParams<T> params;

  311.     SawOscillator<T, true>::setFrequency(params, freq);

  312.     SawOscillatorState<T> state;

  313. 

  314.     T last = SawOscillator<T, true>::runSaw(state, params);

  315.     bool done = false;

  316.     int count = 0;

  317.     for (; !done; ++count) {

  318.         if (count > period + 100) {

  319.             done = true;

  320.             assert(false);

  321.         }

  322.         T saw = SawOscillator<T, true>::runSaw(state, params);

  323.         assertNE(saw, last);

  324.         bool moreThanLast = saw > last;

  325.         last = saw;

  326.         // if saw is turning going back

  327.         if (moreThanLast == neg) {

  328.             const int measuredPeriod = count + 1;

  329.             assertClose(measuredPeriod, period, 1.1);

  330.             done = true;

  331.         }

  332.     }

  333. }

  334. 

  335. 

  336. template <typename T>

  337. static void testSawT()

  338. {

  339.     testSaw1<T>();

  340.     testSaw2<T>();

  341.     testSaw3<T>();

  342.     testTri3<T>();

  343.     testMulti3<T>();

  344.     testSaw4<T>();

  345.     testTri4<T>();

  346.     testSaw5<T>();

  347.     testSaw6<T>();

  348.     testTri7<T>();

  349.     testSaw7<T>();

  350.     testSawFreq<T>(false);

  351.  //   testSawFreq<T>(true);

  352. }

  353. 

  354. void testSaw()

  355. {

  356.     testSawT<float>();

  357.     testSawT<double>();

  358. }