C++

Forum

 
No matching function for call to method?

SofaSitter (5)
Hi!

I need to call one function on my C++ program. I made one root calculator for functions, but, this doesn't work,and I can't find my code

// Please wait, later I will upload the full code, I didn't have it here

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
 
// FUNCION QUE CALCULA LA DIFERENCIA ENTRE 2 VECTORES
real mn_error_vectores(Array1D< real > &u, Array1D< real > &v)
{
   int i;

   if(u.dim()!=v.dim()){
     printf("mn_error_vectores() : arrays of different dimensions \n");
   }

   int N=u.dim();
   real Sum=0.;
   for (i=0;i<N;i++)
   {
      Sum = Sum + fabs(u[i]-v[i])/(fabs(u[i])+1.);
   }
   return (Sum/N);
}

/******************************************************************************
  FUNCION QUE CALCULA LA SOLUCION DE UN SISTEMA POR EL METODO DE GAUSS-SEIDEL
  DEVUELVE EL NUMERO DE ITERACIONES REALIZADA.
*******************************************************************************/
int mn_gauss_seidel (
const Array2D< real > &A, // MATRIZ DEL SISTEMA
const Array1D< real > &b, // VECTOR DE TÉRMINOS INDEPENDIENTES DEL SISTEMA
Array1D< real > &u,       // VECTOR SOLUCION (DE ENTRADA ES UNA INICIALIZACIÓN)
const int nMax,           // NÚMERO DE ITERACIONES MAXIMO
const real TOL)           // TOLERANCIA PARA CONTROLAR LA CONVERGENCIA DEL ALGORITMO
{
    // HACER ALUMNO
    // UTILIZAR LA FUNCION mn_error_vectores() PARA CALCULAR EL ERROR ENTRE 2 ITERACIONES

    real error = 0.;
    real aux = 0.;

    // Bucle para las iteraciones
    for(int n = 1; n <= nMax; n++) {

        for(int i = 0; i < u.dim(); i++) {

            aux = b[i];

            for(int j = 0; j < i; j++) aux = aux - A[i][j] * u[j];

            for(int j = i+1; j < u.dim(); j++) aux = aux - A[i][j] * u[j];

            aux = aux / A[i][i];

            error = mn_distancia(u[i],aux);

            u[i] = aux;

            if( error/u.dim() < TOL) return n;

        }

    }

    // Error
    return -1;
}

/******************************************************************************
  FUNCION QUE CALCULA LA SOLUCION DE UN SISTEMA POR EL METODO DE GAUSS-SEIDEL
  DEVUELVE EL NUMERO DE ITERACIONES REALIZADA.
*******************************************************************************/
int mn_gauss_seidel (
const Array2D< real > &A, // MATRIZ DEL SISTEMA
const Array1D< real > &b, // VECTOR DE TÉRMINOS INDEPENDIENTES DEL SISTEMA
Array1D< real > &u,       // VECTOR SOLUCION (DE ENTRADA ES UNA INICIALIZACIÓN)
const int nMax,           // NÚMERO DE ITERACIONES MAXIMO
const real TOL)           // TOLERANCIA PARA CONTROLAR LA CONVERGENCIA DEL ALGORITMO
{
    // HACER ALUMNO
    // UTILIZAR LA FUNCION mn_error_vectores() PARA CALCULAR EL ERROR ENTRE 2 ITERACIONES
    if(A.dim1()!=A.dim2() || A.dim1()!=b.dim()){
        return (-1.);
    }
    int p, q;
    Array1D<real> temp(b);
    Array2D<real> aux (A);
    real R= 0.;
    real C, T, CO, SI, D,res1,res2;
    for(int n=0; n<=nMax; n++){
        p= 1;
        q=0;
        R= mn_abs(aux[p][q]);
        for(int i = 2; i< A.dim1(); i++){
            for(int j =0; j<i; j++){
                if(mn_abs(aux[i][j])> R){
                    R= mn_abs(aux[i][j]);
                    p= j;
                    q= i;
                }
            }
        }
        if(R>TOL){
            for(int i=0; i<u.dim();i++){
                u[i]= aux[i][i];
            }
            if(mn_error_vectores(temp,u)<TOL){
              return n;
            }
        }
        C= (aux[q][q]-aux[p][p])/(2*aux[p][q]);
        if(C<0){
            T=-C-sqrtl(1.+C*C);
        }else{
            T=-C+sqrtl(1. + C*C);
        }
        CO= 1./sqrtl(1.+ T*T);
        SI= CO*T;
        for(int j=0; j<A.dim1(); j++){
            if(j!=p && j!=q){
                D= aux[p][j];
                res1= CO*D-SI*A[q][j];
                res2=SI*D+CO*A[q][j];
                aux[p][j]=res1;
                aux[q][j]=res2;
                aux[j][p]=aux[p][j];
                aux[j][q]=aux[q][j];
            }
        }
        aux[p][p]-= T*aux[p][q];
        aux[q][q] += T*aux[p][q];
        aux[p][q]=0.;
        aux[q][p]=0.;
    }
    return (-1.);

}

/*========================================================================
  FUNCIONES RELACIONADAS CON LA RESOLUCION DE SISTEMAS DE ECUACIONES
  ======================================================================== */

// INCLUSION DE LIBRERIAS NECESARIAS
#include <stdio.h>
#include "mn_lapack.h"

// FUNCION PARA CALCULAR LA INVERSA DE UNA MATRIZ POR EL METODO DE GAUSS
Array2D< real > mn_inversa(
  const Array2D< real > &A  /* MATRIZ */) 

{
  int N=A.dim1(); 
  if(N!=A.dim2()) return Array2D<real>();
  
  real max,paso,mul;
  int i,j,i_max,k;
  Array2D< real > PASO(N,2*N); 
  Array2D< real > A_1(N,N);
  
  for(i=0;i<N;i++){
    for(j=0;j<N;j++){
      PASO[i][j]=A[i][j];
      PASO[i][j+N]=0.;
    }
  }
  for(i=0;i<N;i++)
      PASO[i][i+N]=1.;

  for(i=0;i<N;i++){
    max=mn_abs(PASO[i][i]);
    i_max=i;
    for(j=i;j<N;j++){
       if(mn_abs(PASO[j][i])>max){
         i_max=j; max=mn_abs(PASO[j][i]);
       }
    }

    if(max==0.){
      printf("Matriz No Invertible\n");
      return Array2D<real>();
    }
    if(i_max>i){
      for(k=0;k<2*N;k++){
        paso=PASO[i][k];
        PASO[i][k]=PASO[i_max][k];
        PASO[i_max][k]=paso;
      }
    }

    for(j=i+1;j<N;j++){
      mul=-PASO[j][i]/PASO[i][i];
      for(k=i;k<2*N;k++) PASO[j][k]+=mul*PASO[i][k];
    }
  }
  if(mn_abs(PASO[N-1][N-1])==0.){
      printf("Matriz No-Invertible\n");
      return Array2D<real>();
    }

  for(i=N-1;i>0;i--){
    for(j=i-1;j>=0;j--){
      mul=-PASO[j][i]/PASO[i][i];
      for(k=i;k<2*N;k++) PASO[j][k]+=mul*PASO[i][k];
    }
  }
  for(i=0;i<N;i++)
    for(j=N;j<2*N;j++)
      PASO[i][j]/=PASO[i][i];

  for(i=0;i<N;i++)
    for(j=0;j<N;j++)
      A_1[i][j]=PASO[i][j+N];
      
  return(A_1);
}


// FUNCION PARA RESOLVER SISTEMAS POR EL METODO DE GAUSS
Array1D< real > mn_gauss(
  const Array2D< real > &A  /* MATRIZ DEL SISTEMA */, 
  const Array1D< real > &b) /* VECTOR DE TERMINOS INDEPENDINENTES */
{
  
  real max,paso,mul;
  int i,j,i_max,k;
  
  //WE CHECK DIMENSIONS 
  if( A.dim1()!=A.dim2() || A.dim1()!=b.dim() ) return(Array1D< real >()); 
  
  int N=A.dim1();
  Array2D< real > PASO(N,N+1);
  Array1D< real > u=b.copy(); 

  // RELLENAMOS LA MATRIZ DE PASO
  for(i=0;i<N;i++){
    for(j=0;j<N;j++){
      PASO[i][j]=A[i][j];
    }
    PASO[i][N]=u[i];
  }

  // INICIAMOS EL PROCESO DE CONVERTIR EN CERO DE LA DIAGONAL HACIA ABAJO 
  for(i=0;i<N;i++){
    max=mn_abs(PASO[i][i]);
    i_max=i;
    for(j=i;j<N;j++){
       if(mn_abs(PASO[j][i])>max){
         i_max=j; max=mn_abs(PASO[j][i]);
       }
    }
    if(max<10e-120){
      printf("Sistema no tiene Solucion 0\n"); 
      return(Array1D< real >());
    }
    if(i_max>i){
      for(k=0;k<=N;k++){
        paso=PASO[i][k];
        PASO[i][k]=PASO[i_max][k];
        PASO[i_max][k]=paso;
      }
    }
    for(j=i+1;j<N;j++){
      mul=-PASO[j][i]/PASO[i][i];
      for(k=i;k<=N;k++) PASO[j][k]+=mul*PASO[i][k];
    }
  }
  
  // INICIAMOS EL REMONTE PARA RESOLVER EL SISTEMA
  if(mn_abs(PASO[N-1][N-1])<10e-120){
      printf("Sistema no tiene Solucion 1\n");
      return(Array1D< real >());
    }

  for(i=N-1;i>0;i--){
    for(j=i-1;j>=0;j--){
      mul=-PASO[j][i]/PASO[i][i];
      for(k=i;k<=N;k++) PASO[j][k]+=mul*PASO[i][k];
    }
  }
  for(i=0;i<N;i++)
      u[i]=PASO[i][N]/PASO[i][i];

  // printf("METODO DE GAUSS TERMINA BIEN\n"); 
  return(u);
}
Last edited on
SofaSitter (5)
Update 2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
// FUNCION PARA CALCULAR EL ERROR DEL SISTEMA
real mn_error_sistema(const Array2D< real > &A, const Array1D< real > &u, const Array1D< real > &b)
{
   int i;
   if(b.dim()==0 || b.dim()!=u.dim() || b.dim()!=A.dim1() ||  b.dim()!=A.dim2()) return(0.); 
   Array1D< real > e=A*u-b;
   
   real Sum=0.;
   for (i=0;i<b.dim();i++){
      Sum = Sum + mn_abs(e[i])/(mn_abs(b[i])+ 1.);
   }
   return (Sum/b.dim());
}


/* FUNCION PARA LEER UN VECTOR DE DISCO. RETORNA LA DIMENSION DEL VECTOR */
int mn_leer_vector(
  char *nombrefichero, 
   Array1D< real > &vector)
{ 
  int dimension; 
  float paso; 
  FILE *f; 
  
  // ABRIMOS EL FICHERO
  if(f=fopen( nombrefichero, "r"),!f){
    printf("Problema con la apertura del fichero\n");
    return -1; 
  } 
  
  // LEEMOS LA DIMENSION 
  fscanf(f,"%d\n",&dimension); 
  if(dimension<1) return(-2); 
  
  // COGEMOS MEMORIA 
   Array1D< real > v(dimension);
  
  // LEEMOS EL VECTOR 
  for(int i=0;i<dimension;i++){ 
    fscanf(f,"%f\n",&paso); 
    v[i]=paso; 
  }
  fclose(f); 
  vector=v.copy(); 
  return dimension; 
} 

/* FUNCION PARA ESCRIBIR UN VECTOR DE DISCO DE DIMENSION dimension Y LO ALMACENA EN vector */
int mn_escribir_vector(
  char *nombrefichero, 
   Array1D< real > &vector) 
{ 
  int i; 
  FILE *f; 
  int dimension=vector.dim(); 
  if(f=fopen( nombrefichero, "w"),!f){
    printf("Problema con la escritura del fichero\n");
    return 1; 
  } 
  fprintf(f,"%d\n",dimension); 
  for(i=0;i<dimension;i++) fprintf(f,"%f\n",(float) vector[i]); 
  fclose(f); 
  return 0; 
} 
 
/* FUNCION PARA LEER UNA MATRIZ DE DISCO DE DIMENSION 
dimension Y LO ALMACENA EN LA MATRIZ matriz  */
int mn_leer_matriz( 
  char *nombrefichero, 
  Array2D< real > &matriz)
{ 
  int dimension1,dimension2; 
  float paso; 
  FILE *f; 
  if(f=fopen( nombrefichero, "r"),!f){
    printf("Problema con la apertura del fichero\n");
    return 1; 
  } 
  fscanf(f,"%d %d\n",&dimension1, &dimension2); 
  if(dimension1<1 || dimension2<1) return(-1); 
  
  // RESERVAMOS MEMORIA PARA LA MATRIZ
  Array2D< real > m(dimension1,dimension2); 
  
  for(int i=0;i<dimension1;i++){  
    for(int j=0;j<dimension2;j++){ 
            
       fscanf(f,"%f ",&paso); 
       m[i][j]=paso; 
       //printf("paso=%e\n",(double) m[i][j]); 
    }
    fscanf(f,"\n");
  }   
  fclose(f); 
  matriz=m.copy(); 
  return dimension1; 
} 
 
/* FUNCION PARA ESCRIBIR UNA MATRIZ EN DISCO
dimension */
int mn_escribir_matriz( 
  char *nombrefichero,
  Array2D< real > &matriz) 
{ 
  int i,j; 
  FILE *f; 
  if(f=fopen( nombrefichero, "w"),!f){
    printf("Problema con la escritura del fichero\n");
    return 1; 
  } 
  fprintf(f,"%d %d\n",matriz.dim1(),matriz.dim2()); 
  for(i=0;i<matriz.dim1();i++){  
    for(j=0;j<matriz.dim2();j++){ 
       fprintf(f,"%f ",(float) matriz[i][j]); 
    }
    fprintf(f,"\n");
  }     
  fclose(f); 
  return 0; 
} 


/* FUNCIÓN PARA CALCULAR EL CONDICIONAMIENTO DE UNA MATRIZ SIMETRICA.
   UTILIZA EL METODO DE JACOBI PARA CALCULAR LOS AUTOVALORES.
   CALCULA EL MÁXIMO Y MÍNIMO EN VALOR ABSOLUTO DE LOS AUTOVALORES. 
   LA FUNCIÓN DEVUELVE EL COCIENTE ENTRE ELLOS.
*/
real mn_condicionamiento(Array2D< real >&A){
  int NMaxIter=100000; //NUMERO MÁXIMO DE ITERACIONES PARA EL MÉTODO DE JACOBI
  real TOL=1e-6; //TOLERANCIA PARA EL MÉTODO DE JACOBI

  
  // SE APLICA EL METODO DE JACOBI
  Array2D< real > B(A.dim1(),A.dim2()); //matriz de autovectores
  int Niter;
  Array1D< real > u=jacobi(A,B,NMaxIter,TOL,Niter); //CALCULA LOS AUTOVALORES
  real max = u[0];
  real min = u[0];
  /* A IMPLEMENTAR POR EL ALUMNO */
   for (int i = 0; i < A.dim1();i++){//iniciamos B con los autovalores
      B[i][i] = u[i];//necesario?
   }
   for (int k = 1; k < A.dim1(); k++){ //Calculo maximo de u
       if (max < fabs(u[k])) max = fabs(u[k]);
   }
   for (int k = 1; k < A.dim1(); k++){//Calculo minimo de u
       if (min > fabs(u[k])) min = fabs(u[k]);
   }
   
   return max/min;
}

real mn_condicionamiento(const Array2D< real > &A,const int NMaxIter, const real TOL)
{
  // HACER ALUMNO
  if(A.dim1()!=A.dim2()) return(-1.); //comprobamos que la matriz es cuadrada

  // EJECUTAMOS LA FUNCION JACOBI PARA CALCULAR LOS AUTOVALORES Y AUTOVECTORES
  int Niter,N=A.dim1();
  Array2D< real >  Autovectores(N,N);
  Array1D< real > Autovalores=jacobi (A,Autovectores, NMaxIter, TOL,Niter);
  if(Niter==-1) return(-1.);

  // CALCULAMOS EL AUTOVALOR MAXIMO Y MINIMO EN VALOR ABSOLUTO
  real autovalor_minimo=mn_abs(Autovalores[0]);
  real autovalor_maximo=autovalor_minimo;
  for(int k=1;k<N;k++){
    real paso=mn_abs(Autovalores[k]);
    if(paso<autovalor_minimo) autovalor_minimo=paso;
    else if(paso>autovalor_maximo) autovalor_maximo=paso;
  }
  return(autovalor_maximo/autovalor_minimo);
}
SofaSitter (5)
Update 3:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
/* PROCEDIMIENTO PARA CALCULAR UNA ITERACION DEL METODO DE JACOBI PARA HACER CERO LA POSICION A[i][j]. 
   DONDE i Y j VIENEN DADOS COMO PARAMETROS DE LA FUNCION. 
   SE CALCULA LA ROTACION R TAL Y COMO SE EXPLICÓ EN CLASE Y SE ACTUALIZA A HACIENDO
     
         A = R^t*A*R
         
   NOTA : UTILIZAR LOS METODOS PARA MULTIPLICAR MATRICES DE LA LIBRERIA TNT.
*/
void jacobi_iteracion (Array2D< real >&A,const int i,const int j)
{
  int N=A.dim1(); // DIMENSIÓN MATRIZ
  Array2D< real > R(N,N,0.);  // MATRIZ DE ROTACIÓN
  
  /* A IMPLEMENTAR POR EL ALUMNO */
   
   real alpha;
   alpha = atan(2.*A[i][j] / (A[j][j] - A[i][i]));
   alpha = alpha /2.;
   
   R[i][i] = cos(alpha);
   R[j][j] = cos(alpha);
   R[i][j] = sin(alpha);
   R[j][i] = -sin(alpha);
   for (int m = 0; m < N-1; m++){
       if (R[m][m] == 0.) R[m][m] = 1.;
   }
   A = R.transpose()*A;
   A = A*R;

}

// FUNCIONES METODO DE JACOBI
#include "an_jacobi.h"

//*****************************************************************************
// FUNCION QUE CALCULA LOS AUTOVALORES DE UNA MATRIZ (LOS DEVUELVE EN UN ARRAY)
//*****************************************************************************
Array1D< real > jacobi (const Array2D< real >&A, // matriz original
Array2D< real >&Autovectores,  // matriz de salida con los autovectores ordenados por columna
const int NMaxIter,  // número máximo de iteraciones 
const real TOL, // tolerancia para detener el algoritmo
int &Niter) // variable de salida con el numero  de iteraciones 
{
         
  /* Bloque(1):Inicialización de variables*/
  if(A.dim1()!=A.dim2() || A.dim1()!=Autovectores.dim1() || A.dim2()!=Autovectores.dim2() ){
    printf("jacobi() : matrix dimensions are different\n"); 
    return(Array1D< real >()); 
  }
    
  int dim=A.dim1(); 
  for(int i=0;i<dim;i++){
    for(int j=i+1;j<dim;j++){
      if(A[i][j]!=A[j][i]){
        printf("jacobi() : matrix is not symmetric\n"); 
        return(Array1D< real >());                      
      }
    }
  }
    
  // hacemos una copia de la matriz
  Array2D< real > A2=A.copy(); 
    
  // inicializamos la matriz de autovectores a la identidad
  Autovectores=0.;
  for(int i=0;i<dim;i++) Autovectores[i][i]=1.; 
  
  // hacemos las iteraciones del metodo de Jacobi 
  int n,i,j,p,q;
  real R,C,T,CO,SI,D;
  /* Fin Bloque(1)*/
  /* Bloque(2):Algoritmo de Jacobi y cálculo de autovectores*/
  for (Niter=1;Niter<=NMaxIter;Niter++){
    p=1;
    q=0;
    R = fabs(A2[p][q]);
    /* Bloque(2.1) Cálculo del elemento mayor no perteneciente a la diagonal*/
    // Recorre la matriz por filas hasta llegar al elemento anterior al de la diagonal
    // es decir al (i,i-1)
    // Sirve para indicar cual es elemento no diagonal mayor y lo mete en R
    for (i=2;i<dim;i++){
      for (j=0;j<=i-1;j++){
        if (fabs(A2[i][j])>R){
          R=fabs(A2[i][j]);
          p=j;
          q=i;
        }
      }
    } /* Fin Bloque(2.1)*/
    /* Bloque(2.2): Solución: Si el elemento más grande es menor que la tolerancia
                          dada se considera que el algortimo ha finalizado*/
    if (R<TOL)
    {
      Array1D< real > a(dim);
      for(int l=0;l<dim;l++) a[l]=A2[l][l];
      // Devuelve la diagonal de autovalores
      return (a);
    } /* Fin Bloque(2.2) */
    /* Bloque(2.3): Cálculo del seno y coseno de la matriz de rotación*/
    C=(A2[q][q]-A2[p][p])/(2*A2[p][q]);
    if (C<0){ T=-C-sqrtl(1.+C*C);}
    else{ T=-C+sqrtl(1.+C*C); }
    CO=1./sqrtl(1.+T*T);
    SI=CO*T; /* Fin Bloque 2.3) */
    /* Bloque(2.4): Modificación de la matriz A*/
    for (j=0;j<dim;j++){
      if(j!=p && j!=q){
        D=A2[p][j];
        A2[j][p]=CO*D-SI*A2[q][j];
        A2[p][j]=A2[j][p];
        A2[j][q]=SI*D+CO*A2[q][j];
        A2[q][j]=A2[j][q];
      }
    }
    A2[p][p]=A2[p][p]-T*A2[p][q];
    A2[q][q]=A2[q][q]+T*A2[p][q];
    A2[p][q]=0;
    A2[q][p]=0; /* Fin Bloque(2.4)*/
    /* Bloque(2.5): Modificación de la matriz de autovectores*/
    real b_ip,b_iq;
    for(i=0;i<dim;i++){
     // b_ip=Autovectores[i][p];
     // b_iq=Autovectores[i][q];
      Autovectores[i][p]=CO*b_ip - SI*Autovectores[i][p];
      Autovectores[i][q]=SI*b_ip + CO*Autovectores[i][q];
    }/* Fin Bloque(2.5)*/
  } /* Fin Bloque(2)*/
  printf ("Error, numero de iteraciones excedido\n");
    
  return(Array1D< real >());
}


//*************************************************************************
// FUNCION QUE CALCULA EL ERROR MAXIMO DE LOS AUTOVECTORES AL HACER Au-lu=0 
//*************************************************************************
real an_error_autovectores(
const Array2D< real > &A, 
const Array2D< real > &Autovectores, const Array1D< real > &Autovalores)
{
   int i,j;
   
   Array2D< real > B(Autovectores); 
   if(A.dim1()!=A.dim2() || B.dim1()!=B.dim2() || A.dim1()!=B.dim1()) return(-1.);
   
   real Max=0.;
   int N=A.dim1();
   
   Array1D< real > Autovector_i(N); 
   
   for (i=0;i<N;i++)
   {
       for (j=0;j<N;j++)
       {
           Autovector_i[j] = B[j][i];
       }
       Array1D< real > lu=Autovector_i*Autovalores[i]; // Multiplicamos cada autovector por su autovalor
       Array1D< real > Au=A*Autovector_i;  // Multiplicamos la matriz inicial por el autovector
       real error = an_error_vectores(Au,lu); // Calculamos el error de AXi - YXi  = 0; (Y=lambda);
       if (Max<error) Max = error; // Nos quedamos con el error mayor de todos los autovectores
   }
   return ((double)Max);
}

/*4========================================================================
  FUNCIONES RELACIONADAS CON LA RESOLUCION DE SISTEMAS DE ECUACIONES
  ======================================================================== */

// INCLUSION DE LIBRERIAS NECESARIAS
#include <stdio.h>
#include "mn_lapack.h"

//*****************************************************************************
// FUNCION QUE CALCULA EL AUTOVALOR MAXIMO DE UNA MATRIZ POR EL METODO DE LA POTENCIA
// DEVUELVE EL AUTOVALOR MAXIMO. SI TERMINA MAL DEVUELVE 0
//*****************************************************************************
real mn_metodo_potencia(
const Array2D< real > &A, // matriz de entrada
Array1D< real > &u, // aproximacion inicial autovector, en salida es el autovector final
const int NMaxIter, // numero maximo de iteraciones
const real TOL) // tolerencia para la convergencia
{
  // HACER ALUMNO
  for(int i=1;i<=NMaxIter;i++){
    Array1D< real > u1=A*u; // calculamos A*u
    real producto_escalar=0; // calculamos producto escalar de u y A*u
    for(int k=0;k<u.dim();k++) producto_escalar+=u[k]*u1[k];
    real norma=0; //calulamos la norma de A*u
    for(int k=0;k<u.dim();k++) norma+=u1[k]*u1[k];
    if(norma==0){ return(0.); }
    norma=sqrtl((long double) norma);
    if(producto_escalar<0) norma=-norma; // cambiamos el signo del autovalor si producto_escalar<0
    for(int k=0;k<u1.dim();k++) u1[k]/=norma; // normalizamos vector
    if(mn_error_vectores(u,u1)<TOL){ // comprobamos test de convergencia
      u=u1;
      return(norma);
    }
    u=u1; // actualizamos el autovector
  }

  return(0.);

}
SofaSitter (5)
Update 4:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 

/* FUNCIÓN PARA CALCULAR EL AUTOVALOR Y AUTOVECTOR MAXIMO POR EL METODO DE LA POTENCIA. 
   EL AUTOVALOR Y AUTOVECTOR SE PASAN COMO PARÁMETROS. 
   LA FUNCION RETORNA EL NUMERO DE ITERACIONES REALIZADO SI TERMINA BIEN Y UN NUMERO NEGATIVO SI TERMINA MAL. 
   FUNCIONES / METODOS QUE HAY QUE UTILIZAR EN LA PRACTICA :
   1-A*u  PARA MULTIPLICAR MATRIZ POR VECTOR
   2-u*r  PARA MULTIPLICAR EL VECTOR u POR EL NUMERO r
   3-u.norma() PARA CALCULAR LA NORMA DE UN VECTOR
   4-mn_producto_escalar(u2,u) PARA CALCULAR EL PRODUCTO ESCALAR DE 2 VECTORES 
   NOTA : NO SE PUEDE HACER NINGUN BUCLE QUE RECORRA LOS ELEMENTOS DE UN VECTOR 
   ES DECIR EL UNICO BUCLE QUE PUEDE APARECER ES EL DE LAS ITERACIONES DEL METODO     
*/
int mn_metodo_potencia(
Array2D< real > &A, // MATRIZ PARA APLICAR EL MÉTODO DE LA POTENCIA 
Array1D< real > &u, // AUTOVECTOR MAXIMO CALCULADO (ESTÁ INICIALIZADO AL ENTRAR) 
real &a_max,  // AUTOVALOR MAXIMO CALCULADO
int Nmax, // NUMERO ITERACIONES MAXIMO
real TOL) // TOLERANCIA PARA LA CONVERGENCIA DEL ALGORITMO
{
  Array1D< real > u2(u.dim()); // VECTOR PARA GUARDAR LA ACTUALIZACIÓN DEL VECTOR u
  
  int cuenta = 0; // Variable contadora a devolver por el programa en caso de que termine bien
  //A IMPLEMENTAR POR EL ALUMNO
if ( A.dim2() == u.dim()){  // Comprobamos que se puede multiplicar la matriz A y el vector u
 for (int n = 0; n <= Nmax; n++){ // Hacemos el metodo unicamente con el número de iteraciones 
  // Paso por paso desarrollamos la función          
     u2[n]=(A[n][n]*u[n]); 
     cuenta = cuenta+1; 
  } 
} 
     u2=u*a_max;
     u2=u.norma();
     mn_producto_escalar(u2,u);
  // Caso satisfactorio: Numero de iteracciones realizadas
  if ( cuenta==Nmax){
  return cuenta;
  }else{
  //Si termina mal      
  return -1;         
 }               
}

// FUNCION PARA CALCULAR LA DIFERENCIA ENTRE 2 VECTORES 
real mn_error_vectores(Array1D< real > &u, Array1D< real > &v)
{
   int i;
   if(u.dim()!=v.dim() || u.dim()==0 ){
     printf("funcion mn_error_vectores(): los vectores tienen dimension distinta\n"); 
     return(-1.); 
   }
   real Sum=0.;
   for (i=0;i<u.dim();i++){
      Sum+= mn_distancia(u[i],v[i]);
   }
   return (Sum/u.dim());
}


// FUNCION QUE CALCULA EL PRODUCTO ESCALAR ENTRE 2 VECTORES 
real mn_producto_escalar(Array1D< real > &u, Array1D< real > &v)
{
   int i;
   if(u.dim()!=v.dim() || u.dim()==0 ){
     printf("funcion mn_producto_escalar(): los vectores tienen dimension distinta\n"); 
     return(-1.); 
   }
   real Sum=0.;
   for (i=0;i<u.dim();i++){
      Sum+=u[i]*v[i];
   }
   return (Sum);
}
SofaSitter (5)
Update 5:

I will upload it later, please wait for this upload
Topic archived. No new replies allowed.