def getListOfInterpolationFcts(listOfDomainBorders, listOfTuckerGridNodes,
finalOrthNormalizedEigVects, Axis_k):
"""
Fonction qui reconstruit les vecteurs propres gardés dans l'axis "Axis_k" par l'interpolation de Lagrange :
+ Une l'interpolation de Lagrange si il n'y a pas de coupage
+ Des interpolations de Lagrange par morceau si il y a de coupages
Argument:
+ listOfDomainBorders : liste des extrêmes (après avoir effectué le coupage)
+ listOfTuckerGridNodes : dictionnaire, contenant les points dans tous les discrétisations fines
+ finalOrthNormalizedEigVects : dictionnaire, contenant tous les vecteurs de base orthonormés par direction
Axis_k : axis considéré
retourne:
les fonctions de base (les polynômes de Lagrange) pour la direction considérée (Axis_k)
"""
listOfBasicFctsUsingLagrangeInterpolation_Axis_k = []
nbExtremes = len(listOfDomainBorders[str(Axis_k)])
nbOfFcts_Axis_k = len(finalOrthNormalizedEigVects[str(Axis_k)])
listOfTuckerGridNodes[str(Axis_k)] = np.asarray(
listOfTuckerGridNodes[str(Axis_k)])
for i in range(nbOfFcts_Axis_k):
### Define each sub-polynomial/sub-interval if the main interval of "Axis_k" is subdivided
if nbExtremes > 2:
polLagrange_ki = []
for j in range(nbExtremes - 1):
#print listOfTuckerGridNodes[str(Axis_k)]
#print listOfDomainBorders[str(Axis_k)][j]
#raw_input()
value1 = find_nearest(listOfTuckerGridNodes[str(Axis_k)],
listOfDomainBorders[str(Axis_k)][j])
value2 = find_nearest(listOfTuckerGridNodes[str(Axis_k)],
listOfDomainBorders[str(Axis_k)][j + 1])
j1Arr = np.where(
listOfTuckerGridNodes[str(Axis_k)] == value1)[0].tolist()
j2Arr = np.where(
listOfTuckerGridNodes[str(Axis_k)] == value2)[0].tolist()
j1 = j1Arr[-1]
j2 = j2Arr[0]
j2 = j2 + 1
interp_k_couplage = LagrangePolynomial.LagrangePolynomial(listOfTuckerGridNodes[str(Axis_k)][j1:j2],\
finalOrthNormalizedEigVects[str(Axis_k)][i][j1:j2])
polLagrange_ki.append(interp_k_couplage)
### Define the polynomial if the main interval of Axis_k is NOT subdivided
elif nbExtremes == 2:
polLagrange_ki = [ LagrangePolynomial.LagrangePolynomial(listOfTuckerGridNodes[str(Axis_k)],\
finalOrthNormalizedEigVects[str(Axis_k)][i])]
listOfBasicFctsUsingLagrangeInterpolation_Axis_k.append(polLagrange_ki)
return listOfBasicFctsUsingLagrangeInterpolation_Axis_k
def getListOfInterpolationFcts(self):
"""
Fonction qui reconstruit les vecteurs propres gardés dans l'axis "Axis_k" par l'interpolation de Lagrange :
+ Une l'interpolation de Lagrange si il n'y a pas de coupage
+ Des interpolations de Lagrange par morceau si il y a de coupages
Argument:
rien
retourne:
rien
"""
self.listOfBasicFctsUsingLagrangeInterpolation_Axis_k = []
nbExtremes = len(self.listOfBorders[str(self.Axis_k)])
for i in range(self.nbOfFcts_Axis_k):
### Define each sub-polynomial/sub-interval if the main interval of "Axis_k" is subdivided
if nbExtremes > 2:
polLagrange_ki = []
for j in range(nbExtremes - 1):
j1Arr = np.where(
self.listOfTuckerGridNodes_Axis_k[self.Axis_k] ==
self.listOfBorders[str(self.Axis_k)][j])[0].tolist()
j2Arr = np.where(
self.listOfTuckerGridNodes_Axis_k[self.Axis_k] ==
self.listOfBorders[str(self.Axis_k)][j +
1])[0].tolist()
j1 = j1Arr[-1]
j2 = j2Arr[0]
j2 = j2 + 1
###because [j1:j2] take the values before j2
interp_k_couplage = LagrangePolynomial.LagrangePolynomial(self.listOfTuckerGridNodes_Axis_k[self.Axis_k][j1:j2],\
self.finalOrthNormalizedEigVects_Axis_k[i][j1:j2].T)
polLagrange_ki.append(interp_k_couplage)
### Define the polynomial if the main interval of Axis_k is NOT subdivided
elif nbExtremes == 2:
polLagrange_ki = [ LagrangePolynomial.LagrangePolynomial(self.listOfTuckerGridNodes_Axis_k[self.Axis_k],\
self.finalOrthNormalizedEigVects_Axis_k[i].T)]
self.listOfBasicFctsUsingLagrangeInterpolation_Axis_k.append(
polLagrange_ki)
def getListOfInterpolationFcts(self):
self.listOfBasicFctsUsingLagrangeInterpolation_Axis_k = []
nbExtremes = len(self.listOfBorders[str(self.Axis_k)])
for i in range(self.nbOfFcts_Axis_k):
### Define each sub-polynomial/sub-interval if the main interval of Axis_k is subdivided
if nbExtremes > 2:
polLagrange_ki = []
for j in range(nbExtremes - 1):
j1Arr = np.where(
self.listOfTuckerGridNodes_Axis_k[self.Axis_k] ==
self.listOfBorders[str(self.Axis_k)][j])[0].tolist()
j2Arr = np.where(
self.listOfTuckerGridNodes_Axis_k[self.Axis_k] ==
self.listOfBorders[str(self.Axis_k)][j +
1])[0].tolist()
print "j1=", j1Arr
print "j2=", j2Arr
print self.listOfBorders[str(self.Axis_k)]
j1 = j1Arr[-1]
j2 = j2Arr[0]
j2 = j2 + 1
###because [j1:j2] take the values before j2
interp_k_couplage = LagrangePolynomial.LagrangePolynomial(self.listOfTuckerGridNodes_Axis_k[self.Axis_k][j1:j2],\
self.finalOrthNormalizedEigVects_Axis_k[i][j1:j2].T)
polLagrange_ki.append(interp_k_couplage)
### Define the polynomial if the main interval of Axis_k is NOT subdivided
elif nbExtremes == 2:
polLagrange_ki = [ LagrangePolynomial.LagrangePolynomial(self.listOfTuckerGridNodes_Axis_k[self.Axis_k],\
self.finalOrthNormalizedEigVects_Axis_k[i].T)]
self.listOfBasicFctsUsingLagrangeInterpolation_Axis_k.append(
polLagrange_ki)
def getEmpiricalPoints(listOfFcts, listOfInitialInterpolationPoints, orderInterpolation):
"""
focntion qui fournit la liste des points communs pour toutes les sections efficaces qui sont utilisés dans la résolution des coefficients de Tucker
Argument:
listOfFcts [une liste d'arrays]: chaque array réprésente un vecteur propre gardé pour une direction donnée qui est utilisé dans la décomposition de Tucker
listOfInitialInterpolationPoints [une liste ou array des flottants] : coordonées des points sur lesquels on sélectionne les points par greedy
orderInterpolation [un entier] : un ordre de l'interpolation de Lagrange et aussi le nombre de points que l'on veut sélectionner
retourne:
listOfFinalEmpericalInterpolationPoints [une liste ou array des flottants] : coordonées des points sélectionnés par greedy
listOfFinalIndexOfEmpiricalInterpolationPoints [une liste ou array des entiers] : indices des points sélectionnés par greedy
"""
listOfFinalIndexOfEmpiricalInterpolationPoints = []
listOfFinalEmpericalInterpolationPoints = []
for m in range(orderInterpolation):
listOfResiduaForInterpolation_m = []
listOfInterpolFcts = []
if m == 0:
indexOfArgMaxPoint, indexOfFctMax = getMaxOfAListOfFcts(listOfFcts)
argMaxPoint = listOfInitialInterpolationPoints[indexOfArgMaxPoint]
listOfFinalIndexOfEmpiricalInterpolationPoints.append(indexOfArgMaxPoint)
listOfFinalEmpericalInterpolationPoints.append(argMaxPoint)
for indexFct in range(len(listOfFcts)):
basisFctAtArgMaxPoint_m_indexFct = listOfFcts[indexFct][indexOfArgMaxPoint]
interpolFct_m_indexFct = basisFctAtArgMaxPoint_m_indexFct * (listOfFcts[indexOfFctMax]/listOfFcts[indexOfFctMax][indexOfArgMaxPoint])
residua_m_indexFct = listOfFcts[indexFct] - interpolFct_m_indexFct
listOfResiduaForInterpolation_m.append(residua_m_indexFct)
if m > 0:
indexOfArgMaxPoint, indexOfFctMax = getMaxOfAListOfFcts(listOfResiduaForInterpolation_m_previous)
argMaxPoint = listOfInitialInterpolationPoints[indexOfArgMaxPoint]
listOfFinalIndexOfEmpiricalInterpolationPoints.append(indexOfArgMaxPoint)
listOfFinalEmpericalInterpolationPoints.append(argMaxPoint)
for indexFct in range(len(listOfFcts)):
listOfFinalIndexOfEmpiricalInterpolationPoints_array = np.asarray(listOfFinalIndexOfEmpiricalInterpolationPoints)
listOfInitialInterpolationPoints_array = np.asarray(listOfFinalEmpericalInterpolationPoints)
valuesOfBasisFctOnInterpolationPoints = listOfFcts[indexFct][listOfFinalIndexOfEmpiricalInterpolationPoints_array]
Lagrangefct = [LagrangePolynomial.LagrangePolynomial(listOfInitialInterpolationPoints_array, valuesOfBasisFctOnInterpolationPoints)]
interpolFct_m_indexFct = LI.getInterpolationArr(Lagrangefct, listOfInitialInterpolationPoints)
residua_m_indexFct = listOfFcts[indexFct] - interpolFct_m_indexFct
listOfResiduaForInterpolation_m.append(residua_m_indexFct)
listOfResiduaForInterpolation_m_previous = listOfResiduaForInterpolation_m ### Exist after the first loop m=0
return listOfFinalEmpericalInterpolationPoints, listOfFinalIndexOfEmpiricalInterpolationPoints
import numpy as np
from LagrangePolynomial import *
#from random import * # randint function definition
def column(matrix, j):
col = [matrix[i][j] for i in range(len(matrix))]
return col
''' The format of the file must be such that between each data has to be an space. '''
data_matrix = np.loadtxt("regvolneg.txt", dtype='f', delimiter=' ')
print(data_matrix)
x_values = range(3, 16)
print(x_values)
for j in range(len(data_matrix[0])):
lpol = LagrangePolynomial()
lpol.set_points(list(x_values), column(data_matrix, j))
y = [lpol.evaluate(xi) for xi in x_values]
plt.plot(x_values, y, label='fdafda')
tags = ['LM7905', 'LM7912']
plt.title("Regulador de voltaje fijo negativo")
plt.xlabel("Voltaje de la fuente")
plt.ylabel(r'Voltaje en $R_o$')
plt.legend(tags)
plt.grid(True) # cuadriculado
plt.show()
def getEmpiricalPoints(listOfFcts, listOfInitialInterpolationPoints,
orderInterpolation):
listOfFinalIndexOfEmpiricalInterpolationPoints = []
listOfFinalEmpericalInterpolationPoints = []
for m in range(orderInterpolation):
listOfResiduaForInterpolation_m = []
listOfInterpolFcts = []
if m == 0:
indexOfArgMaxPoint, indexOfFctMax = getMaxOfAListOfFcts(listOfFcts)
argMaxPoint = listOfInitialInterpolationPoints[indexOfArgMaxPoint]
listOfFinalIndexOfEmpiricalInterpolationPoints.append(
indexOfArgMaxPoint)
listOfFinalEmpericalInterpolationPoints.append(argMaxPoint)
for indexFct in range(len(listOfFcts)):
basisFctAtArgMaxPoint_m_indexFct = listOfFcts[indexFct][
indexOfArgMaxPoint]
interpolFct_m_indexFct = basisFctAtArgMaxPoint_m_indexFct * (
listOfFcts[indexOfFctMax] /
listOfFcts[indexOfFctMax][indexOfArgMaxPoint])
residua_m_indexFct = listOfFcts[
indexFct] - interpolFct_m_indexFct
listOfResiduaForInterpolation_m.append(residua_m_indexFct)
if m > 0:
indexOfArgMaxPoint, indexOfFctMax = getMaxOfAListOfFcts(
listOfResiduaForInterpolation_m_previous)
argMaxPoint = listOfInitialInterpolationPoints[indexOfArgMaxPoint]
listOfFinalIndexOfEmpiricalInterpolationPoints.append(
indexOfArgMaxPoint)
listOfFinalEmpericalInterpolationPoints.append(argMaxPoint)
for indexFct in range(len(listOfFcts)):
listOfFinalIndexOfEmpiricalInterpolationPoints_array = np.asarray(
listOfFinalIndexOfEmpiricalInterpolationPoints)
listOfInitialInterpolationPoints_array = np.asarray(
listOfFinalEmpericalInterpolationPoints)
valuesOfBasisFctOnInterpolationPoints = listOfFcts[indexFct][
listOfFinalIndexOfEmpiricalInterpolationPoints_array]
Lagrangefct = [
LagrangePolynomial.LagrangePolynomial(
listOfInitialInterpolationPoints_array,
valuesOfBasisFctOnInterpolationPoints)
]
interpolFct_m_indexFct = LI.getInterpolationArr(
Lagrangefct, listOfInitialInterpolationPoints)
residua_m_indexFct = listOfFcts[
indexFct] - interpolFct_m_indexFct
listOfResiduaForInterpolation_m.append(residua_m_indexFct)
listOfResiduaForInterpolation_m_previous = listOfResiduaForInterpolation_m ### Exist after the first loop m=0
return listOfFinalEmpericalInterpolationPoints, listOfFinalIndexOfEmpiricalInterpolationPoints
def getListOfInterpolationFcts(listOfBorders, listOfTuckerGridNodes_Axis_k,
finalOrthNormalizedEigVects_Axis_k, Axis_k):
"""
Fonction qui reconstruit les vecteurs propres gardés dans l'axis "Axis_k" par l'interpolation de Lagrange :
+ Une l'interpolation de Lagrange si il n'y a pas de coupage
+ Des interpolations de Lagrange par morceau si il y a de coupages
Argument:
rien
retourne:
rien
"""
listOfBasicFctsUsingLagrangeInterpolation_Axis_k = []
nbExtremes = len(listOfBorders[str(Axis_k)])
nbOfFcts_Axis_k = len(finalOrthNormalizedEigVects_Axis_k[str(Axis_k)])
#print nbOfFcts_Axis_k
#raw_input()
#print "Axis_k =", Axis_k
for i in range(nbOfFcts_Axis_k):
### Define each sub-polynomial/sub-interval if the main interval of "Axis_k" is subdivided
#print "i =", i
if nbExtremes > 2:
polLagrange_ki = []
for j in range(nbExtremes - 1):
#print listOfTuckerGridNodes_Axis_k[str(Axis_k)]
#print listOfBorders[str(Axis_k)]
#raw_input()
#j1Arr = listOfTuckerGridNodes_Axis_k[str(Axis_k)].index(listOfBorders[str(Axis_k)][j])
#j2Arr = listOfTuckerGridNodes_Axis_k[str(Axis_k)].index(listOfBorders[str(Axis_k)][j+1])
### Finding the nearest value ensures that j1Arr <> [] and j2Arr <> []
value1 = find_nearest(
listOfTuckerGridNodes_Axis_k[str(Axis_k)],
listOfBorders[str(Axis_k)][j])
value2 = find_nearest(
listOfTuckerGridNodes_Axis_k[str(Axis_k)],
listOfBorders[str(Axis_k)][j + 1])
j1Arr = np.where(listOfTuckerGridNodes_Axis_k[str(Axis_k)] ==
value1)[0].tolist()
j2Arr = np.where(listOfTuckerGridNodes_Axis_k[str(Axis_k)] ==
value2)[0].tolist()
#j1Arr =np.where(listOfTuckerGridNodes_Axis_k[str(Axis_k)] == listOfBorders[str(Axis_k)][j])[0].tolist()
#j2Arr = np.where(listOfTuckerGridNodes_Axis_k[str(Axis_k)] == listOfBorders[str(Axis_k)][j+1])[0].tolist()
#print j
#print j1Arr
#print j2Arr
j1 = j1Arr[-1]
j2 = j2Arr[0]
j2 = j2 + 1
#print j1
#print j2
#raw_input()
###because [j1:j2] take the values before j2
interp_k_couplage = LagrangePolynomial.LagrangePolynomial(listOfTuckerGridNodes_Axis_k[str(Axis_k)][j1:j2],\
finalOrthNormalizedEigVects_Axis_k[str(Axis_k)][i][j1:j2].T)
polLagrange_ki.append(interp_k_couplage)
### Define the polynomial if the main interval of Axis_k is NOT subdivided
elif nbExtremes == 2:
#print "i = ", i
#print finalOrthNormalizedEigVects_Axis_k[str(Axis_k)][i]
#print "Axis_k =", Axis_k
#raw_input()
polLagrange_ki = [ LagrangePolynomial.LagrangePolynomial(listOfTuckerGridNodes_Axis_k[str(Axis_k)],\
finalOrthNormalizedEigVects_Axis_k[str(Axis_k)][i])]
listOfBasicFctsUsingLagrangeInterpolation_Axis_k.append(polLagrange_ki)
return listOfBasicFctsUsingLagrangeInterpolation_Axis_k
p = np.poly1d(coef)
print(p)
#Lagrange form
lagr_poly = interpolate.lagrange(df.X, df.Y)
print(lagr_poly)
#Graficos
x = np.linspace(df.X.min(), df.X.max())
fig, ax = plt.subplots(2, 1)
ax[0].plot(x, lagr_poly(x), 'b-')
ax[0].plot(df.X, df.Y, 'ro')
ax[0].set_title('$Lagrange$ $form$')
ax[1].plot(x, p(x), 'g-')
ax[1].plot(df.X, df.Y, 'ro')
ax[1].set_title('$Numpy$ $form$')
plt.show()
#Evaluando polinomios de lagrange
print(LP.L(df.X,
0)(df.X)) #para el primer punto su valor es 1 y para el resto es 0
print(LP.L(df.X, 1)(df.X))
print(LP.L(df.X, 2)(df.X))
print(LP.L(df.X, 3)(df.X))