from wxPython.wx import *
import math
import LuDecomposition
import TriDiagonal
DATASET = [-1.0, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4, 0.6, 0.8, 1.0]
def givenFunction(x):
return 1 / (1 + 100 * (x**2))
class NormalFunction:
def perform(self, x):
return givenFunction(x)
class ErrorLagrange:
def __init__(self, aListX):
self.lagrange = Lagrange(aListX)
self.normalFunc = NormalFunction()
def perform(self, x):
return self.normalFunc.perform(x) - self.lagrange.perform(x)
class ErrorPiecewiseLagrange:
def __init__(self, aControlPointListX, aPieceSize):
self.piecewiseLagrange = PiecewiseLagrange(aControlPointListX, aPieceSize)
self.normalFunc = NormalFunction()
def perform(self, x):
return self.normalFunc.perform(x) - self.piecewiseLagrange.perform(x)
class ErrorSpline:
def __init__(self, aControlPointListX):
self.spline = Spline(aControlPointListX)
self.normalFunc = NormalFunction()
def perform(self, x):
return self.normalFunc.perform(x) - self.spline.perform(x)
class Lagrange:
def __init__(self, aListX):
self.controlPointListX = aListX
self.controlPointListY = self._makeControlPointListY()
def _makeControlPointListY(self):
controlPointListY = []
for x in self.controlPointListX:
controlPointListY.append(givenFunction(x))
return controlPointListY
def getControlPointListX(self):
return self.controlPointListX
def getControlPointListY(self):
return self.controlPointListY
def _basedFunction(self, x, i):
bf = 1
for j in range(0, len(self.controlPointListX)):
bf *= self._subBasedFunction(x, i, j)
return bf
def _subBasedFunction(self, x, i, j):
if i == j:
return 1
else:
return (x - self._getX(j)) / (self._getX(i) - self._getX(j))
def perform(self, x):
lg = 0.0
for i in range(0, len(self.controlPointListX)):
lg += self._basedFunction(x, i) * self._getY(i)
return lg
def _getX(self, i):
return self.controlPointListX[i]
def _getY(self, i):
return self.controlPointListY[i]
class PiecewiseLagrange:
def __init__(self, aControlPointListX, aPieceSize):
self.controlPointListX = aControlPointListX
self.pieceSize = aPieceSize
def getControlPointListX(self):
return self.controlPointListX
def perform(self, x):
if (x >= self.controlPointListX[0]) and (x < self.controlPointListX[3]):
return Lagrange(self.getPiece(1)).perform(x)
elif (x >= self.controlPointListX[3]) and (x < self.controlPointListX[6]):
return Lagrange(self.getPiece(2)).perform(x)
elif (x >= self.controlPointListX[6]) and (x < self.controlPointListX[9]):
return Lagrange(self.getPiece(3)).perform(x)
elif (x >= self.controlPointListX[9]) and (x <= self.controlPointListX[10]):
return Lagrange(self.getPiece(4)).perform(x)
def getPiece(self, i):
if ((self.pieceSize-1)*(i-1)+self.pieceSize) > self.getCountControlPoints():
return self.controlPointListX[self.getCountControlPoints()-self.pieceSize : self.getCountControlPoints()]
return self.controlPointListX[self.getFirstPiecePoint(i) : self.getEndPiecePoint(i)]
def getCountControlPoints(self):
return len(self.controlPointListX)
def getFirstPiecePoint(self, i):
return (self.pieceSize-1)*(i-1)
def getEndPiecePoint(self, i):
return (self.pieceSize-1)*(i-1)+self.pieceSize
def getCountPieces(self):
return int(math.ceil( (self.getCountControlPoints()+1) / (self.pieceSize-1) ))
class Spline:
def __init__(self, aControlPointListX):
self.controlPointListX = aControlPointListX
self.controlPointListY = self._makeControlPointListY()
self.doublePrimeListY = self._makeDoublePrimeY()
def getAi(self, i):
return (self.getDoublePrimeY(i+1) - self.getDoublePrimeY(i)) / (6 * self.deltaX(i))
def getBi(self, i):
return (self.getDoublePrimeY(i) / 2)
def getCi(self, i):
return (self.deltaY(i) / self.deltaX(i) ) - (self.deltaX(i) / 6) * (self.getDoublePrimeY(i+1) + (2*self.getDoublePrimeY(i)) )
def getDi(self, i):
return self.getYi(i)
def getXi(self, i):
return self.controlPointListX[i]
def getYi(self, i):
return self.controlPointListY[i]
def getDoublePrimeY(self, i):
return self.doublePrimeListY[i][0]
def getControlPointListX(self):
return self.controlPointListX
def getControlPointListY(self):
return self.controlPointListY
def perform(self, x):
for i in range(0, len(self.controlPointListX)-2):
if (x >= self.getXi(i)) and (x < self.getXi(i+1)):
return self._subCubicSpline(x, i)
if x >= self.getXi(len(self.controlPointListX)-2):
return self._subCubicSpline(x, len(self.controlPointListX)-2)
def _subCubicSpline(self, x, i):
return self.getAi(i) * ((x - self.getXi(i)) ** 3) + self.getBi(i) * ((x - self.getXi(i)) ** 2) + self.getCi(i) * ((x - self.getXi(i))) + self.getDi(i)
def deltaX(self, i):
return self.getXi(i+1) - self.getXi(i)
def deltaY(self, i):
return self.getYi(i+1) - self.getYi(i)
def _makeControlPointListY(self):
cplY = []
for x in self.controlPointListX:
cplY.append (givenFunction(x))
return cplY
def _makeMatrixA(self):
matrixA = self._makeEmptyMatrix()
for i in range(0,9):
matrixA[i][i] = 2 * (self.deltaX(i)+self.deltaX(i+1))
if i>0:
matrixA[i-1][i] = self.deltaX(i)
matrixA[i][i-1] = self.deltaX(i)
return matrixA
def _makeMatrixB(self):
matrixB = []
for i in range(1,10):
matrixB.append([6 * ( self.deltaY(i)/self.deltaX(i) - self.deltaY(i-1)/self.deltaX(i-1) )])
return matrixB
def _makeDoublePrimeY(self):
a = self._makeMatrixA()
b = self._makeMatrixB()
l, u = LuDecomposition.LuDecomposition(a).perform()
matrixY = TriDiagonal.getMatrixY(l, b)
tempY = TriDiagonal.getMatrixX(u, matrixY)
tempY.insert(0, [0.0])
tempY.append([0.0])
return tempY
def _makeEmptyMatrix(self):
n = 9
matrix = []
for i in range(0,n):
row = []
for j in range(0,n):
row.append(0.0)
matrix.append(row)
return matrix
