fepc_real_t
folgen_vektor_norm(folgen_vektor_p f, folgen_vektor_p g) {
vec_p max, temp, temp1, temp2, r, vec_1;
int k, size, test_f, test_g;
int i, j, d, dim;
folge_p temp_folge;
fepc_real_t wert, norm;
ASSERT( f->grad->dim == g->grad->dim );
dim = f->grad->dim;
vec_1 = vec_one(dim);
temp = vec_max( f->grad, g->grad );
max = vec_add( temp, vec_1 );
vec_del(temp);
size = vec_size( max );
norm = 0.0;
for(k=0;k<size;k++) {
r = entry_one2d( k, max );
/*Test ob Folge von f den Grad r besitzt*/
test_f = 0;
for(d=0;d<dim;d++) {
if (( r->array[d] ) > ( f->grad->array[d] )) {
test_f = test_f + 1;
}
}
/*Test ob Folge von g den Grad r besitzt*/
test_g = 0;
for(d=0;d<dim;d++) {
if (( r->array[d] ) > ( g->grad->array[d] )) {
test_g = test_g + 1;
}
}
/*Berechnung der Norm*/
if( (test_f==0) && (test_g==0) ) {
temp = vec_add(f->grad, vec_1);
i = entry_d2one( r, temp);
vec_del(temp);
temp = vec_add(g->grad, vec_1);
j = entry_d2one( r, temp);
vec_del(temp);
wert = folge_norm(f->vektor[i],g->vektor[j]);
norm = norm + wert;
}
if( (test_f==0) && (test_g>0) ) {
temp = vec_add(f->grad, vec_1);
i = entry_d2one( r, temp);
vec_del(temp);
temp1 = vec_new(dim);
temp2 = vec_new(dim);
temp_folge = folge_new( temp1, temp2 );
wert = folge_norm(f->vektor[i],temp_folge);
norm = norm + wert;
folge_del(temp_folge);
}
if( (test_f>0) && (test_g==0) ) {
temp = vec_add(g->grad, vec_1);
j = entry_d2one( r, temp);
vec_del(temp);
temp1 = vec_new(dim);
temp2 = vec_new(dim);
temp_folge = folge_new( temp1, temp2 );
wert = folge_norm(g->vektor[j],temp_folge);
norm = norm + wert;
folge_del(temp_folge);
}
vec_del( r );
}
vec_del(vec_1);
vec_del(max);
return norm;
}
/*******************************************************
*
* globale Funktionen
*
*******************************************************/
fepc_real_t*
fft_faltung(fepc_real_t* a, vec_p n_a, fepc_real_t* b, vec_p n_b) {
int size_a, size_b, size_c, dim;
int k, i, wert, test;
int *n;
vec_p temp, n_c;
fepc_real_t *c;
fftw_complex *in, *out_a, *out_b;
double *out, *in_a, *in_b;
fftw_plan p;
/*Auf Testen von Konsistenz wird verzichtet, da Input bereits auf Konsistenz getestet*/
/*Faltung ueber Fouriertrafo (Theorie ist in Dokumentation zu finden)*/
dim = n_a->dim;
n_c = vec_new(dim);
for(k=0;k<dim;k++) {
n_c->array[k] = n_a->array[k]+n_b->array[k]-1;
}
n = n_c->array;
size_a = vec_size( n_a );
size_b = vec_size( n_b );
size_c = vec_size( n_c );
/*Initialisieren des Ergebnis Array*/
c = (fepc_real_t*) malloc(sizeof(fepc_real_t) * size_c);
/*Berechnen der Fouriertrafo von in_a*/
in_a = (double*) fftw_malloc(sizeof(double) * size_c);
out_a = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * size_c);
for (k=0;k<size_c;k++) {
temp = entry_one2d(k,n_c);
test = 0;
for(i=0;i<dim;i++) {
if ((temp->array[i] <0)||(temp->array[i]>=n_a->array[i])) {
test = test + 1;
}
}
if (test == 0) {
wert = entry_d2one(temp,n_a);
in_a[k] = a[wert];
}
else {
in_a[k] = 0;
}
vec_del(temp);
}
p = fftw_plan_dft_r2c(dim,n,in_a,out_a,FFTW_ESTIMATE);
fftw_execute(p);
fftw_destroy_plan(p);
/*Berechnen der Fouriertrafo von in_b*/
in_b = (double*) fftw_malloc(sizeof(double) * size_c);
out_b = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * size_c);
for (k=0;k<size_c;k++) {
temp = entry_one2d(k,n_c);
test = 0;
for(i=0;i<dim;i++) {
if ((temp->array[i] <0)||(temp->array[i]>=n_b->array[i])) {
test = test + 1;
}
}
if (test == 0) {
wert = entry_d2one(temp,n_b);
in_b[k] = b[wert];
}
else {
in_b[k] = 0;
}
vec_del(temp);
}
p = fftw_plan_dft_r2c(dim,n,in_b,out_b,FFTW_ESTIMATE);
fftw_execute(p);
fftw_destroy_plan(p);
in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * size_c);
out = (double*) fftw_malloc(sizeof(double) * size_c);
for (k=0;k<size_c;k++) {
in[k][0] = out_a[k][0]*out_b[k][0] - out_a[k][1]*out_b[k][1];
in[k][1] = out_a[k][1]*out_b[k][0] + out_a[k][0]*out_b[k][1];
}
/*Berechnung der Inversen Fouriertrafo von in*/
p = fftw_plan_dft_c2r(dim,n,in,out,FFTW_ESTIMATE);
fftw_execute(p);
fftw_destroy_plan(p);
for (k=0;k<size_c;k++) {
c[k] = (fepc_real_t) out[k]/size_c;
}
vec_del(n_c);
fftw_free(in);
free(in_a);
free(in_b);
free(out);
fftw_free(out_a);
fftw_free(out_b);
return c;
}
