float Curva::Xn(int n){
if (n >= cantidadDePuntos)
return Xn(n-cantidadDePuntos);
if (n < 0)
return Xn(n+cantidadDePuntos);
return this->puntos[n]->X();
}
double Newton::calcular(double alfa) {
double xn_1 = calcularPuntoInicial();
double xn = Xn(xn_1);
int i=0;
while(i< 10000) {
xn_1 = xn; ///Me guardo el xn-1 para poder definir otro criterio de parada mas inteligente.
xn = Xn(xn);
i++;
}
return xn_1;
}
Real gammaFunc(const Array& X)const{
Real res=0.0;
Array Xn(X.size());
for(Size j=0; j< ySize_;++j){
for(Size i=0; i< xSize_;++i){
Xn[0]=this->xBegin_[i];
Xn[1]=this->yBegin_[j];
res+=kernelAbs(X,Xn);
}
}
return res;
}
void updateAlphaVec(){
// Function calculates the alpha vector with given
// fixed pillars+values
Array Xk(2),Xn(2);
Size rowCnt=0,colCnt=0;
Real tmpVar=0.0;
// write y-vector and M-Matrix
for(Size j=0; j< ySize_;++j){
for(Size i=0; i< xSize_;++i){
yVec_[rowCnt]=this->zData_[i][j];
// calculate X_k
Xk[0]=this->xBegin_[i];
Xk[1]=this->yBegin_[j];
tmpVar=1/gammaFunc(Xk);
colCnt=0;
for(Size jM=0; jM< ySize_;++jM){
for(Size iM=0; iM< xSize_;++iM){
Xn[0]=this->xBegin_[iM];
Xn[1]=this->yBegin_[jM];
M_[rowCnt][colCnt]=kernelAbs(Xk,Xn)*tmpVar;
colCnt++; // increase column counter
}// end iM
}// end jM
rowCnt++; // increase row counter
} // end i
}// end j
alphaVec_=qrSolve(M_, yVec_);
// check if inversion worked up to a reasonable precision.
// I've chosen not to check determinant(M_)!=0 before solving
Array diffVec=Abs(M_*alphaVec_ - yVec_);
for (Size i=0; i<diffVec.size(); ++i) {
QL_REQUIRE(diffVec[i]<invPrec_,
"inversion failed in 2d kernel interpolation");
}
}
Real value(Real x1, Real x2) const {
Real res=0.0;
Array X(2),Xn(2);
X[0]=x1;X[1]=x2;
Size cnt=0; // counter
for( Size j=0; j< ySize_;++j){
for( Size i=0; i< xSize_;++i){
Xn[0]=this->xBegin_[i];
Xn[1]=this->yBegin_[j];
res+=alphaVec_[cnt]*kernelAbs(X,Xn);
cnt++;
}
}
return res/gammaFunc(X);
}
