fastsum.h

Go to the documentation of this file.

/*
 * Copyright (c) 2002, 2017 Jens Keiner, Stefan Kunis, Daniel Potts
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef fastsum_h_inc
#define fastsum_h_inc

#include "config.h"

#ifdef HAVE_COMPLEX_H
#include <complex.h>
#endif

#include "nfft3.h"
#include "infft.h"

#undef X
#define X(name) NFFT(name)

#if !(defined(NF_LIN) || defined(NF_QUADR) || defined(NF_KUB))
  #define NF_KUB
#endif

#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */

typedef C (*kernel)(R , int , const R *);

#define EXACT_NEARFIELD  (1U<< 0)

#define NEARFIELD_BOXES (1U<< 1)

#define STORE_PERMUTATION_X_ALPHA (1U<< 2)

typedef struct fastsum_plan_
{
  int d;                                
  int N_total;                          
  int M_total;                          
  C *alpha;                       
  C *f;                           
  R *x;                            
  R *y;                            
  kernel k;  
  R *kernel_param;                 
  unsigned flags;                       
  C *pre_K;                       
  int n;                                
  C *b;                      
  C *f_hat;  
  int p;                                
  R eps_I;                           /* fixed to p/n so far  */
  R eps_B;                           /* fixed to 1/16 so far */

  X(plan) mv1;                        
  X(plan) mv2;                        
  int Ad;                               
  C *Add;                 
  /* things for computing *b - are they used only once?? */
  FFTW(plan) fft_plan;

  int box_count;
  int box_count_per_dim;
  int *box_offset;
  R *box_x;
  C *box_alpha;
  
  int *permutation_x_alpha;    
  R MEASURE_TIME_t[8]; 
} fastsum_plan;

void fastsum_init_guru(fastsum_plan *ths, int d, int N_total, int M_total, kernel k, R *param, unsigned flags, int nn, int m, int p, R eps_I, R eps_B);

void fastsum_init_guru_kernel(fastsum_plan *ths, int d, kernel k, R *param,
    unsigned flags, int nn, int p, R eps_I, R eps_B);

void fastsum_init_guru_source_nodes(fastsum_plan *ths, int N_total, int nn_oversampled, int m);

void fastsum_init_guru_target_nodes(fastsum_plan *ths, int M_total, int nn_oversampled, int m);

void fastsum_finalize(fastsum_plan *ths);

void fastsum_finalize_source_nodes(fastsum_plan *ths);

void fastsum_finalize_target_nodes(fastsum_plan *ths);

void fastsum_finalize_kernel(fastsum_plan *ths);

void fastsum_exact(fastsum_plan *ths);

void fastsum_precompute_source_nodes(fastsum_plan *ths);

void fastsum_precompute_target_nodes(fastsum_plan *ths);

void fastsum_precompute(fastsum_plan *ths);

void fastsum_trafo(fastsum_plan *ths);
/* \} */

C regkern(kernel k, R xx, int p, const R *param, R a, R b);

C kubintkern(const R x, const C *Add,
  const int Ad, const R a);

#ifdef __cplusplus
}  /* extern "C" */
#endif /* __cplusplus */

#endif
/* fastsum.h */