LORENE
prepa_poisson.C
1 /*
2  * Copyright (c) 1999-2001 Philippe Grandclement
3  *
4  * This file is part of LORENE.
5  *
6  * LORENE is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * LORENE is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with LORENE; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  */
21 
22 
23 
24 
25 /*
26  * $Id: prepa_poisson.C,v 1.10 2016/12/05 16:18:10 j_novak Exp $
27  * $Log: prepa_poisson.C,v $
28  * Revision 1.10 2016/12/05 16:18:10 j_novak
29  * Suppression of some global variables (file names, loch, ...) to prevent redefinitions
30  *
31  * Revision 1.9 2014/10/13 08:53:30 j_novak
32  * Lorene classes and functions now belong to the namespace Lorene.
33  *
34  * Revision 1.8 2014/10/06 15:16:10 j_novak
35  * Modified #include directives to use c++ syntax.
36  *
37  * Revision 1.7 2008/02/18 13:53:43 j_novak
38  * Removal of special indentation instructions.
39  *
40  * Revision 1.6 2007/12/12 12:30:48 jl_cornou
41  * *** empty log message ***
42  *
43  * Revision 1.5 2004/02/20 10:55:23 j_novak
44  * The versions dzpuis 5 -> 3 has been improved and polished. Should be
45  * operational now...
46  *
47  * Revision 1.4 2004/02/06 10:53:54 j_novak
48  * New dzpuis = 5 -> dzpuis = 3 case (not ready yet).
49  *
50  * Revision 1.3 2003/01/31 08:49:58 e_gourgoulhon
51  * Increased the number nmax of stored matrices from 100 to 200.
52  *
53  * Revision 1.2 2002/10/16 14:37:12 j_novak
54  * Reorganization of #include instructions of standard C++, in order to
55  * use experimental version 3 of gcc.
56  *
57  * Revision 1.1.1.1 2001/11/20 15:19:28 e_gourgoulhon
58  * LORENE
59  *
60  * Revision 2.17 2000/05/22 13:40:27 phil
61  * ajout du cas dzpuis == 3
62  *
63  * Revision 2.16 2000/01/18 14:15:31 phil
64  * enleve assert sur nobre de points min en r
65  *
66  * Revision 2.15 2000/01/04 19:00:21 phil
67  * Double nmax
68  *
69  * Revision 2.14 1999/10/12 09:38:16 phil
70  * passage en const Matrice &
71  *
72  * Revision 2.13 1999/10/11 14:29:25 phil
73  * & -> &&
74  *
75  * Revision 2.12 1999/09/30 09:20:19 phil
76  * remplacement des && en &
77  *
78  * Revision 2.11 1999/09/17 15:24:46 phil
79  * correction definition de NMAX
80  *
81  * Revision 2.10 1999/06/23 12:34:44 phil
82  * ajout de dzpuis = 2
83  *
84  * Revision 2.9 1999/04/28 10:47:12 phil
85  * augmentation de NMAX a 50
86  *
87  * Revision 2.8 1999/04/19 14:28:47 phil
88  * *** empty log message ***
89  *
90  * Revision 2.7 1999/04/19 14:05:32 phil
91  * *** empty log message ***
92  *
93  * Revision 2.6 1999/04/16 13:18:37 phil
94  * *** empty log message ***
95  *
96  * Revision 2.5 1999/04/16 13:16:24 phil
97  * *** empty log message ***
98  *
99  * Revision 2.4 1999/04/14 13:56:42 phil
100  * Sauvegarde des Matrices deja calculees
101  *
102  * Revision 2.3 1999/04/07 14:38:05 phil
103  * *** empty log message ***
104  *
105  * Revision 2.2 1999/04/07 14:26:22 phil
106  * *** empty log message ***
107  *
108  * Revision 2.1 1999/04/07 14:24:14 phil
109  * Les matrices sont passees par reference
110  *
111  * Revision 2.0 1999/04/07 14:11:07 phil
112  * *** empty log message ***
113  *
114  *
115  * $Header: /cvsroot/Lorene/C++/Source/Non_class_members/PDE/prepa_poisson.C,v 1.10 2016/12/05 16:18:10 j_novak Exp $
116  *
117  */
118 
119 //fichiers includes
120 #include <cstdio>
121 #include <cstdlib>
122 #include <cmath>
123 
124 #include "matrice.h"
125 #include "type_parite.h"
126 #include "proto.h"
127 
128 /*
129  * Fonctions supprimant le nombre de colonnes (les premieres)
130  et de lignes (les dernieres) a l'operateur renvoye par laplacien_mat, de facon
131  a ce qu'il ne soit plus degenere. Ceci doit etre fait apres les combinaisons
132  lineaires. La mise a bandes et la decomposition LU sont egalement effectuees ici
133 
134 
135  Entree : lap : resultat de laplacien_mat
136  l : associe a lap
137  puis : puissance dans la ZEC
138  base_r : base de developpement
139 
140  Sortie : renvoie un operateur non degenere ....
141  */
142 
143 
144 
145 
146  //------------------------------------
147  // Routine pour les cas non prevus --
148  //-----------------------------------
149 
150 namespace Lorene {
151 Matrice _prepa_nondege_pas_prevu(const Matrice &lap, int l, double echelle, int puis) {
152  cout << "Construction non degeneree pas prevue..." << endl ;
153  cout << "l : " << l << endl ;
154  cout << "lap : " << lap << endl ;
155  cout << "echelle : " << echelle << endl ;
156  cout << " puis : " << puis << endl ;
157  abort() ;
158  exit(-1) ;
159  Matrice res(1, 1) ;
160  return res;
161 }
162 
163 
164 
165  //-------------------
166  //-- R_CHEB -------
167  //--------------------
168 
169 Matrice _prepa_nondege_r_cheb (const Matrice &lap, int l, double echelle, int) {
170 
171 
172  int n = lap.get_dim(0) ;
173 
174  const int nmax = 200 ; // Nombre de Matrices stockees
175  static Matrice* tab[nmax] ; // les matrices calculees
176  static int nb_dejafait = 0 ; // nbre de matrices calculees
177  static int l_dejafait[nmax] ;
178  static int nr_dejafait[nmax] ;
179  static double vieux_echelle = 0;
180 
181  // Si on a change l'echelle : on detruit tout :
182  if (vieux_echelle != echelle) {
183  for (int i=0 ; i<nb_dejafait ; i++) {
184  l_dejafait[i] = -1 ;
185  nr_dejafait[i] = -1 ;
186  delete tab[i] ;
187  }
188  vieux_echelle = echelle ;
189  nb_dejafait = 0 ;
190  }
191 
192  int indice = -1 ;
193 
194  // On determine si la matrice a deja ete calculee :
195  for (int conte=0 ; conte<nb_dejafait ; conte ++)
196  if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
197  indice = conte ;
198 
199  // Calcul a faire :
200  if (indice == -1) {
201  if (nb_dejafait >= nmax) {
202  cout << "_prepa_nondege_r_cheb : trop de matrices" << endl ;
203  abort() ;
204  exit (-1) ;
205  }
206 
207 
208  l_dejafait[nb_dejafait] = l ;
209  nr_dejafait[nb_dejafait] = n ;
210 
211 
212  //assert (l<n) ;
213 
214  Matrice res(n-2, n-2) ;
215  res.set_etat_qcq() ;
216  for (int i=0 ; i<n-2 ; i++)
217  for (int j=0 ; j<n-2 ; j++)
218  res.set(i, j) = lap(i, j+2) ;
219 
220  res.set_band(2, 2) ;
221  res.set_lu() ;
222  tab[nb_dejafait] = new Matrice(res) ;
223  nb_dejafait ++ ;
224  return res ;
225  }
226 
227  // Cas ou le calcul a deja ete effectue :
228  else
229  return *tab[indice] ;
230 }
231 
232 
233  //-------------------
234  //-- R_JACO02 -----
235  //-------------------
236 
237 Matrice _prepa_nondege_r_jaco02 (const Matrice &lap, int l, double echelle, int) {
238 
239 
240  int n = lap.get_dim(0) ;
241 
242  const int nmax = 200 ; // Nombre de Matrices stockees
243  static Matrice* tab[nmax] ; // les matrices calculees
244  static int nb_dejafait = 0 ; // nbre de matrices calculees
245  static int l_dejafait[nmax] ;
246  static int nr_dejafait[nmax] ;
247  static double vieux_echelle = 0;
248 
249  // Si on a change l'echelle : on detruit tout :
250  if (vieux_echelle != echelle) {
251  for (int i=0 ; i<nb_dejafait ; i++) {
252  l_dejafait[i] = -1 ;
253  nr_dejafait[i] = -1 ;
254  delete tab[i] ;
255  }
256  vieux_echelle = echelle ;
257  nb_dejafait = 0 ;
258  }
259 
260  int indice = -1 ;
261 
262  // On determine si la matrice a deja ete calculee :
263  for (int conte=0 ; conte<nb_dejafait ; conte ++)
264  if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
265  indice = conte ;
266 
267  // Calcul a faire :
268  if (indice == -1) {
269  if (nb_dejafait >= nmax) {
270  cout << "_prepa_nondege_r_jaco02 : trop de matrices" << endl ;
271  abort() ;
272  exit (-1) ;
273  }
274 
275 
276  l_dejafait[nb_dejafait] = l ;
277  nr_dejafait[nb_dejafait] = n ;
278 
279 
280  //assert (l<n) ;
281 
282  Matrice res(n-2, n-2) ;
283  res.set_etat_qcq() ;
284  for (int i=0 ; i<n-2 ; i++)
285  for (int j=0 ; j<n-2 ; j++)
286  res.set(i, j) = lap(i, j+2) ;
287 
288  res.set_band(2, 2) ;
289  res.set_lu() ;
290  tab[nb_dejafait] = new Matrice(res) ;
291  nb_dejafait ++ ;
292  return res ;
293  }
294 
295  // Cas ou le calcul a deja ete effectue :
296  else
297  return *tab[indice] ;
298 }
299 
300  //------------------
301  //-- R_CHEBP ----
302  //------------------
303 
304 Matrice _prepa_nondege_r_chebp (const Matrice &lap, int l, double, int) {
305 
306  int n = lap.get_dim(0) ;
307 
308 
309  const int nmax = 200 ; // Nombre de Matrices stockees
310  static Matrice* tab[nmax] ; // les matrices calculees
311  static int nb_dejafait = 0 ; // nbre de matrices calculees
312  static int l_dejafait[nmax] ;
313  static int nr_dejafait[nmax] ;
314 
315  int indice = -1 ;
316 
317  // On determine si la matrice a deja ete calculee :
318  for (int conte=0 ; conte<nb_dejafait ; conte ++)
319  if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
320  indice = conte ;
321 
322  // Calcul a faire :
323  if (indice == -1) {
324  if (nb_dejafait >= nmax) {
325  cout << "_prepa_nondege_r_chebp : trop de matrices" << endl ;
326  abort() ;
327  exit (-1) ;
328  }
329 
330 
331  l_dejafait[nb_dejafait] = l ;
332  nr_dejafait[nb_dejafait] = n ;
333 
334  assert (div(l, 2).rem == 0) ;
335  // assert (l<=2*n-2) ;
336 
337  if (l==0) {
338  Matrice res(n-1, n-1) ;
339  res.set_etat_qcq() ;
340  for (int i=0 ; i<n-1 ; i++)
341  for (int j=0 ; j<n-1 ; j++)
342  res.set(i, j) = lap(i, j+1) ;
343  res.set_band(3, 0) ;
344  res.set_lu() ;
345  tab[nb_dejafait] = new Matrice(res) ;
346  nb_dejafait ++ ;
347  return res ;
348  }
349  else {
350  Matrice res(n-2, n-2) ;
351  res.set_etat_qcq() ;
352  for (int i=0 ;i<n-2 ; i++)
353  for (int j=0 ; j<n-2 ; j++)
354  res.set(i, j) = lap(i, j+2) ;
355 
356  res.set_band(2, 1) ;
357  res.set_lu() ;
358  tab[nb_dejafait] = new Matrice(res) ;
359  nb_dejafait ++ ;
360  return res ;
361  }
362  }
363  // Cas ou le calcul a deja ete effectue :
364  else
365  return *tab[indice] ;
366 }
367 
368 
369 
370 
371  //-------------------
372  //-- R_CHEBI -----
373  //-------------------
374 
375 Matrice _prepa_nondege_r_chebi (const Matrice &lap, int l, double, int) {
376 
377  int n = lap.get_dim(0) ;
378 
379  const int nmax = 200 ; // Nombre de Matrices stockees
380  static Matrice* tab[nmax] ; // les matrices calculees
381  static int nb_dejafait = 0 ; // nbre de matrices calculees
382  static int l_dejafait[nmax] ;
383  static int nr_dejafait[nmax] ;
384 
385  int indice = -1 ;
386 
387  // On determine si la matrice a deja ete calculee :
388  for (int conte=0 ; conte<nb_dejafait ; conte ++)
389  if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
390  indice = conte ;
391 
392  // Calcul a faire :
393  if (indice == -1) {
394  if (nb_dejafait >= nmax) {
395  cout << "_prepa_nondege_r_chebi : trop de matrices" << endl ;
396  abort() ;
397  exit (-1) ;
398  }
399 
400 
401  l_dejafait[nb_dejafait] = l ;
402  nr_dejafait[nb_dejafait] = n ;
403 
404 
405  assert (div(l, 2).rem == 1) ;
406  // assert (l<=2*n-1) ;
407 
408  if (l==1) {
409  Matrice res(n-1, n-1) ;
410  res.set_etat_qcq() ;
411  for (int i=0 ; i<n-1 ; i++)
412  for (int j=0 ; j<n-1 ; j++)
413  res.set(i, j) = lap(i, j+1) ;
414  res.set_band(3, 0) ;
415  res.set_lu() ;
416  tab[nb_dejafait] = new Matrice(res) ;
417  nb_dejafait ++ ;
418  return res ;
419  }
420  else {
421  Matrice res(n-2, n-2) ;
422  res.set_etat_qcq() ;
423  for (int i=0 ;i<n-2 ; i++)
424  for (int j=0 ; j<n-2 ; j++)
425  res.set(i, j) = lap(i, j+2) ;
426 
427  res.set_band(2, 1) ;
428  res.set_lu() ;
429  tab[nb_dejafait] = new Matrice(res) ;
430  nb_dejafait ++ ;
431  return res ;
432  }
433  }
434  // Cas ou le calcul a deja ete effectue :
435  else
436  return *tab[indice] ;
437 }
438 
439 
440 
441 
442  //-------------------
443  //-- R_CHEBU -----
444  //-------------------
445 
446 
447 Matrice _prepa_nondege_r_chebu (const Matrice &lap, int l, double, int puis) {
448 
449  switch (puis) {
450  case 5 :
451  return _prepa_nondege_r_chebu_cinq (lap, l) ;
452  case 4 :
453  return _prepa_nondege_r_chebu_quatre (lap, l) ;
454  case 3 :
455  return _prepa_nondege_r_chebu_trois (lap, l) ;
456  case 2 :
457  return _prepa_nondege_r_chebu_deux (lap, l) ;
458  default :
459  abort() ;
460  exit(-1) ;
461  return Matrice(0, 0) ;
462  }
463 }
464 
465 // Cas dzpuis = 4 ;
466 Matrice _prepa_nondege_r_chebu_quatre (const Matrice &lap, int l) {
467 
468  int n = lap.get_dim(0) ;
469 
470  const int nmax = 200; // Nombre de Matrices stockees
471  static Matrice* tab[nmax] ; // les matrices calculees
472  static int nb_dejafait = 0 ; // nbre de matrices calculees
473  static int l_dejafait[nmax] ;
474  static int nr_dejafait[nmax] ;
475 
476  int indice = -1 ;
477 
478  // On determine si la matrice a deja ete calculee :
479  for (int conte=0 ; conte<nb_dejafait ; conte ++)
480  if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
481  indice = conte ;
482 
483  // Calcul a faire :
484  if (indice == -1) {
485  if (nb_dejafait >= nmax) {
486  cout << "_prepa_nondege_r_chebu : trop de matrices" << endl ;
487  abort() ;
488  exit (-1) ;
489  }
490 
491 
492  l_dejafait[nb_dejafait] = l ;
493  nr_dejafait[nb_dejafait] = n ;
494 
495  // assert (l<=n-2) ;
496 
497  if (l==0) {
498  Matrice res(n-2, n-2) ;
499  res.set_etat_qcq() ;
500  for (int i=0 ; i<n-2 ; i++)
501  for (int j=0 ; j<n-2 ; j++)
502  res.set(i, j) = lap(i, j+2) ;
503  res.set_band(3, 0) ;
504  res.set_lu() ;
505  tab[nb_dejafait] = new Matrice(res) ;
506  nb_dejafait ++ ;
507  return res ;
508  }
509  else {
510  Matrice res(n-3, n-3) ;
511  res.set_etat_qcq() ;
512  for (int i=0 ;i<n-3 ; i++)
513  for (int j=0 ; j<n-3 ; j++)
514  res.set(i, j) = lap(i, j+3) ;
515 
516  res.set_band(2, 1) ;
517  res.set_lu() ;
518  tab[nb_dejafait] = new Matrice(res) ;
519  nb_dejafait ++ ;
520  return res ;
521  }
522  }
523  // Cas ou le calcul a deja ete effectue :
524  else
525  return *tab[indice] ;
526 }
527 // Cas dzpuis = 3 ;
528 Matrice _prepa_nondege_r_chebu_trois (const Matrice &lap, int l) {
529 
530  int n = lap.get_dim(0) ;
531 
532  const int nmax = 200; // Nombre de Matrices stockees
533  static Matrice* tab[nmax] ; // les matrices calculees
534  static int nb_dejafait = 0 ; // nbre de matrices calculees
535  static int l_dejafait[nmax] ;
536  static int nr_dejafait[nmax] ;
537 
538  int indice = -1 ;
539 
540  // On determine si la matrice a deja ete calculee :
541  for (int conte=0 ; conte<nb_dejafait ; conte ++)
542  if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
543  indice = conte ;
544 
545  // Calcul a faire :
546  if (indice == -1) {
547  if (nb_dejafait >= nmax) {
548  cout << "_prepa_nondege_r_chebu_trois : trop de matrices" << endl ;
549  abort() ;
550  exit (-1) ;
551  }
552 
553  l_dejafait[nb_dejafait] = l ;
554  nr_dejafait[nb_dejafait] = n ;
555 
556  Matrice res(n-2, n-2) ;
557  res.set_etat_qcq() ;
558  for (int i=0 ; i<n-2 ; i++)
559  for (int j=0 ; j<n-2 ; j++)
560  res.set(i, j) = lap(i, j+2) ;
561  res.set_band(2, 1) ;
562  res.set_lu() ;
563  tab[nb_dejafait] = new Matrice(res) ;
564  nb_dejafait ++ ;
565  return res ;
566  }
567  // Cas ou le calcul a deja ete effectue :
568  else
569  return *tab[indice] ;
570 }
571 
572 // Cas dzpuis = 2 ;
573 Matrice _prepa_nondege_r_chebu_deux (const Matrice &lap, int l) {
574 
575  int n = lap.get_dim(0) ;
576 
577  const int nmax = 200; // Nombre de Matrices stockees
578  static Matrice* tab[nmax] ; // les matrices calculees
579  static int nb_dejafait = 0 ; // nbre de matrices calculees
580  static int l_dejafait[nmax] ;
581  static int nr_dejafait[nmax] ;
582 
583  int indice = -1 ;
584 
585  // On determine si la matrice a deja ete calculee :
586  for (int conte=0 ; conte<nb_dejafait ; conte ++)
587  if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
588  indice = conte ;
589 
590  // Calcul a faire :
591  if (indice == -1) {
592  if (nb_dejafait >= nmax) {
593  cout << "_prepa_nondege_r_chebu : trop de matrices" << endl ;
594  abort() ;
595  exit (-1) ;
596  }
597 
598 
599  l_dejafait[nb_dejafait] = l ;
600  nr_dejafait[nb_dejafait] = n ;
601 
602  // assert (l<=n-2) ;
603 
604  if (l==0) {
605  Matrice res(n-2, n-2) ;
606  res.set_etat_qcq() ;
607  for (int i=0 ;i<n-2 ; i++)
608  for (int j=0 ; j<n-2 ; j++)
609  res.set(i, j) = lap(i, j+2) ;
610  res.set_band(3, 2) ;
611  res.set_lu() ;
612  tab[nb_dejafait] = new Matrice(res) ;
613  nb_dejafait ++ ;
614  return res ;
615  }
616  else {
617  Matrice res(n-1, n-1) ;
618  res.set_etat_qcq() ;
619  for (int i=0 ;i<n-1 ; i++)
620  for (int j=0 ; j<n-1 ; j++)
621  res.set(i, j) = lap(i, j+1) ;
622  res.set_band(4, 1) ;
623  res.set_lu() ;
624  tab[nb_dejafait] = new Matrice(res) ;
625  nb_dejafait ++ ;
626  return res ;
627  }
628  }
629  // Cas ou le calcul a deja ete effectue :
630  else
631  return *tab[indice] ;
632 }
633 
634 // Cas dzpuis = 5 ;
635 Matrice _prepa_nondege_r_chebu_cinq (const Matrice &lap, int l) {
636 
637  int n = lap.get_dim(0) ;
638 
639  const int nmax = 200; // Nombre de Matrices stockees
640  static Matrice* tab[nmax] ; // les matrices calculees
641  static int nb_dejafait = 0 ; // nbre de matrices calculees
642  static int l_dejafait[nmax] ;
643  static int nr_dejafait[nmax] ;
644 
645  int indice = -1 ;
646 
647  // On determine si la matrice a deja ete calculee :
648  for (int conte=0 ; conte<nb_dejafait ; conte ++)
649  if ((l_dejafait[conte] == l) && (nr_dejafait[conte] == n))
650  indice = conte ;
651 
652  // Calcul a faire :
653  if (indice == -1) {
654  if (nb_dejafait >= nmax) {
655  cout << "_prepa_nondege_r_chebu : trop de matrices" << endl ;
656  abort() ;
657  exit (-1) ;
658  }
659 
660 
661  l_dejafait[nb_dejafait] = l ;
662  nr_dejafait[nb_dejafait] = n ;
663 
664  // assert (l<=n-2) ;
665 
666  if (l<2) {
667  tab[nb_dejafait] = new Matrice(lap) ;
668  tab[nb_dejafait]->set_band(5,0) ;
669  tab[nb_dejafait]->set_lu() ;
670  nb_dejafait++ ;
671  return *tab[nb_dejafait-1] ;
672  }
673  else {
674  Matrice res(n-1, n-1) ;
675  res.set_etat_qcq() ;
676  for (int i=0 ;i<n-1 ; i++)
677  for (int j=0 ; j<n-1 ; j++)
678  res.set(i, j) = lap(i, j+1) ;
679  res.set_band(4, 1) ;
680  res.set_lu() ;
681  tab[nb_dejafait] = new Matrice(res) ;
682  nb_dejafait ++ ;
683  return res ;
684  }
685 
686  }
687  // Cas ou le calcul a deja ete effectue :
688  else
689  return *tab[indice] ;
690 }
691 
692  //-------------------
693  //-- Fonction ----
694  //-------------------
695 
696 
697 Matrice prepa_nondege(const Matrice &lap, int l, double echelle, int puis, int base_r)
698 {
699 
700  // Routines de derivation
701  static Matrice (*prepa_nondege[MAX_BASE])(const Matrice&, int, double, int) ;
702  static int nap = 0 ;
703 
704  // Premier appel
705  if (nap==0) {
706  nap = 1 ;
707  for (int i=0 ; i<MAX_BASE ; i++) {
708  prepa_nondege[i] = _prepa_nondege_pas_prevu ;
709  }
710  // Les routines existantes
711  prepa_nondege[R_CHEB >> TRA_R] = _prepa_nondege_r_cheb ;
712  prepa_nondege[R_CHEBU >> TRA_R] = _prepa_nondege_r_chebu ;
713  prepa_nondege[R_CHEBP >> TRA_R] = _prepa_nondege_r_chebp ;
714  prepa_nondege[R_CHEBI >> TRA_R] = _prepa_nondege_r_chebi ;
715  prepa_nondege[R_JACO02 >> TRA_R] = _prepa_nondege_r_jaco02 ;
716  }
717 
718  Matrice res(prepa_nondege[base_r](lap, l, echelle, puis)) ;
719  return res ;
720 }
721 
722 }
Lorene prototypes.
Definition: app_hor.h:67
#define R_JACO02
base de Jacobi(0,2) ordinaire (finjac)
Definition: type_parite.h:188
#define TRA_R
Translation en R, used for a bitwise shift (in hex)
Definition: type_parite.h:158
#define R_CHEBI
base de Cheb. impaire (rare) seulement
Definition: type_parite.h:170
#define R_CHEBP
base de Cheb. paire (rare) seulement
Definition: type_parite.h:168
int get_dim(int i) const
Returns the dimension of the matrix.
Definition: matrice.C:263
#define R_CHEBU
base de Chebychev ordinaire (fin), dev. en 1/r
Definition: type_parite.h:180
#define MAX_BASE
Nombre max. de bases differentes.
Definition: type_parite.h:144
#define R_CHEB
base de Chebychev ordinaire (fin)
Definition: type_parite.h:166