LORENE: base_val_manip.C Source File

00001 /*
00002  *   Copyright (c) 2001 Jerome Novak
00003  *
00004  *   This file is part of LORENE.
00005  *
00006  *   LORENE is free software; you can redistribute it and/or modify
00007  *   it under the terms of the GNU General Public License as published by
00008  *   the Free Software Foundation; either version 2 of the License, or
00009  *   (at your option) any later version.
00010  *
00011  *   LORENE is distributed in the hope that it will be useful,
00012  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  *   GNU General Public License for more details.
00015  *
00016  *   You should have received a copy of the GNU General Public License
00017  *   along with LORENE; if not, write to the Free Software
00018  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019  *
00020  */
00021 
00022 
00023 char base_val_manip_C[] = "$Header: /cvsroot/Lorene/C++/Source/Base_val/base_val_manip.C,v 1.9 2009/10/08 16:20:13 j_novak Exp $" ;
00024 
00025 /*
00026  * $Id: base_val_manip.C,v 1.9 2009/10/08 16:20:13 j_novak Exp $
00027  * $Log: base_val_manip.C,v $
00028  * Revision 1.9  2009/10/08 16:20:13  j_novak
00029  * Addition of new bases T_COS and T_SIN.
00030  *
00031  * Revision 1.8  2008/12/03 15:21:21  j_novak
00032  * New method mult_cost.
00033  *
00034  * Revision 1.7  2008/02/18 13:53:38  j_novak
00035  * Removal of special indentation instructions.
00036  *
00037  * Revision 1.6  2004/11/23 15:08:00  m_forot
00038  * Added the bases for the cases without any equatorial symmetry
00039  * (T_COSSIN_C, T_COSSIN_S, T_LEG, R_CHEBPI_P, R_CHEBPI_I).
00040  *
00041  * Revision 1.5  2004/01/27 14:31:26  j_novak
00042  * New method Base_val::mult_sint()
00043  *
00044  * Revision 1.4  2004/01/27 14:13:59  j_novak
00045  * Added method Base_val::mult_x()
00046  *
00047  * Revision 1.3  2003/09/16 08:54:09  j_novak
00048  * Addition of the T_LEG_II base (odd in theta, only for odd m) and the
00049  * transformation functions to and from the T_SIN_P base.
00050  *
00051  * Revision 1.2  2002/10/16 14:36:30  j_novak
00052  * Reorganization of #include instructions of standard C++, in order to
00053  * use experimental version 3 of gcc.
00054  *
00055  * Revision 1.1.1.1  2001/11/20 15:19:28  e_gourgoulhon
00056  * LORENE
00057  *
00058  * Revision 1.3  2001/10/12  15:06:50  novak
00059  * *** empty log message ***
00060  *
00061  * Revision 1.2  2001/10/12 15:05:14  novak
00062  * *** empty log message ***
00063  *
00064  * Revision 1.1  2001/10/12 14:57:24  novak
00065  * Initial revision
00066  *
00067  *
00068  * $Header: /cvsroot/Lorene/C++/Source/Base_val/base_val_manip.C,v 1.9 2009/10/08 16:20:13 j_novak Exp $
00069  *
00070  */
00071 
00072 // Headers C
00073 #include <stdlib.h>
00074 #include <assert.h>
00075 
00076 // Headers Lorene
00077 #include "headcpp.h"
00078 #include "type_parite.h"
00079 #include "base_val.h"
00080 
00081 void Base_val::dsdx() {
00082     
00083     switch(get_base_r(0)) {
00084     case R_CHEBP: 
00085         set_base_r(0, R_CHEBI) ;
00086         break ;
00087     case R_CHEBI: 
00088         set_base_r(0, R_CHEBP) ;
00089         break ;
00090     case R_CHEBPIM_P: 
00091         set_base_r(0, R_CHEBPIM_I) ;
00092         break ;
00093     case R_CHEBPIM_I: 
00094         set_base_r(0, R_CHEBPIM_P) ;
00095         break ;
00096     case R_CHEBPI_P: 
00097         set_base_r(0, R_CHEBPI_I) ;
00098         break ;
00099     case R_CHEBPI_I: 
00100         set_base_r(0, R_CHEBPI_P) ;
00101         break ;    
00102     default: 
00103         break ;
00104     }  
00105     return ;
00106 }
00107 
00108 void Base_val::sx() {
00109     
00110     switch(get_base_r(0)) {
00111     case R_CHEBP: 
00112         set_base_r(0, R_CHEBI) ;
00113         break ;
00114     case R_CHEBI: 
00115         set_base_r(0, R_CHEBP) ;
00116         break ;
00117     case R_CHEBPIM_P: 
00118         set_base_r(0, R_CHEBPIM_I) ;
00119         break ;
00120     case R_CHEBPIM_I: 
00121         set_base_r(0, R_CHEBPIM_P) ;
00122         break ;
00123     case R_CHEBPI_P: 
00124         set_base_r(0, R_CHEBPI_I) ;
00125         break ;
00126     case R_CHEBPI_I: 
00127         set_base_r(0, R_CHEBPI_P) ;
00128         break ;
00129     default: 
00130         break ;
00131     }  
00132     return ;
00133 }
00134 
00135 void Base_val::mult_x() {
00136     
00137     switch(get_base_r(0)) {
00138     case R_CHEBP: 
00139         set_base_r(0, R_CHEBI) ;
00140         break ;
00141     case R_CHEBI: 
00142         set_base_r(0, R_CHEBP) ;
00143         break ;
00144     case R_CHEBPIM_P: 
00145         set_base_r(0, R_CHEBPIM_I) ;
00146         break ;
00147     case R_CHEBPIM_I: 
00148         set_base_r(0, R_CHEBPIM_P) ;
00149         break ;
00150     case R_CHEBPI_P: 
00151         set_base_r(0, R_CHEBPI_I) ;
00152         break ;
00153     case R_CHEBPI_I: 
00154         set_base_r(0, R_CHEBPI_P) ;
00155         break ;
00156     default: 
00157         break ;
00158     }  
00159     return ;
00160 }
00161 
00162 void Base_val::dsdt() {
00163     
00164     switch(get_base_t(0)) {
00165     case T_COS_P:
00166         set_base_t(T_SIN_P) ;
00167         break ;
00168     case T_COS_I:
00169         set_base_t(T_SIN_I) ;
00170         break ;
00171     case T_SIN_P:
00172         set_base_t(T_COS_P) ;
00173         break ;
00174     case T_SIN_I:
00175         set_base_t(T_COS_I) ;
00176         break ;
00177     case T_COSSIN_CP:
00178         set_base_t(T_COSSIN_SP) ;
00179         break ;
00180     case T_COSSIN_SP:
00181         set_base_t(T_COSSIN_CP) ;
00182         break ;
00183     case T_COSSIN_CI:
00184         set_base_t(T_COSSIN_SI) ;
00185         break ;
00186     case T_COSSIN_SI:
00187         set_base_t(T_COSSIN_CI) ;
00188         break ;
00189     case T_COSSIN_C:
00190         set_base_t(T_COSSIN_S) ;
00191         break ;
00192     case T_COSSIN_S:
00193         set_base_t(T_COSSIN_C) ;
00194         break ;
00195     case T_COS:
00196         set_base_t(T_SIN) ;
00197         break ;
00198     case T_SIN:
00199         set_base_t(T_COS) ;
00200         break ;
00201     default: 
00202         cout << "Wrong base in Base_val::dsdt()!" << endl ;
00203         abort() ;
00204         exit(-1) ;
00205         break ;
00206     }  
00207     return ;
00208 }
00209 
00210 void Base_val::ssint() {
00211     
00212     switch(get_base_t(0)) {
00213     case T_COS_P:
00214         set_base_t(T_SIN_I) ;
00215         break ;
00216     case T_COS_I:
00217         set_base_t(T_SIN_P) ;
00218         break ;
00219     case T_SIN_P:
00220         set_base_t(T_COS_I) ;
00221         break ;
00222     case T_SIN_I:
00223         set_base_t(T_COS_P) ;
00224         break ;
00225     case T_COSSIN_CP:
00226         set_base_t(T_COSSIN_SI) ;
00227         break ;
00228     case T_COSSIN_SP:
00229         set_base_t(T_COSSIN_CI) ;
00230         break ;
00231     case T_COSSIN_CI:
00232         set_base_t(T_COSSIN_SP) ;
00233         break ;
00234     case T_COSSIN_SI:
00235         set_base_t(T_COSSIN_CP) ;
00236         break ;
00237     case T_COSSIN_C:
00238         set_base_t(T_COSSIN_S) ;
00239         break ;
00240     case T_COSSIN_S:
00241         set_base_t(T_COSSIN_C) ;
00242         break ;  
00243     case T_COS:
00244         set_base_t(T_SIN) ;
00245         break ;
00246     case T_SIN:
00247         set_base_t(T_COS) ;
00248         break ;  
00249     default: 
00250         cout << "Wrong base in Base_val::ssint()!" << endl ;
00251         abort() ;
00252         exit(-1) ;
00253         break ;
00254     }  
00255     return ;
00256 }
00257 
00258 void Base_val::mult_sint() {
00259     
00260     switch(get_base_t(0)) {
00261     case T_COS_P:
00262         set_base_t(T_SIN_I) ;
00263         break ;
00264     case T_COS_I:
00265         set_base_t(T_SIN_P) ;
00266         break ;
00267     case T_SIN_P:
00268         set_base_t(T_COS_I) ;
00269         break ;
00270     case T_SIN_I:
00271         set_base_t(T_COS_P) ;
00272         break ;
00273     case T_COSSIN_CP:
00274         set_base_t(T_COSSIN_SI) ;
00275         break ;
00276     case T_COSSIN_SP:
00277         set_base_t(T_COSSIN_CI) ;
00278         break ;
00279     case T_COSSIN_CI:
00280         set_base_t(T_COSSIN_SP) ;
00281         break ;
00282     case T_COSSIN_SI:
00283         set_base_t(T_COSSIN_CP) ;
00284         break ;
00285     case T_COSSIN_C:
00286         set_base_t(T_COSSIN_S) ;
00287         break ;
00288     case T_COSSIN_S:
00289         set_base_t(T_COSSIN_C) ;
00290         break ;   
00291     case T_COS:
00292         set_base_t(T_SIN) ;
00293         break ;
00294     case T_SIN:
00295         set_base_t(T_COS) ;
00296         break ;  
00297     default: 
00298         cout << "Wrong base in Base_val::mult_sint()!" << endl ;
00299         abort() ;
00300         exit(-1) ;
00301         break ;
00302     }  
00303     return ;
00304 }
00305 
00306 void Base_val::mult_cost() {
00307     
00308     switch(get_base_t(0)) {
00309     case T_COS_P:
00310         set_base_t(T_COS_I) ;
00311         break ;
00312     case T_COS_I:
00313         set_base_t(T_COS_P) ;
00314         break ;
00315     case T_SIN_P:
00316         set_base_t(T_SIN_I) ;
00317         break ;
00318     case T_SIN_I:
00319         set_base_t(T_SIN_P) ;
00320         break ;
00321     case T_COSSIN_CP:
00322         set_base_t(T_COSSIN_CI) ;
00323         break ;
00324     case T_COSSIN_SP:
00325         set_base_t(T_COSSIN_SI) ;
00326         break ;
00327     case T_COSSIN_CI:
00328         set_base_t(T_COSSIN_CP) ;
00329         break ;
00330     case T_COSSIN_SI:
00331         set_base_t(T_COSSIN_SP) ;
00332         break ;
00333     case T_COSSIN_C:
00334         set_base_t(T_COSSIN_C) ;
00335         break ;
00336     case T_COSSIN_S:
00337         set_base_t(T_COSSIN_S) ;
00338         break ;   
00339     case T_COS:
00340         set_base_t(T_COS) ;
00341         break ;
00342     case T_SIN:
00343         set_base_t(T_SIN) ;
00344         break ;  
00345     default: 
00346         cout << "Wrong base in Base_val::mult_cost()!" << endl ;
00347         abort() ;
00348         exit(-1) ;
00349         break ;
00350     }  
00351     return ;
00352 }
00353 
00354 void Base_val::ylm() {
00355     
00356     switch(get_base_t(0)) {
00357     case T_COS_P:
00358         set_base_t(T_LEG_PP) ;
00359         break ;
00360     case T_COS_I:
00361         set_base_t(T_LEG_IP) ;
00362         break ;
00363     case T_SIN_I:
00364         set_base_t(T_LEG_PI) ;
00365         break ;
00366     case T_SIN_P:
00367         set_base_t(T_LEG_II) ;
00368         break ;
00369     case T_COSSIN_CP:
00370         set_base_t(T_LEG_P) ;
00371         break ;
00372     case T_COSSIN_CI:
00373         set_base_t(T_LEG_I) ;
00374         break ;
00375     case T_COSSIN_C:
00376         set_base_t(T_LEG) ;
00377         break ;
00378     case T_COSSIN_S:
00379         set_base_t(T_LEG) ;
00380         break ;
00381     case T_COS:
00382         set_base_t(T_LEG_MP) ;
00383         break ;
00384     default: 
00385         cout << "Wrong base in Base_val::ylm()!" << endl ;
00386         abort() ;
00387         exit(-1) ;
00388         break ;
00389     }  
00390     return ;
00391 }