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
23char 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
147namespace Lorene {
148Matrice _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
166Matrice _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
234Matrice _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
301Matrice _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
372Matrice _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
444Matrice _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 ;
463Matrice _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 ;
525Matrice _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 ;
570Matrice _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 ;
632Matrice _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
694Matrice 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}
int get_dim(int i) const
Returns the dimension of the matrix.
Definition matrice.C:260
#define MAX_BASE
Nombre max. de bases differentes.
#define R_CHEBU
base de Chebychev ordinaire (fin), dev. en 1/r
#define R_JACO02
base de Jacobi(0,2) ordinaire (finjac)
#define R_CHEBI
base de Cheb. impaire (rare) seulement
#define TRA_R
Translation en R, used for a bitwise shift (in hex)
#define R_CHEB
base de Chebychev ordinaire (fin)
#define R_CHEBP
base de Cheb. paire (rare) seulement
Lorene prototypes.
Definition app_hor.h:64