Static Objects

[ArtemisTheHunter]

Hi guys

I'm trying to use a static object for save the positions of an array.

Sorry, tomorrow I edit with more info


PLEASE WAIT,Tomorrow I edit with more info

/*========================================================================
  FUNCIONES PARA EL MANEJO DE ARITMETICAS DE PRECISION FINITA
  ======================================================================== */

// INCLUSION DE LA LIBRERIA PARA GESTIONAR LA ARITMETICA
#include "an_aritmeticas.h"

// FUNCION PARA CALCULAR LA PRECISION (UNIDAD DE REDONDEO) DE LA ARITMETICA
real an_precision_aritmetica()
{
  real A=1.;
  real B=2.;
  int M=1; 
  while(B>1.){
    A=A/2; 
    B=1.+A;
    M=M+1;
  }
  return(A); 
}

// FUNCION PARA CALCULAR EL MENOR NUMERO POSITIVO
int an_menor_numero_positivo()
{
    real A = 1.;
    int M = 0;
    while (A > 0) {
      A /= 2;
      M ++;
    }
    return (M);
}

// FUNCION PARA CALCULAR EL MAYOR NUMERO POSITIVO
int an_mayor_numero_positivo()
{
    real A = 1.;
    real B = 2.;
    int M = 0;
    while (B > A) {
      A *= 2;
      B = 2*A;
      M ++;
    }
    return (M);
}

// FUNCION PARA CALCULAR LA DISTANCIA ENTRE 2 NUMEROS REALES 
real an_distancia(real A,real B)
{
  real abs_A=A>0?A:-A;
  real abs_B=B>0?B:-B;  
  real max=abs_A>abs_B?abs_A:abs_B;
  real abs_A_B=A>B?(A-B):(B-A); 
  
  return( abs_A_B/(max+1.) );   
}

//Newton-Rapshon, cálculo de 0s
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "an_calculo_ceros.h"

// FUNCION QUE IMPLEMENTA EL METODO DE NEWTON-RAPHSON CONOCIENDO LA FUNCION DERIVADA 
int an_newton_raphson (real (*f)(const real), real (*f_1)(const real), real &root, const int Nmax, const real TOL)
{
  real f_root=(*f)(root); // evaluacion de la funcion
  for(int i=0;i<Nmax;i++){
    if(an_distancia(f_root,0.)<TOL){return(i);} // test de salida por el valor de la funcion
    real derivada=(*f_1)(root); // calculo de la derivada
    //printf("root=%e derivada=%e\n",(double) root, (double) derivada);
    if(derivada==0.) return(-1);  // test de salida por el valor de la derivada
    real root2=root-f_root/derivada; // calculo nuevo valor raiz
    f_root=(*f)(root2);  // calculo de la función en el nuevo valor
    if(an_distancia(root2,root)<TOL){  // test de salida por proximidad de raices 
      root=root2;
      return(i); 
    }
    root=root2;  // actualizacion raiz
  }
  return(-2); // salida si se ha superado el numero de iteraciones maximo 
}


// FUNCION QUE IMPLEMENTA EL METODO DE NEWTON-RAPHSON SIN CONOCER LA FUNCION DERIVADA 
int an_newton_raphson (real (*f)(const real), real &root, const int Nmax, const real TOL)
{

  real h=(double) sqrtl((long double) an_precision_aritmetica());
  real f_root=(*f)(root);
  for(int i=0;i<Nmax;i++){
    if(an_distancia(f_root,0.)<TOL){return(i);}
    real derivada=((*f)(root*(1+h)+h)-f_root)/(root*h+h); 
    //printf("root=%e derivada=%e\n",(double) root, (double) derivada); 
    if(derivada==0.) return(-1); 
    real root2=root-f_root/derivada;
    f_root=(*f)(root2);
    if(an_distancia(root2,root)<TOL){
      root=root2;
      return(i); 
    }
    root=root2; 
  }
  return(-2); 
}

// FUNCION QUE IMPLEMENTA EL METODO DE LA SECANTE 
int an_secante (real (*f)(const real), real &root_0, real &root_1,const int Nmax, const real TOL)
{
  real f_root_0=(*f)(root_0);
  real f_root_1=(*f)(root_1);
  for(int i=0;i<Nmax;i++){
    if(an_distancia(f_root_1,0.)<TOL){return(i);}
    real h=root_1-root_0;
    if(h==0.) return(-1); 
    real derivada=(f_root_1-f_root_0)/h; 
    //printf("root_1=%e derivada=%e\n",(double) root_1, (double) derivada); 
    if(derivada==0.) return(-2); 
    real root_2=root_1-f_root_1/derivada;
    f_root_0=f_root_1;
    f_root_1=(*f)(root_2);
    if(an_distancia(root_1,root_2)<TOL){
      root_0=root_1;
      root_1=root_2;
      return(i); 
    }
    root_0=root_1;
    root_1=root_2;
  }
  return(-3); 
}     

//Cholesky
/* Funciones para la resolución de un sistema matricial por el método de Cholesky */

#include "an_cholesky.h"
#include "an_lapack.h"
#include <stdlib.h>
#include <stdio.h>

/* Función que calcula las matrices de descomposición de Cholesky. Se implementa
   en una sola matriz pues se trata de una matriz triangular inferior y su inversa */
Array2D< real > an_cholesky_factorization(const Array2D< real > &A)
{
   int i,j,k;
   if(A.dim1()!=A.dim2() ) return( Array2D< real >());
   int N=A.dim1(); 
   
   Array2D< real > B(N,N); // definmos la matriz de CHOLESKY 
   
   // APLICAMOS EL ALGORITMO DE CHOLESKY 
   for (i=0;i<N;i++){
      real Sum = 0.;   
      for (k=0;k<=(i-1);k++){  /* Sumatorio de B[i][i] */
         Sum = Sum + (B[i][k])*(B[i][k]);
      }
      if (A[i][i]< Sum)
      {
         printf ("La matriz no esta definida positiva\n\n");
         return( Array2D< real >());
      }
      B[i][i]=sqrtl((long double) A[i][i]-Sum);
      
      for  (j=i+1;j<N;j++){ /* Calculamos Elementos de la parte no diagonal de B */
	     Sum = 0;
         if (B[i][i]==0){
            printf ("Ha ocurrido un error en la ejecucion de la factorizacion\n\n"); 
            return( Array2D< real >());
         }
         for (k=0;k<=(i-1);k++){
            Sum = Sum + (B[j][k]*(B[i][k]));
         }
         B[j][i]=(1/(B[i][i]))*((A[j][i])-Sum);
         B[i][j]= B[j][i]; // hacemos la matriz simetrica para guardar en la misma matriz B y B traspuesta
      }
   }
   return( B );
}


// FUNCION PARA RESOLVER UN SISTEMA TRIANGULAR INFERIOR 
Array1D< real > an_descenso (const Array2D< real > &B, const Array1D< real > &b)
{
   int i,j;
   if(B.dim1()!=B.dim2() || B.dim1()!=b.dim() ) return(Array1D< real >());
   int N=B.dim1(); 
   Array1D< real > z(N); 
   
   // INICIAMOS EL DESCENSO
   for (i=0;i<N;i++){
      if (B[i][i]==0) { // comprobamos que la diagonal es distinto de cero 
         return(Array1D< real >());
      }
      z[i]=b[i]; // inicializamos la solucion 
      for (j=0;j<i;j++){ // aplicamos la formula para calcluar la solucion
         z[i]=z[i] - B[i][j]*z[j];
      }
      z[i]=z[i]/B[i][i];
  }
  return(z);
}

// FUNCION PARA RESOLVER UN SISTEMA TRIANGULAR SUPERIOR
Array1D< real > an_remonte (const Array2D< real > &B, const Array1D< real > &z)
{
   int i,j;
   if(B.dim1()!=B.dim2()  || B.dim1()!=z.dim() ) return(Array1D< real >());
   int N=B.dim1(); 
   Array1D< real > DU(N); 
   
   // INICIAMOS EL REMONTE
   for (i=N-1;i>=0;i--){
      if (B[i][i]==0){  // comprobamos que la diagonal es distinto de cero 
         return(Array1D< real >());
      }
      DU[i]=z[i]; // inicializamos la solucion 
      for  (j=i+1;j<N;j++){ // aplicamos la formula para calcluar la solucion 
         DU[i]=DU[i] - B[i][j]*DU[j];
      }
      DU[i]=DU[i]/B[i][i];
  }
  return(DU);
}    


// FUNCION PARA RESOLVER UN SISTEMA POR EL METODO DE CHOLESKY 
Array1D< real > an_cholesky (const Array2D< real > &A, const Array1D< real > &b)
{
    int c;
    int N=A.dim1(); 
    Array2D< real > CH = an_cholesky_factorization (A); /*Calculamos la matriz de Cholesky */
    if (CH.dim1()==0) return (Array1D< real >() );
    Array1D< real > z=an_descenso (CH,b); /* Vector donde devolverá la solución de la triangular inferior */
    if (z.dim()==0) return (Array1D< real >() );
    Array1D< real > u = an_remonte (CH,z);
    if (u.dim()==0) return (Array1D< real >() );
    return(u); 
    
}

// FUNCION PARA CALCULAR EL DETERMINANTE DE UNA MATRIZ POR LA FACTORIZACION DE CHOLESKY
real an_determinante_factorizacion_cholesky(const Array2D< real > &A)
{
  Array2D< real > CH = an_cholesky_factorization (A); /*Calculamos la matriz de Cholesky */
  if (CH.dim1()==0) return (-1.);
  double determinante=1.; 
  for(int i=0;i<CH.dim1();i++){
    determinante*=CH[i][i];         
  }
  return(determinante*determinante); 
}