public void DFTTestMethod2()
        {
            InverseFastFourierTransform IFFT = new InverseFastFourierTransform();
            // test case 2

            var FrequenciesAmplitudes = new List <float> {
                64, 20.9050074380220f, 11.3137084989848f, 8.65913760233915f, 8, 8.65913760233915f, 11.3137084989848f, 20.9050074380220f
            };
            var FrequenciesPhaseShifts = new List <float> {
                0, 1.96349540849362f, 2.35619449019235f, 2.74889357189107f, 3.14159265358979f, -2.74889357189107f, -2.35619449019235f, -1.96349540849362f
            };
            var Frequencies = new List <float> {
                0, 1, 2, 3, 4, 5, 6, 7
            };

            IFFT.InputFreqDomainSignal = new DSPAlgorithms.DataStructures.Signal(true, Frequencies, FrequenciesAmplitudes, FrequenciesPhaseShifts);

            IFFT.Run();

            List <float> outPutSamples = new List <float> {
                1, 3, 5, 7, 9, 11, 13, 15
            };

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(outPutSamples, IFFT.OutputTimeDomainSignal.Samples));
        }
        public void DirectConvolutionTestMethod4()
        {
            DirectConvolution dc = new DirectConvolution();
            // test case 4 ..
            var expectedOutput = new Signal(new List <float>()
            {
                1, 1, -1, 0, 0, 3, 3, 2, 1
            }, new List <int>()
            {
                -2, -1, 0, 1, 2, 3, 4, 5, 6
            }, false);

            dc.InputSignal1 = new Signal(new List <float>()
            {
                1, 2, 1, 1
            }, new List <int>()
            {
                -2, -1, 0, 1
            }, false);

            dc.InputSignal2 = new Signal(new List <float>()
            {
                1, -1, 0, 0, 1, 1
            }, new List <int>()
            {
                0, 1, 2, 3, 4, 5
            }, false);

            dc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, dc.OutputConvolvedSignal.Samples));
            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesIndicesAreEqual(expectedOutput, dc.OutputConvolvedSignal));
        }
示例#3
0
        public void DFTTestMethod3()
        {
            DiscreteFourierTransform DFT = new DiscreteFourierTransform();
            // test case 2
            List <float> Samples = new List <float> {
                1, 3, 5, 7, 9, 11, 13, 15
            };

            DFT.InputTimeDomainSignal  = new DSPAlgorithms.DataStructures.Signal(Samples, false);
            DFT.InputSamplingFrequency = 4;

            var FrequenciesAmplitudes = new List <float> {
                64, 20.9050074380220f, 11.3137084989848f, 8.65913760233915f, 8, 8.65913760233915f, 11.3137084989848f, 20.9050074380220f
            };
            var FrequenciesPhaseShifts = new List <float> {
                0, 1.96349540849362f, 2.35619449019235f, 2.74889357189107f, -3.14159265358979f, -2.74889357189107f, -2.35619449019235f, -1.96349540849362f
            };
            var Frequencies = new List <float> {
                0, 1, 2, 3, 4, 5, 6, 7
            };

            DFT.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(FrequenciesAmplitudes, DFT.OutputFreqDomainSignal.FrequenciesAmplitudes) &&
                          UnitTestUtitlities.SignalsPhaseShiftsAreEqual(FrequenciesPhaseShifts, DFT.OutputFreqDomainSignal.FrequenciesPhaseShifts));
        }
        public void AutoFastNonNormalizedCorrelationTestMethod2()
        {
            FastCorrelation fc             = new FastCorrelation();
            var             expectedOutput = UnitTestUtitlities.LoadSignal("TestingSignals/FastAutoCorrelationNonNormalized_TestCase.ds");

            fc.InputSignal1 = UnitTestUtitlities.LoadSignal("TestingSignals/FastAutoCorrelation.ds");
            fc.Run();
            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, fc.OutputNonNormalizedCorrelation));
        }
        public void QuantizationAndEncodingTestMethod3()
        {
            QuantizationAndEncoding Q = new QuantizationAndEncoding();

            Q.InputLevel  = 4;
            Q.InputSignal = new DSPAlgorithms.DataStructures.Signal(new List <float>()
            {
                -1.22f, 1.5f, 3.24f, 3.94f, 2.20f, -1.1f, -2.26f, -1.88f, -1.2f
            }, false);
            Q.Run();

            List <int> expectedIntervalIndices = new List <int>()
            {
                1, 3, 4, 4, 3, 1, 1, 1, 1
            };
            List <string> expectedEncodedValues = new List <string>()
            {
                "00", "10", "11", "11", "10", "00", "00", "00", "00"
            };
            List <float> expectedQuantizedValues = new List <float>()
            {
                -1.485f, 1.615f, 3.165f, 3.165f, 1.615f, -1.485f, -1.485f, -1.485f, -1.485f
            };
            List <float> expectedSampledError = new List <float>()
            {
                -0.265f, 0.115f, -0.075f, -0.775f, -0.585f, -0.385f, 0.775f, 0.395f, -0.285f
            };

            bool encodedValues   = true;
            bool quantizedValues = true;
            bool indicesValues   = true;
            bool errorValues     = true;

            for (int i = 0; i < expectedEncodedValues.Count; i++)
            {
                if (expectedEncodedValues[i] != Q.OutputEncodedSignal[i])
                {
                    encodedValues = false;
                    break;
                }
            }

            quantizedValues = UnitTestUtitlities.SignalsSamplesAreEqual(expectedQuantizedValues, Q.OutputQuantizedSignal.Samples);
            errorValues     = UnitTestUtitlities.SignalsSamplesAreEqual(expectedSampledError, Q.OutputSamplesError);

            for (int i = 0; i < expectedIntervalIndices.Count; i++)
            {
                if (expectedIntervalIndices[i] != Q.OutputIntervalIndices[i])
                {
                    indicesValues = false;
                    break;
                }
            }

            Assert.IsTrue(encodedValues && quantizedValues && indicesValues && errorValues);
        }
        public void AutoDirectNormalizedPeriodicCorrelationTestMethod2()
        {
            DirectCorrelation dc = new DirectCorrelation();

            dc.InputSignal1 = UnitTestUtitlities.LoadSignal("TestingSignals/AutoCorrelationPeriodic_TestCase.ds");
            Signal expectedOutput = UnitTestUtitlities.LoadSignal("TestingSignals/AutoCorrelationNormalizedPeriodic_TestCase.ds");

            dc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, dc.OutputNormalizedCorrelation));
        }
        public void IFFT_TestMethod2()
        {
            InverseFastFourierTransform IFFT = new InverseFastFourierTransform();

            IFFT.InputFreqDomainSignal = UnitTestUtitlities.LoadSignal(@"TestingSignals/Signal2_FFT_Results.ds");
            List <float> outPutSamples = UnitTestUtitlities.LoadSignal("TestingSignals/Signal2_FFT.ds").Samples;

            IFFT.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(outPutSamples,
                                                                    IFFT.OutputTimeDomainSignal.Samples));
        }
        public void NormalizerTestMethod2()
        {
            var sig1           = UnitTestUtitlities.LoadSignal("TestingSignals/Signal2.ds");
            var expectedOutput = UnitTestUtitlities.LoadSignal("TestingSignals/Normalizer_TestCase2.ds").Samples;

            Normalizer a = new Normalizer();

            a.InputMinRange = 0;
            a.InputMaxRange = 1;
            a.InputSignal   = sig1;

            a.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput, a.OutputNormalizedSignal.Samples));
        }
示例#9
0
        public void FFT_TestMethod2()
        {
            DiscreteFourierTransform DFT = new DiscreteFourierTransform();
            // test case 1 ..
            var sig1           = UnitTestUtitlities.LoadSignal("TestingSignals/Signal2_FFT.ds");
            var expectedOutput = UnitTestUtitlities.LoadSignal("TestingSignals/Signal2_FFT_Results.ds");

            DFT.InputTimeDomainSignal  = sig1;
            DFT.InputSamplingFrequency = 360;

            DFT.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.FrequenciesAmplitudes, DFT.OutputFreqDomainSignal.FrequenciesAmplitudes) &&
                          UnitTestUtitlities.SignalsPhaseShiftsAreEqual(expectedOutput.FrequenciesPhaseShifts, DFT.OutputFreqDomainSignal.FrequenciesPhaseShifts));
        }
        public void MovingAverageTestMethod2()
        {
            // test case 2 ..
            var sig1           = UnitTestUtitlities.LoadSignal("TestingSignals/Signal2.ds");
            var expectedOutput = UnitTestUtitlities.LoadSignal("TestingSignals/MovingAverage_TestCase2.ds").Samples;

            MovingAverage a = new MovingAverage();

            a.InputSignal     = sig1;
            a.InputWindowSize = 5;

            a.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput, a.OutputAverageSignal.Samples));
        }
示例#11
0
        public void MultiplySignalByConstantTestMethod2()
        {
            var sig1           = UnitTestUtitlities.LoadSignal("TestingSignals/Signal2.ds");
            var expectedOutput = UnitTestUtitlities.LoadSignal("TestingSignals/MultiplySignalByConstant_TestCase2.ds").Samples;


            MultiplySignalByConstant m = new MultiplySignalByConstant();

            m.InputSignal   = sig1;
            m.InputConstant = 10;

            m.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput, m.OutputMultipliedSignal.Samples));
        }
        public void SubtractorTestMethod2()
        {
            var sig1 = UnitTestUtitlities.LoadSignal("TestingSignals/Signal1.ds");
            var sig2 = UnitTestUtitlities.LoadSignal("TestingSignals/Signal3.ds");

            var expectedOutput = UnitTestUtitlities.LoadSignal("TestingSignals/Subtractor_TestCase2.ds").Samples;

            Subtractor m = new Subtractor();

            m.InputSignal1 = sig2;
            m.InputSignal2 = sig1;

            m.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput, m.OutputSignal.Samples));
        }
示例#13
0
        public void RemoveDCComponentTestMethod1()
        {
            // test case 1 ..
            var sig1 = UnitTestUtitlities.LoadSignal("TestingSignals/DC_Component.ds");

            var expectedOutput = UnitTestUtitlities.LoadSignal("TestingSignals/DC_Component_Result.ds").Samples;

            RemoveDCComponent m = new RemoveDCComponent();

            m.InputSignal = sig1;


            m.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput, m.OutputSignal.Samples));
        }
示例#14
0
        public void AdderTestMethod2()
        {
            var sig1 = UnitTestUtitlities.LoadSignal("TestingSignals/Signal1.ds");
            var sig2 = UnitTestUtitlities.LoadSignal("TestingSignals/Signal3.ds");

            var expectedOutput = UnitTestUtitlities.LoadSignal("TestingSignals/Adder_TestCase2.ds");

            Adder a = new Adder();

            a.InputSignals = new List <Signal>();
            a.InputSignals.Add(sig1);
            a.InputSignals.Add(sig2);

            a.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, a.OutputSignal.Samples));
        }
        public void AutoFastNonNormalizedCorrelationTestMethod1()
        {
            FastCorrelation fc = new FastCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                0.50f, 0.25f, 0.00f, 0.25f
            }, false);

            fc.InputSignal1 = new Signal(new List <float>()
            {
                1, 0, 0, 1
            }, true);

            fc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, fc.OutputNonNormalizedCorrelation));
        }
        public void DFTTestMethod1()
        {
            FastFourierTransform FFT = new FastFourierTransform();
            // test case 1 ..
            var sig1 = UnitTestUtitlities.LoadSignal("TestingSignals/DFT_Signal1.ds");

            FFT.InputTimeDomainSignal  = sig1;
            FFT.InputSamplingFrequency = 4;

            List <float> amplitude = new List <float> {
                64, 20.9050074380220f, 11.3137084989848f, 8.65913760233915f, 8, 8.65913760233915f, 11.3137084989848f, 20.9050074380220f
            };
            List <float> phase = new List <float> {
                0, 1.96349540849362f, 2.35619449019235f, 2.74889357189107f, 3.14159265358979f, -2.74889357189107f, -2.35619449019235f, -1.96349540849362f
            };

            FFT.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(amplitude, FFT.OutputFreqDomainSignal.FrequenciesAmplitudes) && UnitTestUtitlities.SignalsSamplesAreEqual(phase, FFT.OutputFreqDomainSignal.FrequenciesPhaseShifts));
        }
        public void CrossDirectNormalizedNonPeriodicCorrelationTestMethod2()
        {
            DirectCorrelation fc = new DirectCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                0.2916059f, 0.3499271f, 0.4665695f, 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f
            }, false);

            fc.InputSignal1 = new Signal(new List <float>()
            {
                2, 1, 0, 0, 3
            }, false);
            fc.InputSignal2 = new Signal(new List <float>()
            {
                2, 1, 4
            }, false); fc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, fc.OutputNormalizedCorrelation));
        }
        public void CrossDirectNonNormalizedPeriodicCorrelationTestMethod2()
        {
            DirectCorrelation fc = new DirectCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                0.7142857f, 0.8571429f, 1.1428571f, 0.8571429f, 0.4285714f, 1.7142857f, 0.2857143f
            }, false);

            fc.InputSignal1 = new Signal(new List <float>()
            {
                2, 1, 0, 0, 3
            }, true);
            fc.InputSignal2 = new Signal(new List <float>()
            {
                2, 1, 4
            }, true); fc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, fc.OutputNonNormalizedCorrelation));
        }
        public void CrossFastNormalizedCorrelationTestMethod1()
        {
            FastCorrelation fc = new FastCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                0.9667248f, 0.7352555f, 0.6807921f, 0.8577981f
            }, false);

            fc.InputSignal1 = new Signal(new List <float>()
            {
                4, 3, 1, 6
            }, false);
            fc.InputSignal2 = new Signal(new List <float>()
            {
                5, 2, 3, 7
            }, false);

            fc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, fc.OutputNormalizedCorrelation));
        }
        public void CrossFastNonNormalizedCorrelationTestMethod1()
        {
            FastCorrelation fc = new FastCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                17.7500000f, 13.5000000f, 12.5000000f, 15.7500000f
            }, false);

            fc.InputSignal1 = new Signal(new List <float>()
            {
                4, 3, 1, 6
            }, false);
            fc.InputSignal2 = new Signal(new List <float>()
            {
                5, 2, 3, 7
            }, false);

            fc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, fc.OutputNonNormalizedCorrelation));
        }
        public void CrossDirectNormalizedPeriodicCorrelationTestMethod1()
        {
            DirectCorrelation fc = new DirectCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                0.5974621f, 0.3502364f, 0.2472257f, 0.6180642f, 0.3502364f, 0.7210749f,
            }, false);

            fc.InputSignal1 = new Signal(new List <float>()
            {
                4, 3, 1, 6
            }, true);
            fc.InputSignal2 = new Signal(new List <float>()
            {
                5, 2, 3
            }, true);

            fc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, fc.OutputNormalizedCorrelation));
        }
        public void DirectConvolutionTestMethod1()
        {
            DirectConvolution dc = new DirectConvolution();
            // test case 1 ..
            var expectedOutput = new Signal(new List <float>()
            {
                1, 3, 7, 7, 7, 6, 4
            }, false);

            dc.InputSignal1 = new Signal(new List <float>()
            {
                1, 2, 4
            }, false);
            dc.InputSignal2 = new Signal(new List <float>()
            {
                1, 1, 1, 1, 1
            }, false);

            dc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, dc.OutputConvolvedSignal.Samples));
        }
        public void CrossDirectNonNormalizedPeriodicCorrelationTestMethod1()
        {
            DirectCorrelation fc = new DirectCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                4.8333333f, 2.8333333f, 2.0000000f, 5.0000000f, 2.8333333f, 5.8333333f
            }, false);

            fc.InputSignal1 = new Signal(new List <float>()
            {
                4, 3, 1, 6
            }, true);
            fc.InputSignal2 = new Signal(new List <float>()
            {
                5, 2, 3
            }, true);

            fc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, fc.OutputNonNormalizedCorrelation));
        }
        public void DirectConvolutionTestMethod3()
        {
            DirectConvolution dc = new DirectConvolution();

            var expectedOutput = new Signal(new List <float>()
            {
                44, 143, 243, 442, 454, 367, 495, 132
            }, false);

            dc.InputSignal1 = new Signal(new List <float>()
            {
                1, 2, 3, 4
            }, false);
            dc.InputSignal2 = new Signal(new List <float>()
            {
                44, 55, 1, 99, 33
            }, false);

            dc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, dc.OutputConvolvedSignal.Samples));
        }
        public void DirectConvolutionTestMethod2()
        {
            DirectConvolution dc = new DirectConvolution();

            var expectedOutput = new Signal(new List <float>()
            {
                0.5f, 1, 1, 1, 1.5f, 2, 1.5f, 0.5f
            }, false);

            dc.InputSignal1 = new Signal(new List <float>()
            {
                1, 0, 0, 1, 1
            }, false);
            dc.InputSignal2 = new Signal(new List <float>()
            {
                0.5f, 1, 1, 0.5f
            }, false);

            dc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, dc.OutputConvolvedSignal.Samples));
        }
        public void QuantizationAndEncodingTestMethod2()
        {
            QuantizationAndEncoding Q = new QuantizationAndEncoding();

            Q.InputLevel  = 8;
            Q.InputSignal = new DSPAlgorithms.DataStructures.Signal(new List <float>()
            {
                0.387f, 0.430f, 0.478f, 0.531f, 0.590f, 0.6561f, 0.729f, 0.81f, 0.9f, 1f, 0.2f
            }, false);
            Q.Run();


            List <string> expectedEncodedValues = new List <string>()
            {
                "001", "010", "010", "011", "011", "100", "101", "110", "110", "111", "000"
            };
            List <float> expectedQuantizedValues = new List <float>()
            {
                0.35f, 0.45f, 0.45f, 0.55f, 0.55f, 0.65f, 0.75f, 0.85f, 0.85f, 0.95f, 0.25f
            };

            bool encodedValues   = true;
            bool quantizedValues = true;

            for (int i = 0; i < expectedEncodedValues.Count; i++)
            {
                if (expectedEncodedValues[i] != Q.OutputEncodedSignal[i])
                {
                    encodedValues = false;
                    break;
                }
            }

            quantizedValues = UnitTestUtitlities.SignalsSamplesAreEqual(expectedQuantizedValues, Q.OutputQuantizedSignal.Samples);

            Assert.IsTrue(encodedValues && quantizedValues);
        }
        public void AutoDirectNonNormalizedNonPeriodicCorrelationTestMethod1()
        {
            DirectCorrelation dc = new DirectCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                #region expectedOutput
                0.145421785526316f,
                0.138042811315789f,
                0.116859722763158f,
                0.084224233421053f,
                0.043787748552632f,
                0.000012503421053f,
                -0.042372349868421f,
                -0.078934778684211f,
                -0.106057218026316f,
                -0.121306617631579f,
                -0.123700744473684f,
                -0.113731415526316f,
                -0.093230693157895f,
                -0.065077018026316f,
                -0.032791058815789f,
                -0.000081059605263f,
                0.029601792631579f,
                0.053442207368421f,
                0.069530525921053f,
                0.076999285657895f,
                0.076019766710526f,
                0.067674143815789f,
                0.053729758684211f,
                0.036355934736842f,
                0.017824319210526f,
                0.000233551710526f,
                -0.014711043815789f,
                -0.025840895263158f,
                -0.032583095921053f,
                -0.034938634210526f,
                -0.033394412368421f,
                -0.028789378552632f,
                -0.022158962500000f,
                -0.014580769210526f,
                -0.007041455789474f,
                -0.000337463815789f,
                0.004983341710526f,
                0.008638095657895f,
                0.010590359210526f,
                0.011004474605263f,
                0.010183886184211f,
                0.008505514342105f,
                0.006358184736842f,
                0.004093438815789f,
                0.001991600000000f,
                0.000244809210526f,
                -0.001045239736842f,
                -0.001856842368421f,
                -0.002230833815789f,
                -0.002249111052632f,
                -0.002013452236842f,
                -0.001627179473684f,
                -0.001181853815789f,
                -0.000748792105263f,
                -0.000375964473684f,
                -0.000088670131579f,
                0.000106684868421f,
                0.000217783026316f,
                0.000260585131579f,
                0.000254524342105f,
                0.000218744605263f,
                0.000169398552632f,
                0.000118649473684f,
                0.000074126184211f,
                0.000039611710526f,
                0.000015828026316f,
                0.000001548421053f,
                -0.000005348421053f,
                -0.000006818947368f,
                -0.000011735263158f,
                -0.000008277368421f,
                -0.000004515921053f,
                -0.000001522894737f,
                0.000000287894737f,
                0.000000952894737f,
                0.000000759473684f
                #endregion
            }, false);


            dc.InputSignal1 = new Signal(new List <float>()
            {
                #region input
                0.0078f,
                0.0042f,
                -0.0010f,
                -0.0089f,
                -0.0195f,
                -0.0321f,
                -0.0453f,
                -0.0570f,
                -0.0644f,
                -0.0645f,
                -0.0541f,
                -0.0308f,
                0.0065f,
                0.0569f,
                0.1168f,
                0.1802f,
                0.2385f,
                0.2815f,
                0.2985f,
                0.2802f,
                0.2203f,
                0.1175f,
                -0.0234f,
                -0.1910f,
                -0.3680f,
                -0.5324f,
                -0.6608f,
                -0.7313f,
                -0.7272f,
                -0.6400f,
                -0.4719f,
                -0.2360f,
                0.0441f,
                0.3374f,
                0.6095f,
                0.8269f,
                0.9624f,
                0.9988f,
                0.9313f,
                0.7686f,
                0.5314f,
                0.2493f,
                -0.0436f,
                -0.3133f,
                -0.5307f,
                -0.6752f,
                -0.7370f,
                -0.7172f,
                -0.6271f,
                -0.4853f,
                -0.3147f,
                -0.1384f,
                0.0227f,
                0.1530f,
                0.2430f,
                0.2899f,
                0.2967f,
                0.2707f,
                0.2220f,
                0.1611f,
                0.0979f,
                0.0404f,
                -0.0062f,
                -0.0393f,
                -0.0585f,
                -0.0654f,
                -0.0628f,
                -0.0537f,
                0.0070f,
                -0.0413f,
                -0.0281f,
                -0.0160f,
                -0.0062f,
                0.0009f,
                0.0053f,
                0.0074f
                #endregion
            }, false);

            dc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, dc.OutputNonNormalizedCorrelation));
        }
        public void AutoDirectNormalizedPeriodicCorrelationTestMethod1()
        {
            DirectCorrelation dc = new DirectCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                #region expectedOutput
                1.000000000000000f,
                0.949263346546471f,
                0.803598135141501f,
                0.579174028230784f,
                0.301098116072651f,
                0.000054926433279f,
                -0.291432449983038f,
                -0.542879553167652f,
                -0.729354522706577f,
                -0.834207650618337f,
                -0.850623554132106f,
                -0.781970783046271f,
                -0.640833016250542f,
                -0.446995555767965f,
                -0.224673416186276f,
                0.000607467079631f,
                0.205062378576322f,
                0.369248194252224f,
                0.479921978677686f,
                0.530986938475165f,
                0.523487256764368f,
                0.464754805750753f,
                0.366889967809337f,
                0.244854252770369f,
                0.114442724895062f,
                -0.009583349276823f,
                -0.115006812714489f,
                -0.193162298304378f,
                -0.239399685616858f,
                -0.253025889111290f,
                -0.236825947230794f,
                -0.196288123122651f,
                -0.138681851739129f,
                -0.072116638898228f,
                -0.004698546714708f,
                0.056167997778006f,
                0.104298182282958f,
                0.135073092329783f,
                0.145650243148883f,
                0.135073092329783f,
                0.104298182282958f,
                0.056167997778006f,
                -0.004698546714708f,
                -0.072116638898228f,
                -0.138681851739129f,
                -0.196288123122651f,
                -0.236825947230794f,
                -0.253025889111290f,
                -0.239399685616858f,
                -0.193162298304378f,
                -0.115006812714489f,
                -0.009583349276823f,
                0.114442724895062f,
                0.244854252770369f,
                0.366889967809337f,
                0.464754805750753f,
                0.523487256764368f,
                0.530986938475165f,
                0.479921978677686f,
                0.369248194252224f,
                0.205062378576322f,
                0.000607467079631f,
                -0.224673416186276f,
                -0.446995555767965f,
                -0.640833016250543f,
                -0.781970783046271f,
                -0.850623554132106f,
                -0.834207650618337f,
                -0.729354522706577f,
                -0.542879553167652f,
                -0.291432449983038f,
                0.000054926433279f,
                0.301098116072651f,
                0.579174028230784f,
                0.803598135141502f,
                0.949263346546471f,
                #endregion
            }, true);


            dc.InputSignal1 = new Signal(new List <float>()
            {
                #region input
                0.0078f,
                0.0042f,
                -0.0010f,
                -0.0089f,
                -0.0195f,
                -0.0321f,
                -0.0453f,
                -0.0570f,
                -0.0644f,
                -0.0645f,
                -0.0541f,
                -0.0308f,
                0.0065f,
                0.0569f,
                0.1168f,
                0.1802f,
                0.2385f,
                0.2815f,
                0.2985f,
                0.2802f,
                0.2203f,
                0.1175f,
                -0.0234f,
                -0.1910f,
                -0.3680f,
                -0.5324f,
                -0.6608f,
                -0.7313f,
                -0.7272f,
                -0.6400f,
                -0.4719f,
                -0.2360f,
                0.0441f,
                0.3374f,
                0.6095f,
                0.8269f,
                0.9624f,
                0.9988f,
                0.9313f,
                0.7686f,
                0.5314f,
                0.2493f,
                -0.0436f,
                -0.3133f,
                -0.5307f,
                -0.6752f,
                -0.7370f,
                -0.7172f,
                -0.6271f,
                -0.4853f,
                -0.3147f,
                -0.1384f,
                0.0227f,
                0.1530f,
                0.2430f,
                0.2899f,
                0.2967f,
                0.2707f,
                0.2220f,
                0.1611f,
                0.0979f,
                0.0404f,
                -0.0062f,
                -0.0393f,
                -0.0585f,
                -0.0654f,
                -0.0628f,
                -0.0537f,
                0.0070f,
                -0.0413f,
                -0.0281f,
                -0.0160f,
                -0.0062f,
                0.0009f,
                0.0053f,
                0.0074f
                #endregion
            }, true);

            dc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, dc.OutputNormalizedCorrelation));
        }
        public void AutoDirectNormalizedNonPeriodicCorrelationTestMethod1()
        {
            DirectCorrelation dc = new DirectCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                #region expectedOutput
                1.000000000000000f,
                0.949258123988644f,
                0.803591582514373f,
                0.579172048508587f,
                0.301108588332576f,
                0.000085980384627f,
                -0.291375530255426f,
                -0.542798855058250f,
                -0.729307631882456f,
                -0.834170871940141f,
                -0.850634201924987f,
                -0.782079625241122f,
                -0.641105408109733f,
                -0.447505288088622f,
                -0.225489315078280f,
                -0.000557410328650f,
                0.203558170630646f,
                0.367497945201271f,
                0.478130052312350f,
                0.529489342874014f,
                0.522753633063938f,
                0.465364550234759f,
                0.369475305847400f,
                0.250003358198783f,
                0.122569800295161f,
                0.001606029727121f,
                -0.101161210217209f,
                -0.177696176467876f,
                -0.224059248090833f,
                -0.240257222011648f,
                -0.229638305206877f,
                -0.197971565597520f,
                -0.152377186264090f,
                -0.100265370540975f,
                -0.048420914129124f,
                -0.002320586386477f,
                0.034268192296570f,
                0.059400286048142f,
                0.072825121574442f,
                0.075672806281640f,
                0.070029989986388f,
                0.058488584164483f,
                0.043722367414417f,
                0.028148731642748f,
                0.013695334524961f,
                0.001683442474869f,
                -0.007187642023918f,
                -0.012768667099642f,
                -0.015340437526025f,
                -0.015466121836501f,
                -0.013845602497280f,
                -0.011189379003944f,
                -0.008127075400100f,
                -0.005149105428414f,
                -0.002585338038063f,
                -0.000609744484006f,
                0.000733623700431f,
                0.001497595601151f,
                0.001791926365337f,
                0.001750249050953f,
                0.001504207945677f,
                0.001164877408282f,
                0.000815898892004f,
                0.000509732320658f,
                0.000272391859191f,
                0.000108842194851f,
                0.000010647792881f,
                -0.000036778678196f,
                -0.000046890824121f,
                -0.000080698109402f,
                -0.000056919727612f,
                -0.000031053951348f,
                -0.000010472259925f,
                0.000001979722198f,
                0.000006552627128f,
                0.000005222557827f,

                #endregion
            }, false);


            dc.InputSignal1 = new Signal(new List <float>()
            {
                #region input
                0.0078f,
                0.0042f,
                -0.0010f,
                -0.0089f,
                -0.0195f,
                -0.0321f,
                -0.0453f,
                -0.0570f,
                -0.0644f,
                -0.0645f,
                -0.0541f,
                -0.0308f,
                0.0065f,
                0.0569f,
                0.1168f,
                0.1802f,
                0.2385f,
                0.2815f,
                0.2985f,
                0.2802f,
                0.2203f,
                0.1175f,
                -0.0234f,
                -0.1910f,
                -0.3680f,
                -0.5324f,
                -0.6608f,
                -0.7313f,
                -0.7272f,
                -0.6400f,
                -0.4719f,
                -0.2360f,
                0.0441f,
                0.3374f,
                0.6095f,
                0.8269f,
                0.9624f,
                0.9988f,
                0.9313f,
                0.7686f,
                0.5314f,
                0.2493f,
                -0.0436f,
                -0.3133f,
                -0.5307f,
                -0.6752f,
                -0.7370f,
                -0.7172f,
                -0.6271f,
                -0.4853f,
                -0.3147f,
                -0.1384f,
                0.0227f,
                0.1530f,
                0.2430f,
                0.2899f,
                0.2967f,
                0.2707f,
                0.2220f,
                0.1611f,
                0.0979f,
                0.0404f,
                -0.0062f,
                -0.0393f,
                -0.0585f,
                -0.0654f,
                -0.0628f,
                -0.0537f,
                0.0070f,
                -0.0413f,
                -0.0281f,
                -0.0160f,
                -0.0062f,
                0.0009f,
                0.0053f,
                0.0074f
                #endregion
            }, false);

            dc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, dc.OutputNormalizedCorrelation));
        }
        public void AutoDirectNonNormalizedPeriodicCorrelationTestMethod1()
        {
            DirectCorrelation dc = new DirectCorrelation();

            var expectedOutput = new Signal(new List <float>()
            {
                #region expectedOutput
                0.145421785526316f,
                0.138043570789474f,
                0.116860675657895f,
                0.084224521315789f,
                0.043786225657895f,
                0.000007987500000f,
                -0.042380627236842f,
                -0.078946513947368f,
                -0.106064036973684f,
                -0.121311966052632f,
                -0.123699196052632f,
                -0.113715587500000f,
                -0.093191081447368f,
                -0.065002891842105f,
                -0.032672409342105f,
                0.000088338947368f,
                0.029820537236842f,
                0.053696731710526f,
                0.069791111052632f,
                0.077217068684211f,
                0.076126451578947f,
                0.067585473684211f,
                0.053353794210526f,
                0.035607142631579f,
                0.016642465394737f,
                -0.001393627763158f,
                -0.016724496052632f,
                -0.028090006315789f,
                -0.034813929736842f,
                -0.036795476578947f,
                -0.034439652105263f,
                -0.028544569342105f,
                -0.020167362500000f,
                -0.010487330394737f,
                -0.000683271052632f,
                0.008168050526316f,
                0.015167227894737f,
                0.019642570263158f,
                0.021180718421053f,
                0.019642570263158f,
                0.015167227894737f,
                0.008168050526316f,
                -0.000683271052632f,
                -0.010487330394737f,
                -0.020167362500000f,
                -0.028544569342105f,
                -0.034439652105263f,
                -0.036795476578947f,
                -0.034813929736842f,
                -0.028090006315789f,
                -0.016724496052632f,
                -0.001393627763158f,
                0.016642465394737f,
                0.035607142631579f,
                0.053353794210526f,
                0.067585473684211f,
                0.076126451578947f,
                0.077217068684211f,
                0.069791111052632f,
                0.053696731710526f,
                0.029820537236842f,
                0.000088338947368f,
                -0.032672409342105f,
                -0.065002891842105f,
                -0.093191081447368f,
                -0.113715587500000f,
                -0.123699196052632f,
                -0.121311966052632f,
                -0.106064036973684f,
                -0.078946513947368f,
                -0.042380627236842f,
                0.000007987500000f,
                0.043786225657895f,
                0.084224521315789f,
                0.116860675657895f,
                0.138043570789474f,

                #endregion
            }, true);


            dc.InputSignal1 = new Signal(new List <float>()
            {
                #region input
                0.0078f,
                0.0042f,
                -0.0010f,
                -0.0089f,
                -0.0195f,
                -0.0321f,
                -0.0453f,
                -0.0570f,
                -0.0644f,
                -0.0645f,
                -0.0541f,
                -0.0308f,
                0.0065f,
                0.0569f,
                0.1168f,
                0.1802f,
                0.2385f,
                0.2815f,
                0.2985f,
                0.2802f,
                0.2203f,
                0.1175f,
                -0.0234f,
                -0.1910f,
                -0.3680f,
                -0.5324f,
                -0.6608f,
                -0.7313f,
                -0.7272f,
                -0.6400f,
                -0.4719f,
                -0.2360f,
                0.0441f,
                0.3374f,
                0.6095f,
                0.8269f,
                0.9624f,
                0.9988f,
                0.9313f,
                0.7686f,
                0.5314f,
                0.2493f,
                -0.0436f,
                -0.3133f,
                -0.5307f,
                -0.6752f,
                -0.7370f,
                -0.7172f,
                -0.6271f,
                -0.4853f,
                -0.3147f,
                -0.1384f,
                0.0227f,
                0.1530f,
                0.2430f,
                0.2899f,
                0.2967f,
                0.2707f,
                0.2220f,
                0.1611f,
                0.0979f,
                0.0404f,
                -0.0062f,
                -0.0393f,
                -0.0585f,
                -0.0654f,
                -0.0628f,
                -0.0537f,
                0.0070f,
                -0.0413f,
                -0.0281f,
                -0.0160f,
                -0.0062f,
                0.0009f,
                0.0053f,
                0.0074f
                #endregion
            }, true);

            dc.Run();

            Assert.IsTrue(UnitTestUtitlities.SignalsSamplesAreEqual(expectedOutput.Samples, dc.OutputNonNormalizedCorrelation));
        }