LORENE
base_val_name_theta.C
1 /*
2  * Method Base_val::name_theta
3  *
4  * (see file base_val.h for documentation).
5  *
6  */
7 
8 /*
9  * Copyright (c) 2003 Eric Gourgoulhon.
10  *
11  * This file is part of LORENE.
12  *
13  * LORENE is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License version 2
15  * as published by the Free Software Foundation.
16  *
17  * LORENE is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with LORENE; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25  *
26  */
27 
28 char base_val_name_theta_C[] = "$Header: /cvsroot/Lorene/C++/Source/Base_val/base_val_name_theta.C,v 1.9 2014/10/13 08:52:39 j_novak Exp $" ;
29 
30 /*
31  * $Id: base_val_name_theta.C,v 1.9 2014/10/13 08:52:39 j_novak Exp $
32  * $Log: base_val_name_theta.C,v $
33  * Revision 1.9 2014/10/13 08:52:39 j_novak
34  * Lorene classes and functions now belong to the namespace Lorene.
35  *
36  * Revision 1.8 2014/10/06 15:12:57 j_novak
37  * Modified #include directives to use c++ syntax.
38  *
39  * Revision 1.7 2009/10/23 12:55:16 j_novak
40  * New base T_LEG_MI
41  *
42  * Revision 1.6 2009/10/08 16:20:13 j_novak
43  * Addition of new bases T_COS and T_SIN.
44  *
45  * Revision 1.5 2004/12/17 13:35:01 m_forot
46  * Add the case T_LEG
47  *
48  * Revision 1.4 2004/11/23 15:08:01 m_forot
49  * Added the bases for the cases without any equatorial symmetry
50  * (T_COSSIN_C, T_COSSIN_S, T_LEG, R_CHEBPI_P, R_CHEBPI_I).
51  *
52  * Revision 1.3 2004/10/04 13:40:38 j_novak
53  * Added the T_COS base case.
54  *
55  * Revision 1.2 2004/08/24 09:14:41 p_grandclement
56  * Addition of some new operators, like Poisson in 2d... It now requieres the
57  * GSL library to work.
58  *
59  * Also, the way a variable change is stored by a Param_elliptic is changed and
60  * no longer uses Change_var but rather 2 Scalars. The codes using that feature
61  * will requiere some modification. (It should concern only the ones about monopoles)
62  *
63  * Revision 1.1 2003/10/19 19:49:40 e_gourgoulhon
64  * First version
65  *
66  *
67  *
68  * $Header: /cvsroot/Lorene/C++/Source/Base_val/base_val_name_theta.C,v 1.9 2014/10/13 08:52:39 j_novak Exp $
69  *
70  */
71 
72 // C headers
73 #include <cstring>
74 #include <cstdlib>
75 
76 // Lorene headers
77 #include "type_parite.h"
78 #include "base_val.h"
79 
80 // Local prototypes
81 namespace Lorene {
82 void basename_t_unknown(int, int, char*) ;
83 void basename_t_cos(int, int, char*) ;
84 void basename_t_sin(int, int, char*) ;
85 void basename_t_cos_p(int, int, char*) ;
86 void basename_t_sin_p(int, int, char*) ;
87 void basename_t_cos_i(int, int, char*) ;
88 void basename_t_sin_i(int, int, char*) ;
89 void basename_t_cossin_cp(int, int, char*) ;
90 void basename_t_cossin_sp(int, int, char*) ;
91 void basename_t_cossin_c(int, int, char*) ;
92 void basename_t_cossin_s(int, int, char*) ;
93 void basename_t_cossin_ci(int, int, char*) ;
94 void basename_t_cossin_si(int, int, char*) ;
95 void basename_t_leg_p(int, int, char*) ;
96 void basename_t_leg(int, int, char*) ;
97 void basename_t_leg_mp(int, int, char*) ;
98 void basename_t_leg_mi(int, int, char*) ;
99 void basename_t_leg_pp(int, int, char*) ;
100 void basename_t_leg_i(int, int, char*) ;
101 void basename_t_leg_ip(int, int, char*) ;
102 void basename_t_leg_pi(int, int, char*) ;
103 void basename_t_leg_ii(int, int, char*) ;
104 void basename_t_cl_cos_p(int, int, char*) ;
105 void basename_t_cl_sin_p(int, int, char*) ;
106 void basename_t_cl_cos_i(int, int, char*) ;
107 void basename_t_cl_sin_i(int, int, char*) ;
108 
109 
110  //----------------------------//
111  // Base_val method //
112  //----------------------------//
113 
114 void Base_val::name_theta(int l, int k, int j, char* name) const {
115 
116  // Array of actual base name functions
117  static void(*vbasename_t[MAX_BASE])(int, int, char*) ;
118 
119  static bool first_call = true ;
120 
121  // Initializations at first call
122  // -----------------------------
123  if ( first_call ) {
124 
125  first_call = false ;
126 
127  for (int i=0 ; i<MAX_BASE ; i++) {
128  vbasename_t[i] = basename_t_unknown ;
129  }
130 
131  vbasename_t[T_COS >> TRA_T] = basename_t_cos ;
132  vbasename_t[T_SIN >> TRA_T] = basename_t_sin ;
133  vbasename_t[T_COS_P >> TRA_T] = basename_t_cos_p ;
134  vbasename_t[T_SIN_P >> TRA_T] = basename_t_sin_p ;
135  vbasename_t[T_COS_I >> TRA_T] = basename_t_cos_i ;
136  vbasename_t[T_SIN_I >> TRA_T] = basename_t_sin_i ;
137  vbasename_t[T_COSSIN_CP >> TRA_T] = basename_t_cossin_cp ;
138  vbasename_t[T_COSSIN_SP >> TRA_T] = basename_t_cossin_sp ;
139  vbasename_t[T_COSSIN_CI >> TRA_T] = basename_t_cossin_ci ;
140  vbasename_t[T_COSSIN_SI >> TRA_T] = basename_t_cossin_si ;
141  vbasename_t[T_COSSIN_C >> TRA_T] = basename_t_cossin_c ;
142  vbasename_t[T_COSSIN_S >> TRA_T] = basename_t_cossin_s ;
143  vbasename_t[T_LEG_P >> TRA_T] = basename_t_leg_p ;
144  vbasename_t[T_LEG_MP >> TRA_T] = basename_t_leg_mp ;
145  vbasename_t[T_LEG_MI >> TRA_T] = basename_t_leg_mi ;
146  vbasename_t[T_LEG >> TRA_T] = basename_t_leg ;
147  vbasename_t[T_LEG_PP >> TRA_T] = basename_t_leg_pp ;
148  vbasename_t[T_LEG_I >> TRA_T] = basename_t_leg_i ;
149  vbasename_t[T_LEG_IP >> TRA_T] = basename_t_leg_ip ;
150  vbasename_t[T_LEG_PI >> TRA_T] = basename_t_leg_pi ;
151  vbasename_t[T_LEG_II >> TRA_T] = basename_t_leg_ii ;
152  vbasename_t[T_CL_COS_P >> TRA_T] = basename_t_cl_cos_p ;
153  vbasename_t[T_CL_SIN_P >> TRA_T] = basename_t_cl_sin_p ;
154  vbasename_t[T_CL_COS_I >> TRA_T] = basename_t_cl_cos_i ;
155  vbasename_t[T_CL_SIN_I >> TRA_T] = basename_t_cl_sin_i ;
156 
157  }
158 
159  // Call to the function adapted to the basis in domain l
160  //------------------------------------------------------
161 
162  assert( (l>=0) && (l<nzone) ) ;
163 
164  int base_t = ( b[l] & MSQ_T ) >> TRA_T ;
165 
166  vbasename_t[base_t](k, j, name) ;
167 
168 }
169 
170 
171  //-------------------------------//
172  // individual basis functions //
173  //-------------------------------//
174 
175 void basename_t_unknown(int, int, char*) {
176  cout << "Base_val::name_theta : unknwon basis !" << endl ;
177  abort() ;
178 }
179 
180 
181 void basename_t_cos(int , int j, char* name) {
182 
183  assert( j>=0 ) ;
184 
185  strcpy(name, "cos") ;
186 
187  int xt = j ;
188 
189  char cxt[4] ;
190  assert( xt < 1000) ;
191  sprintf(cxt, "%d", xt) ;
192  strcat(name, cxt) ;
193  strcat(name, "t") ;
194 }
195 
196 void basename_t_sin(int , int j, char* name) {
197 
198  assert( j>=0 ) ;
199 
200  strcpy(name, "sin") ;
201 
202  int xt = j ;
203 
204  char cxt[4] ;
205  assert( xt < 1000) ;
206  sprintf(cxt, "%d", xt) ;
207  strcat(name, cxt) ;
208  strcat(name, "t") ;
209 }
210 
211 
212 void basename_t_cos_p(int , int j, char* name) {
213 
214  assert( j>=0 ) ;
215 
216  strcpy(name, "cos") ;
217 
218  int xt = 2*j ;
219 
220  char cxt[4] ;
221  assert( xt < 1000) ;
222  sprintf(cxt, "%d", xt) ;
223  strcat(name, cxt) ;
224  strcat(name, "t") ;
225 }
226 
227 
228 void basename_t_sin_p(int , int j, char* name) {
229 
230  assert( j>=0 ) ;
231 
232  if (j == 0) {
233  strcpy(name, "unused") ;
234  return ;
235  }
236 
237  strcpy(name, "sin") ;
238 
239  int xt = 2*j ;
240 
241  char cxt[4] ;
242  assert( xt < 1000) ;
243  sprintf(cxt, "%d", xt) ;
244  strcat(name, cxt) ;
245  strcat(name, "t") ;
246 }
247 
248 void basename_t_cl_cos_p(int , int j, char* name) {
249 
250  assert( j>=0 ) ;
251 
252  strcpy(name, "cl_cos") ;
253 
254  int xt = 2*j ;
255 
256  char cxt[4] ;
257  assert( xt < 1000) ;
258  sprintf(cxt, "%d", xt) ;
259  strcat(name, cxt) ;
260  strcat(name, "t") ;
261 }
262 
263 void basename_t_cl_sin_p(int , int j, char* name) {
264 
265  assert( j>=0 ) ;
266 
267  strcpy(name, "cl_sin") ;
268 
269  int xt = 2*j ;
270 
271  char cxt[4] ;
272  assert( xt < 1000) ;
273  sprintf(cxt, "%d", xt) ;
274  strcat(name, cxt) ;
275  strcat(name, "t") ;
276 }
277 
278 void basename_t_cos_i(int , int j, char* name) {
279 
280  assert( j>=0 ) ;
281 
282  strcpy(name, "cos") ;
283 
284  int xt = 2*j + 1 ;
285 
286  char cxt[4] ;
287  assert( xt < 1000) ;
288  sprintf(cxt, "%d", xt) ;
289  strcat(name, cxt) ;
290  strcat(name, "t") ;
291 }
292 
293 void basename_t_cl_cos_i(int , int j, char* name) {
294 
295  assert( j>=0 ) ;
296 
297  strcpy(name, "cl_cos") ;
298 
299  int xt = 2*j + 1 ;
300 
301  char cxt[4] ;
302  assert( xt < 1000) ;
303  sprintf(cxt, "%d", xt) ;
304  strcat(name, cxt) ;
305  strcat(name, "t") ;
306 }
307 
308 void basename_t_sin_i(int , int j, char* name) {
309 
310  assert( j>=0 ) ;
311 
312  strcpy(name, "sin") ;
313 
314  int xt = 2*j + 1 ;
315 
316  char cxt[4] ;
317  assert( xt < 1000) ;
318  sprintf(cxt, "%d", xt) ;
319  strcat(name, cxt) ;
320  strcat(name, "t") ;
321 }
322 
323 void basename_t_cl_sin_i(int , int j, char* name) {
324 
325  assert( j>=0 ) ;
326 
327  strcpy(name, "cl_sin") ;
328 
329  int xt = 2*j + 1 ;
330 
331  char cxt[4] ;
332  assert( xt < 1000) ;
333  sprintf(cxt, "%d", xt) ;
334  strcat(name, cxt) ;
335  strcat(name, "t") ;
336 }
337 
338 
339 void basename_t_cossin_cp(int k, int j, char* name) {
340 
341  assert( k>=0 ) ;
342  assert( j>=0 ) ;
343 
344  int m = k / 2 ;
345  int xt ;
346  if (m%2 == 0) {
347  strcpy(name, "cos") ;
348  xt = 2*j ;
349  }
350  else {
351  strcpy(name, "sin") ;
352  xt = 2*j + 1 ;
353  }
354 
355  char cxt[4] ;
356  assert( xt < 1000) ;
357  sprintf(cxt, "%d", xt) ;
358  strcat(name, cxt) ;
359  strcat(name, "t") ;
360 }
361 
362 
363 void basename_t_cossin_sp(int k, int j, char* name) {
364 
365  assert( k>=0 ) ;
366  assert( j>=0 ) ;
367 
368  int m = k / 2 ;
369  int xt ;
370  if (m%2 == 0) {
371  if (j == 0) {
372  strcpy(name, "unused") ;
373  return ;
374  }
375  else {
376  strcpy(name, "sin") ;
377  xt = 2*j ;
378  }
379  }
380  else {
381  strcpy(name, "cos") ;
382  xt = 2*j + 1 ;
383  }
384 
385  char cxt[4] ;
386  assert( xt < 1000) ;
387  sprintf(cxt, "%d", xt) ;
388  strcat(name, cxt) ;
389  strcat(name, "t") ;
390 }
391 
392 void basename_t_cossin_c(int k, int j, char* name) {
393 
394  assert( k>=0 ) ;
395  assert( j>=0 ) ;
396 
397  int m = k / 2 ;
398  int xt ;
399  if (m%2 == 0) {
400  strcpy(name, "cos") ;
401  xt = j ;
402  }
403  else {
404  if (j == 0) {
405  strcpy(name, "unused") ;
406  return ;
407  } else {
408  strcpy(name, "sin") ;
409  xt = j ;
410  }
411  }
412 
413  char cxt[4] ;
414  assert( xt < 1000) ;
415  sprintf(cxt, "%d", xt) ;
416  strcat(name, cxt) ;
417  strcat(name, "t") ;
418 }
419 
420 
421 void basename_t_cossin_s(int k, int j, char* name) {
422 
423  assert( k>=0 ) ;
424  assert( j>=0 ) ;
425 
426  int m = k / 2 ;
427  int xt ;
428  if (m%2 == 0) {
429  if (j == 0) {
430  strcpy(name, "unused") ;
431  return ;
432  }
433  else {
434  strcpy(name, "sin") ;
435  xt = j ;
436  }
437  }
438  else {
439  strcpy(name, "cos") ;
440  xt = j ;
441  }
442 
443  char cxt[4] ;
444  assert( xt < 1000) ;
445  sprintf(cxt, "%d", xt) ;
446  strcat(name, cxt) ;
447  strcat(name, "t") ;
448 }
449 
450 
451 void basename_t_cossin_ci(int k, int j, char* name) {
452 
453  assert( k>=0 ) ;
454  assert( j>=0 ) ;
455 
456  int m = k / 2 ;
457  int xt ;
458  if (m%2 == 0) {
459  strcpy(name, "cos") ;
460  xt = 2*j + 1;
461  }
462  else {
463  if (j == 0) {
464  strcpy(name, "unused") ;
465  return ;
466  }
467  else {
468  strcpy(name, "sin") ;
469  xt = 2*j ;
470  }
471  }
472 
473  char cxt[4] ;
474  assert( xt < 1000) ;
475  sprintf(cxt, "%d", xt) ;
476  strcat(name, cxt) ;
477  strcat(name, "t") ;
478 }
479 
480 
481 void basename_t_cossin_si(int k, int j, char* name) {
482 
483  assert( k>=0 ) ;
484  assert( j>=0 ) ;
485 
486  int m = k / 2 ;
487  int xt ;
488  if (m%2 == 0) {
489  strcpy(name, "sin") ;
490  xt = 2*j + 1;
491  }
492  else {
493  strcpy(name, "cos") ;
494  xt = 2*j ;
495  }
496 
497  char cxt[4] ;
498  assert( xt < 1000) ;
499  sprintf(cxt, "%d", xt) ;
500  strcat(name, cxt) ;
501  strcat(name, "t") ;
502 }
503 
504 void basename_t_leg(int k, int j, char* name) {
505 
506  assert( k>=0 ) ;
507  assert( j>=0 ) ;
508 
509  int m = k / 2 ;
510 
511  if (j < m/2) {
512  strcpy (name, "unused") ;
513  return ;
514  }
515 
516  strcpy(name, "P_") ;
517 
518  int xt = j;
519 
520  char cxt[4] ;
521  assert( xt < 1000) ;
522  sprintf(cxt, "%d", xt) ;
523  strcat(name, cxt) ;
524  strcat(name, "^") ;
525 
526  assert( m < 1000) ;
527  sprintf(cxt, "%d", m) ;
528  strcat(name, cxt) ;
529 }
530 
531 void basename_t_leg_mp(int k, int j, char* name) {
532 
533  assert( k>=0 ) ;
534  assert( j>=0 ) ;
535 
536  int m = 2 * (k / 2) ;
537 
538  if (j < m/2) {
539  strcpy (name, "unused") ;
540  return ;
541  }
542 
543  strcpy(name, "P_") ;
544 
545  int xt = j;
546 
547  char cxt[4] ;
548  assert( xt < 1000) ;
549  sprintf(cxt, "%d", xt) ;
550  strcat(name, cxt) ;
551  strcat(name, "^") ;
552 
553  assert( m < 1000) ;
554  sprintf(cxt, "%d", m) ;
555  strcat(name, cxt) ;
556 }
557 
558 void basename_t_leg_mi(int k, int j, char* name) {
559 
560  assert( k>=0 ) ;
561  assert( j>=0 ) ;
562 
563  int m = 2 * ((k-1) / 2) + 1 ;
564 
565  if (j < m/2) {
566  strcpy (name, "unused") ;
567  return ;
568  }
569 
570  strcpy(name, "P_") ;
571 
572  int xt = j;
573 
574  char cxt[4] ;
575  assert( xt < 1000) ;
576  sprintf(cxt, "%d", xt) ;
577  strcat(name, cxt) ;
578  strcat(name, "^") ;
579 
580  assert( m < 1000) ;
581  sprintf(cxt, "%d", m) ;
582  strcat(name, cxt) ;
583 }
584 
585 void basename_t_leg_p(int k, int j, char* name) {
586 
587  assert( k>=0 ) ;
588  assert( j>=0 ) ;
589 
590  int m = k / 2 ;
591 
592  if (j < m/2) {
593  strcpy (name, "unused") ;
594  return ;
595  }
596 
597  strcpy(name, "P_") ;
598 
599  int xt = (m%2 == 0) ? 2*j : 2*j + 1 ;
600 
601  char cxt[4] ;
602  assert( xt < 1000) ;
603  sprintf(cxt, "%d", xt) ;
604  strcat(name, cxt) ;
605  strcat(name, "^") ;
606 
607  assert( m < 1000) ;
608  sprintf(cxt, "%d", m) ;
609  strcat(name, cxt) ;
610 }
611 
612 
613 void basename_t_leg_pp(int k, int j, char* name) {
614 
615  assert( k>=0 ) ;
616  assert( j>=0 ) ;
617 
618  int m = 2 * (k / 2) ;
619 
620  if (j < m/2) {
621  strcpy (name, "unused") ;
622  return ;
623  }
624 
625  strcpy(name, "P_") ;
626 
627  int xt = 2*j ;
628 
629  char cxt[4] ;
630  assert( xt < 1000) ;
631  sprintf(cxt, "%d", xt) ;
632  strcat(name, cxt) ;
633  strcat(name, "^") ;
634 
635  assert( m < 1000) ;
636  sprintf(cxt, "%d", m) ;
637  strcat(name, cxt) ;
638 }
639 
640 
641 void basename_t_leg_i(int k, int j, char* name) {
642 
643  assert( k>=0 ) ;
644  assert( j>=0 ) ;
645 
646  int m = k / 2 ;
647 
648  if (j < m/2 + m%2) {
649  strcpy (name, "unused") ;
650  return ;
651  }
652 
653  strcpy(name, "P_") ;
654 
655  int xt = (m%2 == 0) ? 2*j + 1 : 2*j ;
656 
657  char cxt[4] ;
658  assert( xt < 1000) ;
659  sprintf(cxt, "%d", xt) ;
660  strcat(name, cxt) ;
661  strcat(name, "^") ;
662 
663  assert( m < 1000) ;
664  sprintf(cxt, "%d", m) ;
665  strcat(name, cxt) ;
666 }
667 
668 
669 void basename_t_leg_ip(int k, int j, char* name) {
670 
671  assert( k>=0 ) ;
672  assert( j>=0 ) ;
673 
674  int m = 2 * (k / 2) ;
675 
676  if (j < m/2) {
677  strcpy (name, "unused") ;
678  return ;
679  }
680 
681  strcpy(name, "P_") ;
682 
683  int xt = 2*j + 1 ;
684 
685  char cxt[4] ;
686  assert( xt < 1000) ;
687  sprintf(cxt, "%d", xt) ;
688  strcat(name, cxt) ;
689  strcat(name, "^") ;
690 
691  assert( m < 1000) ;
692  sprintf(cxt, "%d", m) ;
693  strcat(name, cxt) ;
694 }
695 
696 
697 void basename_t_leg_pi(int k, int j, char* name) {
698 
699  assert( k>=0 ) ;
700  assert( j>=0 ) ;
701 
702  int m = 2 * ((k-1) / 2) + 1 ;
703 
704  if (j < m/2) {
705  strcpy (name, "unused") ;
706  return ;
707  }
708 
709  strcpy(name, "P_") ;
710 
711  int xt = 2*j + 1 ;
712 
713  char cxt[4] ;
714  assert( xt < 1000) ;
715  sprintf(cxt, "%d", xt) ;
716  strcat(name, cxt) ;
717  strcat(name, "^") ;
718 
719  assert( m < 1000) ;
720  sprintf(cxt, "%d", m) ;
721  strcat(name, cxt) ;
722 }
723 
724 
725 void basename_t_leg_ii(int k, int j, char* name) {
726 
727  assert( k>=0 ) ;
728  assert( j>=0 ) ;
729 
730  int m = 2 * ((k-1) / 2) + 1 ;
731 
732  if (j < m/2 + 1) {
733  strcpy (name, "unused") ;
734  return ;
735  }
736 
737  strcpy(name, "P_") ;
738 
739  int xt = 2*j ;
740 
741  char cxt[4] ;
742  assert( xt < 1000) ;
743  sprintf(cxt, "%d", xt) ;
744  strcat(name, cxt) ;
745  strcat(name, "^") ;
746 
747  assert( m < 1000) ;
748  sprintf(cxt, "%d", m) ;
749  strcat(name, cxt) ;
750 }
751 
752 
753 
754 
755 
756 
757 
758 
759 
760 
761 
762 
763 
764 
765 }
void name_theta(int l, int k, int j, char *basename) const
Name of the basis function in .
int * b
Array (size: nzone ) of the spectral basis in each domain.
Definition: base_val.h:331
int nzone
Number of domains (zones)
Definition: base_val.h:327
#define T_CL_COS_I
CL of odd cosines.
Definition: type_parite.h:232
#define T_CL_SIN_I
CL of odd sines.
Definition: type_parite.h:234
#define TRA_T
Translation en Theta, used for a bitwise shift (in hex)
Definition: type_parite.h:160
#define T_LEG_MP
fct. de Legendre associees avec m pair
Definition: type_parite.h:238
#define MAX_BASE
Nombre max. de bases differentes.
Definition: type_parite.h:144
#define T_LEG_PI
fct. de Legendre associees paires avec m impair
Definition: type_parite.h:224
#define T_COSSIN_SP
sin pair-cos impair alternes, sin pour m=0
Definition: type_parite.h:210
#define T_LEG
fct. de Legendre associees
Definition: type_parite.h:236
#define T_SIN_P
dev. sin seulement, harmoniques paires
Definition: type_parite.h:202
#define T_COSSIN_S
dev. cos-sin alternes, sin pour m=0
Definition: type_parite.h:194
#define T_COSSIN_SI
sin impair-cos pair alternes, sin pour m=0
Definition: type_parite.h:214
#define T_CL_SIN_P
CL of even sines.
Definition: type_parite.h:230
#define T_LEG_P
fct. de Legendre associees paires
Definition: type_parite.h:216
#define T_LEG_IP
fct. de Legendre associees impaires avec m pair
Definition: type_parite.h:222
#define T_COS_P
dev. cos seulement, harmoniques paires
Definition: type_parite.h:200
#define T_COSSIN_CI
cos impair-sin pair alternes, cos pour m=0
Definition: type_parite.h:212
#define T_CL_COS_P
CL of even cosines.
Definition: type_parite.h:228
#define T_LEG_MI
fct. de Legendre associees avec m impair
Definition: type_parite.h:240
#define MSQ_T
Extraction de l'info sur Theta.
Definition: type_parite.h:154
#define T_COSSIN_CP
cos pair-sin impair alternes, cos pour m=0
Definition: type_parite.h:208
#define T_LEG_II
fct. de Legendre associees impaires avec m impair
Definition: type_parite.h:226
#define T_LEG_I
fct. de Legendre associees impaires
Definition: type_parite.h:220
#define T_SIN_I
dev. sin seulement, harmoniques impaires
Definition: type_parite.h:206
#define T_COS
dev. cos seulement
Definition: type_parite.h:196
#define T_SIN
dev. sin seulement
Definition: type_parite.h:198
#define T_LEG_PP
fct. de Legendre associees paires avec m pair
Definition: type_parite.h:218
#define T_COS_I
dev. cos seulement, harmoniques impaires
Definition: type_parite.h:204
#define T_COSSIN_C
dev. cos-sin alternes, cos pour m=0
Definition: type_parite.h:192
Lorene prototypes.
Definition: app_hor.h:64