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