inline float interpolated_noise2(float x, float y)
{
int ix, iy, ix1, iy1;
float n1, n2, n3, n4, frx, fry, i1, i2;
ix=(int)(x);
iy=(int)(y);
frx=x-ix;
fry=y-iy;
ix1=(ix+1) & KNOTSMASK;
iy1=(iy+1) & KNOTSMASK;
ix=ix & KNOTSMASK;
iy=iy & KNOTSMASK;
n1=knots2[ix][iy];
n2=knots2[ix1][iy];
n3=knots2[ix][iy1];
n4=knots2[ix1][iy1];
i1=interpola(n1, n2, frx);
i2=interpola(n3, n4, frx);
return(interpola(i1, i2, fry));
}
int32_t main(int32_t argc, char *argv[])
{
if (argc != 5)
{
printf("OPA, ocorreu um erro, verifique se os parâmetros estão sendo passados corretamente!");
return 1;
}
else
{
int32_t memoria = atoi(argv[3]) * MB;
const int32_t K = atoi(argv[4]);
FILE *fp = fopen(argv[1], "rb");
clock_t inicio, fim;
unsigned long arquivoEntradaTAM = getTamArquivo(fp);
inicio = clock();
KFile *arquivos = geraLinhas(fp, memoria, K);
int32_t output_file_index = interpola(arquivos, arquivoEntradaTAM, memoria, K);
fim = clock();
double tempoGasto = (double) (fim - inicio) / CLOCKS_PER_SEC;
int32_t x;
for (x = 0; x < 2 * K; x++)
{
fclose(arquivos[x].fp);
if (x == output_file_index)
{
continue;
}
remove(arquivos[x].nome);
}
rename(arquivos[output_file_index].nome, argv[2]);
printf("Tempo de execucao gasto: %lf\n", tempoGasto);
fclose(fp);
}
return 0;
}
inline float interpolated_noise1(float x)
{
int ix;
float n1, n2, fr;
ix=(int)x;
fr=x-ix;
n1=knots1[ix & KNOTSMASK];
n2=knots1[(ix+1) & KNOTSMASK];
// interpolazione dei tra i due valori
return(interpola(n1, n2, fr));
}
void multigrid(int m, /* Malla en la que estamos */
double ***d, /* Defecto */
double ***v,
int iteraciones_s1,
int iteraciones_s2,
const char * tipo) /* tipo de suavizador */
{
int d_malla; /* dimension de la malla */
int d_malla_inf; /* dimension de la malla inferior */
double **fu;
double **vg;
if(m==0)
{
exacta(d[m],v[m]);
printf("Exacta");
}
else
{
d_malla=pow(2,m+1)+1;
d_malla_inf=pow(2,m)+1;
inicializa_cero(v[m],d_malla);
fu=allocate2D(d_malla,d_malla);
vg=allocate2D(d_malla,d_malla);
copia_matriz(d[m],fu,d_malla);
suaviza(v[m],fu,iteraciones_s1,tipo,d_malla);
copia_matriz(v[m],vg,d_malla);
calcula_defecto(d[m],fu,v[m],d_malla);
///muestra_matriz("d",d[m],d_malla,d_malla);
restringe(d[m],d[m-1],d_malla_inf);
multigrid(m-1,d,v,iteraciones_s1,iteraciones_s2,tipo);
interpola(v[m-1],v[m],d_malla_inf,d_malla);
suma_matrices(v[m],vg,d_malla);
suaviza(v[m],fu,iteraciones_s2,tipo,d_malla);
deallocate2D(fu,d_malla);
deallocate2D(vg,d_malla);
}
}
inline float interpolated_noise3(float x, float y, float z)
{
int ix, iy, iz, ix1, iy1, iz1;
float n1, n2, n3, n4, frx, fry, frz, i1, i2, i3, i4;
ix=(int)(x);
iy=(int)(y);
iz=(int)(z);
frx=x-ix;
fry=y-iy;
frz=z-iz;
ix1=(ix+1) & KNOTSMASK;
iy1=(iy+1) & KNOTSMASK;
iz1=(iz+1) & KNOTSMASK;
ix=ix & KNOTSMASK;
iy=iy & KNOTSMASK;
iz=iz & KNOTSMASK;
n1=knots3[ix][iy][iz];
n2=knots3[ix1][iy][iz];
n3=knots3[ix][iy1][iz];
n4=knots3[ix1][iy1][iz];
i1=interpola(n1, n2, frx);
i2=interpola(n3, n4, frx);
i3=interpola(i1, i2, fry);
n1=knots3[ix][iy][iz1];
n2=knots3[ix1][iy][iz1];
n3=knots3[ix][iy1][iz1];
n4=knots3[ix1][iy1][iz1];
i1=interpola(n1, n2, frx);
i2=interpola(n3, n4, frx);
i4=interpola(i1, i2, fry);
return(interpola(i3, i4, frz));
}
int main(int argc,char *argv[])
{
int i,j;
int n_mallas=4;
int iteraciones_s1=1; /* Iteraciones del primer suavizador */
int iteraciones_s2=1; /* Iteraciones del segundo suavizador */
int dimension;
int dim_inf; /* Dimension de la malla inferior */
double norma_defecto=1.0;
double norma_defecto_anterior;
double **u; /* Solución */
double **f;
double ***v;
double ***d;
const char *tipo="gsrb";
const char *uso="\n";
///////////////////////////////////////////
// escaneo de argumentos //
if((argc>1) && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
printf (uso, argv[0]);
exit(1);
}
for(i=1;i<argc;i++)
{
if(!strcmp(argv[i],"-mallas"))
{
n_mallas=atoi(argv[++i]);
}
else
{
fprintf(stderr,"Opción inválida '%s'\n `%s --help` para mas información\n",
argv[i], argv[0]);
exit(1);
}
}
// Fin escaneo de argumentos //
///////////////////////////////////////////
///////////////////////////////////////////
// Generamos los datos necesarios //
// //
// x . x . x //
// . . . . . //
// x . x . x //
// . . . . . //
// x . x . x n_mallas=2, dimension=5 //
dimension = pow(2,n_mallas)+1;
u=allocate2D(dimension,dimension);
f=allocate2D(dimension,dimension);
inicializa_cero(f,dimension);
//muestra_matriz("f",f,dimension,dimension);
inicializa(u,dimension);
//muestra_matriz("u",u,dimension,dimension);
v=(double***)malloc(n_mallas*sizeof(double**)); // v y d son matrices p
d=(double***)malloc(n_mallas*sizeof(double**)); // en cada malla
for(i=0;i<n_mallas;i++)
{
j=pow(2,i+1)+1;
v[i]=allocate2D(j,j);
d[i]=allocate2D(j,j);
inicializa_cero(v[i],j);
inicializa_cero(d[i],j);
//muestra_matriz("v",v[i],j,j);
}
// Fin inicialización //
////////////////////////////////////////////
////////////////////////////////////////////
// Bucle principal //
for(i=0;i<20;i++)
{
dim_inf=(dimension+1)/2;
/* Suavizado */
suaviza(u,f,iteraciones_s1,tipo,dimension);
//muestra_matriz("u",u,dimension,dimension);
/* Cálculo del defecto */
calcula_defecto(d[n_mallas-1],f,u,dimension);
//muestra_matriz("d",d[n_mallas-1],dimension,dimension);
/* Restringimos el defecto */
restringe(d[n_mallas-1],d[n_mallas-2],(dimension+1)/2);
//muestra_matriz("d_",d[n_mallas-2],(dimension+1)/2,(dimension+1)/2);
/* Llamamos a multigrid */
multigrid(n_mallas-2,d,v,iteraciones_s1,iteraciones_s2,tipo);
//muestra_matriz("v_",v[n_mallas-2],(dimension+1)/2,(dimension+1)/2);
/* Interpolamos */
interpola(v[n_mallas-2],v[n_mallas-1],(dimension+1)/2,dimension);
//muestra_matriz("v",v[n_mallas-1],dimension,dimension);
/* Sumamos */
suma_matrices(u,v[n_mallas-1],dimension);
//muestra_matriz("u",u,dimension,dimension);
/* Volvemos a suavizar */
suaviza(u,f,iteraciones_s2,tipo,dimension);
//muestra_matriz("u",u,dimension,dimension);
/* Comienza el test de convergencia */
calcula_defecto(d[n_mallas-1],f,u,dimension);
//muestra_matriz("d",d[n_mallas-1],dimension,dimension);
norma_defecto_anterior=norma_defecto;
norma_defecto=calcula_max(d[n_mallas-1],dimension);
printf("Iter: %d max(defecto)=%e\tratio=%0.10f\n",i,norma_defecto,norma_defecto/norma_defecto_anterior);
}
// Fin bucle principal //
////////////////////////////////////////////
////////////////////////////////////////////
// Liberamos memoria //
deallocate2D(u,dimension);
deallocate2D(f,dimension);
for(i=0;i<n_mallas;i++)
{
j=pow(2,i+1)+1;
deallocate2D(v[i],j);
deallocate2D(d[i],j);
}
free(v);
free(d);
return 0;
}
void multigrid(malla * u, malla *f, matriz *op, double * max)
{
int i,j;
if(u->nivel==1)
{
/* Escalar el operador al nivel */
matriz op_n;
/* Inicializamos el operador */
inicializa_matriz(&op_n,3);
copia_matriz(op,&op_n);
escala_matriz(&op_n,pow((u->dimension-1),2));
/* Construimos el sistema a resolver */
double A[3][3];
A[0][0]=op_n.v[1][1];
A[0][1]=op_n.v[2][1];
A[0][2]=op_n.v[2][2];
A[1][0]=op_n.v[0][1];
A[1][1]=op_n.v[1][1];
A[1][2]=op_n.v[1][2];
A[2][0]=op_n.v[0][0];
A[2][1]=op_n.v[1][0];
A[2][2]=op_n.v[1][1];
double B[3];
B[0] = f->v[2][1]-op_n.v[1][2]*u->v[2][2]
-op_n.v[0][1]*u->v[1][1]
-op_n.v[0][0]*u->v[1][0]
-op_n.v[1][0]*u->v[2][0];
B[1] = f->v[3][1]-op_n.v[0][0]*u->v[2][0]
-op_n.v[1][0]*u->v[3][0]
-op_n.v[2][1]*u->v[4][1];
B[2] = f->v[3][2]-op_n.v[0][1]*u->v[2][2]
-op_n.v[1][2]*u->v[3][3]
-op_n.v[2][2]*u->v[4][3]
-op_n.v[2][1]*u->v[4][2];
/* Hacemos eliminación gausiana */
A[1][1]=A[1][1]-A[0][1]*A[1][0]/A[0][0];
A[1][2]=A[1][2]-A[0][2]*A[1][0]/A[0][0];
B[1]=B[1]-B[0]*A[1][0]/A[0][0];
A[2][1]=A[2][1]-A[0][1]*A[2][0]/A[0][0];
A[2][2]=A[2][2]-A[0][2]*A[2][0]/A[0][0];
B[2]=B[2]-B[0]*A[2][0]/A[0][0];
A[2][2]=A[2][2]-A[1][2]*A[2][1]/A[1][1];
B[2]=B[2]-B[1]*A[2][1]/A[1][1];
/* Resolvemos */
u->v[3][2]=B[2]/A[2][2];
u->v[3][1]=(B[1]-A[1][2]*u->v[3][2])/A[1][1];
u->v[2][1]=(B[0]-A[0][2]*u->v[3][2]-A[0][1]*u->v[3][1])/A[0][0];
}
else
{
/* Escalar el operador al nivel */
matriz op_n;
/* Definicion de las mallas */
malla d; /* Para almacenar el defecto */
malla d_; /* Para almacenar el defecto restringido */
malla v;
malla v_;
/* Inicializacióm mallas*/
inicializa_malla_c(&d,u->nivel);
inicializa_malla_c(&d_,u->nivel-1);
inicializa_malla_c(&v,u->nivel);
inicializa_malla_c(&v_,u->nivel-1);
inicializa_matriz(&op_n,3);
copia_matriz(op,&op_n);
printf("sf=pow(%d,2)",u->dimension-1);
escala_matriz(&op_n,pow((u->dimension-1),2));
/* Suavizado */
muestra_malla(u);
printf("After smooth %f\n ",op_n.v[1][1]);
suaviza_r(u,f,&op_n);
suaviza_g(u,f,&op_n);
suaviza_b(u,f,&op_n);
muestra_malla(u);
/* Defecto */
defecto(u,f,&d,&op_n);
printf("After defect %f\n ",op_n.v[1][1]);
muestra_malla(&d);
/* Restringimos */
restringe(&d,&d_);
/* Rellamada a multigrid */
multigrid(&v_,&d_,op,max);
/* Interpolamos */
interpola(&v_,&v);
/* Sumamos */
suma_mallas(u,&v);
/* Postsuavizamos */
suaviza_r(u,f,&op_n);
suaviza_g(u,f,&op_n);
suaviza_b(u,f,&op_n);
/* En la malla mas alta, comprobamos cómo va la cosa */
if(u->nivel==2)
{
/* Calculamos el defecto */
defecto(u,f,&d,&op_n);
for(i=0;i<u->dimension;i++)
{
for(j=0;j<i;j++)
{
if(fabs(d.v[i][j])>max[0])
{
max[0]=fabs(d.v[i][j]);
}
}
}
}
/* Liberacion de recursos */
libera_matriz(&op_n);
libera_malla(&d);
libera_malla(&d_);
libera_malla(&v);
libera_malla(&v_);
}
}
