32 #include "ope_elementary.h" 36 Matrice _cl_poisson_2d_pas_prevu (
const Matrice & source,
int,
double,
int) {
37 cout <<
"Combinaison lineaire pas prevu..." << endl ;
48 Matrice _cl_poisson_2d_r_cheb (
const Matrice &source,
int l,
double echelle,
int) {
49 int n = source.
get_dim(0) ;assert (n == source.get_dim(1)) ;
51 const int nmax = 100 ;
52 static Matrice* tab[nmax] ;
53 static int nb_dejafait = 0 ;
54 static int l_dejafait[nmax] ;
55 static int nr_dejafait[nmax] ;
56 static double vieux_echelle = 0 ;
59 if (vieux_echelle != echelle) {
60 for (
int i=0 ; i<nb_dejafait ; i++) {
66 vieux_echelle = echelle ;
72 for (
int conte=0 ; conte<nb_dejafait ; conte ++)
73 if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
78 if (nb_dejafait >= nmax) {
79 cout <<
"_cl_poisson_r_cheb : trop de matrices" << endl ;
84 l_dejafait[nb_dejafait] = l ;
85 nr_dejafait[nb_dejafait] = n ;
87 Matrice barre(source) ;
89 for (
int i=0 ; i<n-2 ; i++) {
90 for (
int j=0 ; j<n ; j++)
91 barre.set(i, j) = ((1+dirac)*source(i, j)-source(i+2, j))
97 for (
int i=0 ; i<n-4 ; i++)
98 for (
int j=0 ; j<n ; j++)
99 res.set(i, j) = barre(i, j)-barre(i+2, j) ;
100 tab[nb_dejafait] =
new Matrice(res) ;
107 return *tab[indice] ;
115 Matrice _cl_poisson_2d_r_chebp (
const Matrice &source,
int l,
double,
int) {
118 assert (n == source.get_dim(1)) ;
120 const int nmax = 100 ;
121 static Matrice* tab[nmax] ;
122 static int nb_dejafait = 0 ;
123 static int l_dejafait[nmax] ;
124 static int nr_dejafait[nmax] ;
129 for (
int conte=0 ; conte<nb_dejafait ; conte ++)
130 if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
135 if (nb_dejafait >= nmax) {
136 cout <<
"_cl_poisson_2d_r_chebp : trop de matrices" << endl ;
141 l_dejafait[nb_dejafait] = l ;
142 nr_dejafait[nb_dejafait] = n ;
144 Matrice barre(source) ;
147 for (
int i=0 ; i<n-2 ; i++) {
148 for (
int j=0 ; j<n ; j++)
149 barre.set(i, j) = (1+dirac)*source(i, j)-source(i+2, j) ;
150 if (i==0) dirac = 0 ;
153 Matrice tilde(barre) ;
154 for (
int i=0 ; i<n-4 ; i++)
155 for (
int j=0 ; j<n ; j++)
156 tilde.set(i, j) = barre(i, j)-barre(i+2, j) ;
159 for (
int i=0 ; i<n-4 ; i++)
160 for (
int j=0 ; j<n ; j++)
161 res.set(i, j) = tilde(i, j)-tilde(i+1, j) ;
162 tab[nb_dejafait] =
new Matrice(res) ;
169 return *tab[indice] ;
177 Matrice _cl_poisson_2d_r_chebi (
const Matrice &source,
int l,
double,
int) {
179 assert (n == source.get_dim(1)) ;
182 const int nmax = 100 ;
183 static Matrice* tab[nmax] ;
184 static int nb_dejafait = 0 ;
185 static int l_dejafait[nmax] ;
186 static int nr_dejafait[nmax] ;
191 for (
int conte=0 ; conte<nb_dejafait ; conte ++)
192 if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
197 if (nb_dejafait >= nmax) {
198 cout <<
"_cl_poisson_2d_r_chebi : trop de matrices" << endl ;
203 l_dejafait[nb_dejafait] = l ;
204 nr_dejafait[nb_dejafait] = n ;
206 Matrice barre(source) ;
208 for (
int i=0 ; i<n-2 ; i++)
209 for (
int j=0 ; j<n ; j++)
210 barre.set(i, j) = source(i, j)-source(i+2, j) ;
212 Matrice tilde(barre) ;
213 for (
int i=0 ; i<n-4 ; i++)
214 for (
int j=0 ; j<n ; j++)
215 tilde.set(i, j) = barre(i, j)-barre(i+2, j) ;
218 for (
int i=0 ; i<n-4 ; i++)
219 for (
int j=0 ; j<n ; j++)
220 res.set(i, j) = tilde(i, j)-tilde(i+1, j) ;
221 tab[nb_dejafait] =
new Matrice(res) ;
228 return *tab[indice] ;
234 Matrice _cl_poisson_2d_r_chebu_quatre (
const Matrice&,
int) ;
235 Matrice _cl_poisson_2d_r_chebu_trois (
const Matrice&,
int) ;
236 Matrice _cl_poisson_2d_r_chebu_deux (
const Matrice&,
int) ;
239 Matrice _cl_poisson_2d_r_chebu (
const Matrice &source,
int l,
double,
int puis) {
241 assert (n == source.get_dim(1)) ;
248 res = _cl_poisson_2d_r_chebu_quatre(source, l) ;
251 res = _cl_poisson_2d_r_chebu_trois (source, l) ;
254 res = _cl_poisson_2d_r_chebu_deux(source, l) ;
266 Matrice _cl_poisson_2d_r_chebu_quatre (
const Matrice &source,
int l) {
268 assert (n == source.get_dim(1)) ;
271 const int nmax = 200 ;
272 static Matrice* tab[nmax] ;
273 static int nb_dejafait = 0 ;
274 static int l_dejafait[nmax] ;
275 static int nr_dejafait[nmax] ;
280 for (
int conte=0 ; conte<nb_dejafait ; conte ++)
281 if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
286 if (nb_dejafait >= nmax) {
287 cout <<
"_cl_poisson_2d_r_chebu_quatre : trop de matrices" << endl ;
292 l_dejafait[nb_dejafait] = l ;
293 nr_dejafait[nb_dejafait] = n ;
295 Matrice barre(source) ;
298 for (
int i=0 ; i<n-2 ; i++) {
299 for (
int j=0 ; j<n ; j++)
300 barre.set(i, j) = ((1+dirac)*source(i, j)-source(i+2, j)) ;
301 if (i==0) dirac = 0 ;
304 Matrice tilde(barre) ;
305 for (
int i=0 ; i<n-4 ; i++)
306 for (
int j=0 ; j<n ; j++)
307 tilde.set(i, j) = (barre(i, j)-barre(i+2, j)) ;
309 Matrice prime(tilde) ;
310 for (
int i=0 ; i<n-4 ; i++)
311 for (
int j=0 ; j<n ; j++)
312 prime.set(i, j) = (tilde(i, j)-tilde(i+1, j)) ;
315 for (
int i=0 ; i<n-4 ; i++)
316 for (
int j=0 ; j<n ; j++)
317 res.set(i, j) = (prime(i, j)-prime(i+2, j)) ;
318 tab[nb_dejafait] =
new Matrice(res) ;
325 return *tab[indice] ;
329 Matrice _cl_poisson_2d_r_chebu_trois (
const Matrice &source,
int l) {
331 assert (n == source.get_dim(1)) ;
334 const int nmax = 200 ;
335 static Matrice* tab[nmax] ;
336 static int nb_dejafait = 0 ;
337 static int l_dejafait[nmax] ;
338 static int nr_dejafait[nmax] ;
343 for (
int conte=0 ; conte<nb_dejafait ; conte ++)
344 if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
349 if (nb_dejafait >= nmax) {
350 cout <<
"_cl_poisson_2d_r_chebu_trois : trop de matrices" << endl ;
355 l_dejafait[nb_dejafait] = l ;
356 nr_dejafait[nb_dejafait] = n ;
358 Matrice barre(source) ;
361 for (
int i=0 ; i<n-2 ; i++) {
362 for (
int j=0 ; j<n ; j++)
363 barre.set(i, j) = ((1+dirac)*source(i, j)-source(i+2, j)) ;
364 if (i==0) dirac = 0 ;
367 Matrice tilde(barre) ;
368 for (
int i=0 ; i<n-2 ; i++)
369 for (
int j=0 ; j<n ; j++)
370 tilde.set(i, j) = (barre(i, j)-barre(i+2, j)) ;
373 for (
int i=0 ; i<n-2 ; i++)
374 for (
int j=0 ; j<n ; j++)
375 res.set(i, j) = (tilde(i, j)+tilde(i+1, j)) ;
377 tab[nb_dejafait] =
new Matrice(res) ;
384 return *tab[indice] ;
389 Matrice _cl_poisson_2d_r_chebu_deux (
const Matrice &source,
int l) {
391 assert (n == source.get_dim(1)) ;
394 const int nmax = 200 ;
395 static Matrice* tab[nmax] ;
396 static int nb_dejafait = 0 ;
397 static int l_dejafait[nmax] ;
398 static int nr_dejafait[nmax] ;
403 for (
int conte=0 ; conte<nb_dejafait ; conte ++)
404 if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
409 if (nb_dejafait >= nmax) {
410 cout <<
"_cl_poisson_2d_r_chebu_deux : trop de matrices" << endl ;
415 l_dejafait[nb_dejafait] = l ;
416 nr_dejafait[nb_dejafait] = n ;
418 Matrice barre(source) ;
421 for (
int i=0 ; i<n-2 ; i++) {
422 for (
int j=0 ; j<n ; j++)
423 barre.set(i, j) = ((1+dirac)*source(i, j)-source(i+2, j)) ;
424 if (i==0) dirac = 0 ;
427 Matrice tilde(barre) ;
428 for (
int i=0 ; i<n-4 ; i++)
429 for (
int j=0 ; j<n ; j++)
430 tilde.set(i, j) = (barre(i, j)-barre(i+2, j)) ;
433 for (
int i=0 ; i<n-4 ; i++)
434 for (
int j=0 ; j<n ; j++)
435 res.set(i, j) = (tilde(i, j)+tilde(i+1, j)) ;
442 return *tab[indice] ;
460 cl_poisson_2d[i] = _cl_poisson_2d_pas_prevu ;
463 cl_poisson_2d[
R_CHEBP >>
TRA_R] = _cl_poisson_2d_r_chebp ;
464 cl_poisson_2d[
R_CHEBI >>
TRA_R] = _cl_poisson_2d_r_chebi ;
465 cl_poisson_2d[
R_CHEB >>
TRA_R] = _cl_poisson_2d_r_cheb ;
466 cl_poisson_2d[
R_CHEBU >>
TRA_R] = _cl_poisson_2d_r_chebu ;
double alpha
Parameter of the associated mapping.
Matrice * ope_cl
Pointer on the banded-matrix of the operator.
double beta
Parameter of the associated mapping.
int dzpuis
the associated dzpuis, if in the compactified domain.
Matrice * ope_mat
Pointer on the matrix representation of the operator.
int l_quant
quantum number
int base_r
Radial basis of decomposition.
#define TRA_R
Translation en R, used for a bitwise shift (in hex)
#define R_CHEBI
base de Cheb. impaire (rare) seulement
#define R_CHEBP
base de Cheb. paire (rare) seulement
int get_dim(int i) const
Returns the dimension of the matrix.
virtual void do_ope_cl() const
Computes the banded-matrix of the operator.
virtual void do_ope_mat() const
Computes the matrix of the operator.
#define R_CHEBU
base de Chebychev ordinaire (fin), dev. en 1/r
#define MAX_BASE
Nombre max. de bases differentes.
#define R_CHEB
base de Chebychev ordinaire (fin)