def testRSubOperator(self):
        ma20 = MovingAverage(20, 'close')
        sumTotal = Sum('close')
        subRes = 5.0 - MovingAverage(20, 'close')
        concated = sumTotal - (ma20 ^ sumTotal)

        for i, close in enumerate(self.sampleClose):
            data = {'close': close}
            ma20.push(data)
            sumTotal.push(data)
            subRes.push(data)
            concated.push(data)

            expected = 5.0 - ma20.result()
            calculated = subRes.result()
            self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
                                                             "expected:   {1:f}\n"
                                                             "calculated: {2:f}".format(i, expected, calculated))

            expected = (sumTotal.result() - ma20.result(), 0.0)
            calculated = concated.result()
            self.assertAlmostEqual(calculated[0], expected[0], 12, "at index {0:d}\n"
                                                                   "expected:   {1:f}\n"
                                                                   "calculated: {2:f}".format(i, expected[0],
                                                                                              calculated[0]))
            self.assertAlmostEqual(calculated[1], expected[1], 12, "at index {0:d}\n"
                                                                   "expected:   {1:f}\n"
                                                                   "calculated: {2:f}".format(i, expected[1],
                                                                                              calculated[1]))
    def testSubOperator(self):
        ma5 = MovingAverage(5, 'close')
        sumTotal = Sum('open')
        subRes = MovingAverage(5, 'close') - Sum('open')
        concated = (MovingAverage(5, 'close') ^ Sum('open')) - Sum('open')

        for i, (open, close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
            data = {'close': close, 'open': open}
            ma5.push(data)
            sumTotal.push(data)
            subRes.push(data)
            concated.push(data)

            expected = ma5.result() - sumTotal.result()
            calculated = subRes.result()
            self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
                                                             "expected:   {1:f}\n"
                                                             "calculated: {2:f}".format(i, expected, calculated))

            expected = (ma5.result() - sumTotal.result(), 0.0)
            calculated = concated.result()
            self.assertAlmostEqual(calculated[0], expected[0], 12, "at index {0:d}\n"
                                                                   "expected:   {1:f}\n"
                                                                   "calculated: {2:f}".format(i, expected[0],
                                                                                              calculated[0]))
            self.assertAlmostEqual(calculated[1], expected[1], 12, "at index {0:d}\n"
                                                                   "expected:   {1:f}\n"
                                                                   "calculated: {2:f}".format(i, expected[1],
                                                                                              calculated[1]))
    def testRSubOperator(self):
        ma20 = MovingAverage(20, 'close')
        sumTotal = Sum('close')
        subRes = 5.0 - MovingAverage(20, 'close')
        concated = sumTotal - (ma20 ^ sumTotal)

        for i, close in enumerate(self.sampleClose):
            data = {'close': close}
            ma20.push(data)
            sumTotal.push(data)
            subRes.push(data)
            concated.push(data)

            expected = 5.0 - ma20.result()
            calculated = subRes.result()
            self.assertAlmostEqual(
                calculated, expected, 12, "at index {0:d}\n"
                "expected:   {1:f}\n"
                "calculated: {2:f}".format(i, expected, calculated))

            expected = (sumTotal.result() - ma20.result(), 0.0)
            calculated = concated.result()
            self.assertAlmostEqual(
                calculated[0], expected[0], 12, "at index {0:d}\n"
                "expected:   {1:f}\n"
                "calculated: {2:f}".format(i, expected[0], calculated[0]))
            self.assertAlmostEqual(
                calculated[1], expected[1], 12, "at index {0:d}\n"
                "expected:   {1:f}\n"
                "calculated: {2:f}".format(i, expected[1], calculated[1]))
    def testSubOperator(self):
        ma5 = MovingAverage(5, 'close')
        sumTotal = Sum('open')
        subRes = MovingAverage(5, 'close') - Sum('open')
        concated = (MovingAverage(5, 'close') ^ Sum('open')) - Sum('open')

        for i, (open,
                close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
            data = {'close': close, 'open': open}
            ma5.push(data)
            sumTotal.push(data)
            subRes.push(data)
            concated.push(data)

            expected = ma5.result() - sumTotal.result()
            calculated = subRes.result()
            self.assertAlmostEqual(
                calculated, expected, 12, "at index {0:d}\n"
                "expected:   {1:f}\n"
                "calculated: {2:f}".format(i, expected, calculated))

            expected = (ma5.result() - sumTotal.result(), 0.0)
            calculated = concated.result()
            self.assertAlmostEqual(
                calculated[0], expected[0], 12, "at index {0:d}\n"
                "expected:   {1:f}\n"
                "calculated: {2:f}".format(i, expected[0], calculated[0]))
            self.assertAlmostEqual(
                calculated[1], expected[1], 12, "at index {0:d}\n"
                "expected:   {1:f}\n"
                "calculated: {2:f}".format(i, expected[1], calculated[1]))
    def testSum(self):
        mm = Sum(dependency='close')

        for i, value in enumerate(self.samplesClose):
            mm.push(dict(close=value))
            expected = np.sum(self.samplesClose[:i + 1])
            calculated = mm.result()

            self.assertAlmostEqual(expected, calculated, 10, "at index {0:d}\n"
                                                             "expected sum:   {1:f}\n"
                                                             "calculated sum: {2:f}".format(i, expected, calculated))
    def testSum(self):
        mm = Sum(dependency='close')

        for i, value in enumerate(self.samplesClose):
            mm.push(dict(close=value))
            expected = np.sum(self.samplesClose[:i + 1])
            calculated = mm.result()

            self.assertAlmostEqual(
                expected, calculated, 10, "at index {0:d}\n"
                "expected sum:   {1:f}\n"
                "calculated sum: {2:f}".format(i, expected, calculated))
    def testCompoundedOperator(self):
        ma5 = MovingAverage(5, 'x')
        maxer = Max('close')
        max5ma = Max('close') >> MovingAverage(5)
        max5ma2 = MovingAverage(5, Max('close'))
        average = Average('close')
        sumM = Sum('close')
        mvTest = Correlation(dependency=('x', 'y'))
        mvCorr = (Average('close') ^ Sum('close')) >> Correlation(dependency=('x', 'y'))

        for i, close in enumerate(self.sampleClose):
            data = {'close': close, 'open': open}
            maxer.push(data)
            data2 = {'x': maxer.result()}
            ma5.push(data2)
            max5ma.push(data)
            max5ma2.push(data)
            average.push(data)
            sumM.push(data)
            data3 = {'x': average.result(), 'y': sumM.result()}
            mvTest.push(data3)
            mvCorr.push(data)

            expected = ma5.result()
            calculated = max5ma.result()
            self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
                                                             "expected:   {1:f}\n"
                                                             "calculated: {2:f}".format(i, expected, calculated))

            calculated = max5ma2.result()
            self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
                                                             "expected:   {1:f}\n"
                                                             "calculated: {2:f}".format(i, expected, calculated))

            if i >= 1:
                expected = mvTest.result()
                calculated = mvCorr.result()
                self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
                                                                 "expected:   {1:f}\n"
                                                                 "calculated: {2:f}".format(i, expected, calculated))

        with self.assertRaises(ValueError):
            _ = Max('close') >> math.sqrt

        with self.assertRaises(ValueError):
            _ = (Max('close') ^ Minimum('close')) >> MovingCorrelation(20, dependency=('x', 'y', 'z'))

        (Max('close') ^ Minimum('close')) >> MovingCorrelation(20, dependency=('x', 'y'))
Ejemplo n.º 8
0
    def testCompoundedOperator(self):
        ma5 = MovingAverage(5, 'x')
        maxer = Max('close')
        max5ma = Max('close') >> MovingAverage(5)
        max5ma2 = MovingAverage(5, Max('close'))
        average = Average('close')
        sumM = Sum('close')
        mvTest = Correlation(dependency=('x', 'y'))
        mvCorr = (Average('close')
                  ^ Sum('close')) >> Correlation(dependency=('x', 'y'))

        for i, close in enumerate(self.sampleClose):
            data = {'close': close, 'open': 1.}
            maxer.push(data)
            data2 = {'x': maxer.result()}
            ma5.push(data2)
            max5ma.push(data)
            max5ma2.push(data)
            average.push(data)
            sumM.push(data)
            data3 = {'x': average.result(), 'y': sumM.result()}
            mvTest.push(data3)
            mvCorr.push(data)

            expected = ma5.result()
            calculated = max5ma.result()
            self.assertAlmostEqual(
                calculated, expected, 12, "at index {0:d}\n"
                "expected:   {1:f}\n"
                "calculated: {2:f}".format(i, expected, calculated))

            calculated = max5ma2.result()
            self.assertAlmostEqual(
                calculated, expected, 12, "at index {0:d}\n"
                "expected:   {1:f}\n"
                "calculated: {2:f}".format(i, expected, calculated))

            if i >= 1:
                expected = mvTest.result()
                calculated = mvCorr.result()
                self.assertAlmostEqual(
                    calculated, expected, 12, "at index {0:d}\n"
                    "expected:   {1:f}\n"
                    "calculated: {2:f}".format(i, expected, calculated))

        with self.assertRaises(ValueError):
            _ = Max('close') >> math.sqrt

        with self.assertRaises(ValueError):
            _ = (Max('close') ^ Min('close')) >> MovingCorrelation(
                20, dependency=('x', 'y', 'z'))

        (Max('close') ^ Min('close')) >> MovingCorrelation(
            20, dependency=('x', 'y'))