imported>Unknown at 05:23, 7 February 2021

2021-02-07T05:23:03Z

New page

from wxPython.wx import *
import unittest
from NaCurves import *

class TestGivenFunction(unittest.TestCase):
def testOne(self):
expected = 1 / (1 + 100 * ((-1.0)**2))
actual = givenFunction(-1.0)
self.assertEquals (actual, expected)

def testPow(self):
self.assertEquals (1, (-1.0)**2)

def testMany(self):
dataset = [-1.0, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4, 0.6, 0.8, 1.0]
for x in dataset:
expected = 1 / (1 + 100 * (x**2))
actual = givenFunction(x)
self.assertEquals (actual, expected)

class TestLagrange(unittest.TestCase):
def setUp(self):
self.dataset = [-1.0, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4, 0.6, 0.8, 1.0]
self.l = Lagrange(self.dataset)
def tearDown(self):
self.l = None

def _getX(self, i):
return self.dataset[i]

def testFunctionExistence(self):
self.assert_(Lagrange);

def testInsertPointX(self):
l = Lagrange(self.dataset)
self.assertEquals (l.getControlPointListX(), self.dataset)

def testInsertPointY(self):
l = Lagrange(self.dataset)
listY = []
for x in self.dataset:
listY.append(givenFunction(x))

self.assertEquals (l.getControlPointListY(), listY)

def testSubBasedFunctionOne(self):
l = Lagrange(self.dataset)
x = -0.1

expected = (x - self._getX(1)) / (self._getX(0) - self._getX(1))
self.assertEquals (l._subBasedFunction(x,0,1), expected)
expected = (x - self._getX(2)) / (self._getX(0) - self._getX(2))
self.assertEquals (l._subBasedFunction(x,0,2), expected)
expected = (x - self._getX(3)) / (self._getX(0) - self._getX(3))
self.assertEquals (l._subBasedFunction(x,0,3), expected)
self.assertEquals (l._subBasedFunction(x,0,0), 1)

def testSubBasedFunctionTwo(self):
l = Lagrange(self.dataset)
x = -0.1

expected = (x - self._getX(0)) / (self._getX(1) - self._getX(0))
self.assertEquals (l._subBasedFunction(x,1,0), expected)
expected = (x - self._getX(2)) / (self._getX(1) - self._getX(2))
self.assertEquals (l._subBasedFunction(x,1,2), expected)
expected = (x - self._getX(3)) / (self._getX(1) - self._getX(3))
self.assertEquals (l._subBasedFunction(x,1,3), expected)
self.assertEquals (l._subBasedFunction(x,1,1), 1)

def testSubBasedFunctionMany(self):
l = Lagrange(self.dataset)
x = -0.3
for i in range(0, len(self.dataset)):
for j in range(0, len(self.dataset)):
actual = l._subBasedFunction (x, i, j)
if i == j:
self.assertEquals (actual, 1)
else:
expected = (x - self._getX(j)) / (self._getX(i) - self._getX(j))
self.assertEquals (expected, actual)

def testBasedFunctionOne(self):
x = -0.1
expected = 1
for i in range(1, len(self.dataset)):
expected *= (x - self._getX(i)) / (self._getX(0) - self._getX(i))
y0 = givenFunction(self.dataset[0])

self.assertEquals (self.l._basedFunction(x, 0), expected)

def testBasedFunctionTwo(self):
x = -0.1
expected = 1
for i in range(0, len(self.dataset)):
if i == 1:
expected *= 1
else:
expected *= (x - self._getX(i)) / (self._getX(1) - self._getX(i))

self.assertEquals (self.l._basedFunction(x, 1), expected)

def testLagrangeFunction(self):
self.assert_(self.l.perform)

def testInterpolation(self):
for x in self.dataset:
expected = givenFunction(x)
actual = self.l.perform(x)
self.assertEquals (actual, expected)

def testOne(self):
listX = [-0.8, -0.6, -0.4]
l = Lagrange(listX)
x = -0.5
expected = 1
actual = l._subBasedFunction(x, 0, 0)
self.assertEquals (actual, expected)

expected = (x - listX[1]) / (listX[0] - listX[1])
actual = l._subBasedFunction(x, 0, 1)
self.assertEquals (actual, expected)

expected = (x - listX[2]) / (listX[0] - listX[2])
actual = l._subBasedFunction(x, 0, 2)
self.assertEquals (actual, expected)

expected = (x - listX[0]) / (listX[1] - listX[0])
actual = l._subBasedFunction(x, 1, 0)
self.assertEquals (actual, expected)

def testTwo(self):
listX = [-0.8, -0.6, -0.4]
l = Lagrange(listX)
x = -0.5

expected = 1
expected *= (x - listX[1]) / (listX[0] - listX[1])
expected *= (x - listX[2]) / (listX[0] - listX[2])
actual = l._basedFunction(x, 0)
self.assertEquals (actual, expected)

def testThree(self):
listX = [-0.8, -0.6, -0.4]
l = Lagrange(listX)

x = -0.8
expected = 1
expected *= (x - listX[1]) / (listX[0] - listX[1])
expected *= (x - listX[2]) / (listX[0] - listX[2])
expected *= givenFunction(x)

actual = l.perform(x)

self.assertEquals (expected, givenFunction(x))
self.assertEquals (actual, expected)

class TestPiecewiseLagrange(unittest.TestCase):
def setUp(self):
self.dataset = [-1.0, -0.8, -0.6, -0.4, -0.2, 0.0, 0.2, 0.4, 0.6, 0.8, 1.0]
def testPiecewiseExistence(self):
self.assert_(PiecewiseLagrange)

def testInsertPointX(self):
pl = PiecewiseLagrange(self.dataset, 4)
self.assertEquals (pl.getControlPointListX(), self.dataset)

def testInterpolation(self):
pl = PiecewiseLagrange(self.dataset, 4)
for x in self.dataset:
expected = givenFunction(x)
actual = pl.perform(x)
self.assertEquals (actual, expected)

def testPerformOne(self):
pl = PiecewiseLagrange(self.dataset, 4)
subPl = Lagrange([-1.0, -0.8, -0.6, -0.4])
x = -0.9
expected = subPl.perform(x)
actual = pl.perform(x)
self.assertEquals (actual, expected)

def testPerformTwo(self):
pl = PiecewiseLagrange(self.dataset, 4)
subPl = Lagrange([-0.4, -0.2, 0.0, 0.2])
x = 0.1
expected = subPl.perform(x)
actual = pl.perform(x)
self.assertEquals (actual, expected)

def testPerformThree(self):
pl = PiecewiseLagrange(self.dataset, 4)
subPl = Lagrange([0.2, 0.4, 0.6, 0.8])
x = 0.5
expected = subPl.perform(x)
actual = pl.perform(x)
self.assertEquals (actual, expected)

def testPerformFour(self):
pl = PiecewiseLagrange(self.dataset, 4)
subPl = Lagrange([0.4, 0.6, 0.8, 1.0])
x = 0.95
expected = subPl.perform(x)
actual = pl.perform(x)
self.assertEquals (actual, expected)

def testControlPointPiece(self):
pl = PiecewiseLagrange(self.dataset, 4)
expected = [-1.0, -0.8, -0.6, -0.4]
actual = pl.getPiece(1)
self.assertEquals (actual, expected)

expected = [-0.4, -0.2, 0.0, 0.2]
actual = pl.getPiece(2)
self.assertEquals (actual, expected)

expected = [0.2, 0.4, 0.6, 0.8]
actual = pl.getPiece(3)
self.assertEquals (actual, expected)

expected = [0.4, 0.6, 0.8, 1.0]
actual = pl.getPiece(4)
self.assertEquals (actual, expected)

def testCountPieces(self):
pl = PiecewiseLagrange(self.dataset, 4)
self.assertEquals (pl.getCountPieces(), 4)

class TestSpline(unittest.TestCase):
def setUp(self):
self.dataset = [-1.0, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4, 0.6, 0.8, 1.0]
self.s = Spline(self.dataset)

def tearDown(self):
self.s = None

def testInterpolation(self):
for x in self.dataset:
expected = givenFunction(x)
actual = self.s.perform(x)
self.assertEquals (actual, expected)

def testInsertPointX(self):
actual = self.s.getControlPointListX()
self.assertEquals (actual, self.dataset)

def testControlPointY(self):
expected = []
for x in self.dataset:
expected.append (givenFunction(x))
actual = self.s.getControlPointListY()
self.assertEquals (actual, expected)

def testDeltaX(self):
expected = -0.8 - (-1.0)
actual = self.s.deltaX(0)
self.assertEquals (actual, expected)

def testDeltaY(self):
expected = givenFunction(self.dataset[1]) - givenFunction(self.dataset[0])
actual = self.s.deltaY(0)
self.assertEquals (actual, expected)

def testEmptyMatrixA(self):
actual = self.s._makeEmptyMatrix()
expected = [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]
self.assertEquals (actual, expected)

def testMatrixA(self):
actual = self.s._makeMatrixA()

for i in range(0,9):
if i-1 >= 0:
self.assertEquals (round(actual[i-1][i], 1), 0.2)
self.assertEquals (round(actual[i][i-1], 1), 0.2)
self.assertEquals (round(actual[i][i], 1), 0.8)

def testMatrixB(self):
actual = self.s._makeMatrixB()

expected = []
for i in range(1,10):
expected.append([6 * ( self.deltaY(i)/self.deltaX(i) - self.deltaY(i-1)/self.deltaX(i-1) )])

self.assertEquals (actual, expected)

def deltaX(self, i):
return self.dataset[i+1] - self.dataset[i]

def deltaY(self, i):
return givenFunction(self.dataset[i+1]) - givenFunction(self.dataset[i])

def testDoublePrimeY(self):
actual = self.s._makeDoublePrimeY()

self.assertEquals (actual[0][0], 0.0)
self.assertEquals (actual[10][0], 0.0)

def testPerform(self):
actual = self.s.perform(0)
print actual

def testAi(self):
actual = self.s.getAi(0)
print actual

def testBi(self):
actual = self.s.getBi(0)
print actual

def testCi(self):
actual = self.s.getCi(0)
print actual

def testDi(self):
actual = self.s.getDi(0)
print actual

class TestApp(wxApp):
def OnInit(self):
return true

if __name__=="__main__":
app = TestApp(0)

unittest.main(argv=('','-v'))

CubicSpline/1002/test NaCurves.py - Revision history

imported>Unknown at 05:23, 7 February 2021