cmp_arithm.C
/*
* Arithmetical operations for class Cmp
*
*/
/*
* Copyright (c) 1999-2000 Jean-Alain Marck
* Copyright (c) 1999-2001 Eric Gourgoulhon
* Copyright (c) 1999-2001 Philippe Grandclement
*
* This file is part of LORENE.
*
* LORENE is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* LORENE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LORENE; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
char cmp_arithm_C[] = "$Header: /cvsroot/Lorene/C++/Source/Cmp/cmp_arithm.C,v 1.5 2014/10/13 08:52:47 j_novak Exp $" ;
/*
* $Id: cmp_arithm.C,v 1.5 2014/10/13 08:52:47 j_novak Exp $
* $Log: cmp_arithm.C,v $
* Revision 1.5 2014/10/13 08:52:47 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.4 2014/10/06 15:13:03 j_novak
* Modified #include directives to use c++ syntax.
*
* Revision 1.3 2003/06/20 13:59:59 f_limousin
* L'assert pour le mapping est realise a partir du mapping lui meme et non a partir du pointeur sur le mapping.
*
* Revision 1.2 2002/10/16 14:36:34 j_novak
* Reorganization of #include instructions of standard C++, in order to
* use experimental version 3 of gcc.
*
* Revision 1.1.1.1 2001/11/20 15:19:27 e_gourgoulhon
* LORENE
*
* Revision 2.11 2001/05/26 15:07:47 eric
* Ajout de operator% : multiplication de deux Cmp avec desaliasage
*
* Revision 2.10 2000/02/15 13:39:57 phil
* correction -= et +=
*
* Revision 2.9 2000/01/28 16:34:57 eric
* Utilisation des nouvelles fonctions Cmp::check_dzpuis et Cmp::dz_nonzero
* dans les tests sur dzpuis.
*
* Revision 2.8 1999/12/10 16:32:52 eric
* Dans l'arithmetique membre (+=, -=, *=), on n'appelle desormais
* del_deriv() que tout a la fin.
*
* Revision 2.7 1999/11/26 14:23:38 eric
* Ajout du membre dzpuis.
*
* Revision 2.6 1999/11/12 17:08:35 eric
* Ajout de la partie manquante de l'arithmetique.
*
* Revision 2.5 1999/10/28 13:23:43 phil
* Deverouillage des ETATNONDEF
*
* Revision 2.4 1999/10/27 08:45:21 eric
* ntroduction du membre Valeur va.
*
* Revision 2.3 1999/10/22 08:14:58 eric
* La fonction annule() est rebaptisee annule_hard().
*
* Revision 2.2 1999/09/14 17:19:44 phil
* ajout de Cmp operator* (double, const Cmp&)
*
* Revision 2.1 1999/03/03 11:13:56 hyc
* *** empty log message ***
*
*
* $Header: /cvsroot/Lorene/C++/Source/Cmp/cmp_arithm.C,v 1.5 2014/10/13 08:52:47 j_novak Exp $
*
*/
// headers C
#include <cassert>
#include <cstdlib>
// headers Lorene
#include "cmp.h"
#include "type_parite.h"
//********************//
// OPERATEURS UNAIRES //
//********************//
namespace Lorene {
Cmp operator+(const Cmp & ci) {
return ci ;
}
Cmp operator-(const Cmp & ci) {
// Cas particulier
if ((ci.get_etat() == ETATZERO) || (ci.get_etat() == ETATNONDEF)) {
return ci ;
}
// Cas general
assert(ci.get_etat() == ETATQCQ) ; // sinon...
Cmp r(ci.get_mp()) ; // Cmp resultat
r.set_etat_qcq() ;
r.va = - ci.va ;
r.set_dzpuis( ci.get_dzpuis() ) ;
// Termine
return r ;
}
//**********//
// ADDITION //
//**********//
// Cmp + Cmp
// ---------
Cmp operator+(const Cmp & c1, const Cmp & c2) {
if (c1.get_etat() == ETATNONDEF)
return c1 ;
if (c2.get_etat() == ETATNONDEF)
return c2 ;
assert(c1.get_mp() == c2.get_mp()) ;
// Cas particuliers
if (c1.get_etat() == ETATZERO) {
return c2 ;
}
if (c2.get_etat() == ETATZERO) {
return c1 ;
}
assert(c1.get_etat() == ETATQCQ) ; // sinon...
assert(c2.get_etat() == ETATQCQ) ; // sinon...
// Cas general
if ( c1.dz_nonzero() && c2.dz_nonzero() ) {
if ( c1.get_dzpuis() != c2.get_dzpuis() ) {
cout << "Operation Cmp + Cmp forbidden in the external " << endl;
cout << " compactified domain ! " << endl ;
abort() ;
}
}
Cmp r(c1) ; // Le resultat
r.va += c2.va ;
if (c1.dz_nonzero()) {
r.set_dzpuis( c1.get_dzpuis() ) ;
}
else{
r.set_dzpuis( c2.get_dzpuis() ) ;
}
// Termine
return r ;
}
// Cmp + double
// ------------
Cmp operator+(const Cmp& t1, double x)
{
// Protections
assert(t1.get_etat() != ETATNONDEF) ;
// Cas particuliers
if (x == double(0)) {
return t1 ;
}
assert( t1.check_dzpuis(0) ) ;
Cmp resu(t1) ;
if (t1.get_etat() == ETATZERO) {
resu = x ;
}
else{
assert(resu.get_etat() == ETATQCQ) ; // sinon ...
resu.va = resu.va + x ;
}
resu.set_dzpuis(0) ;
return resu ;
}
// double + Cmp
// ------------
Cmp operator+(double x, const Cmp& t1)
{
return t1 + x ;
}
// Cmp + int
// ---------
Cmp operator+(const Cmp& t1, int m)
{
return t1 + double(m) ;
}
// int + Cmp
// ---------
Cmp operator+(int m, const Cmp& t1)
{
return t1 + double(m) ;
}
//**************//
// SOUSTRACTION //
//**************//
// Cmp - Cmp
// ---------
Cmp operator-(const Cmp & c1, const Cmp & c2) {
if (c1.get_etat() == ETATNONDEF)
return c1 ;
if (c2.get_etat() == ETATNONDEF)
return c2 ;
assert(c1.get_mp() == c2.get_mp()) ;
// Cas particuliers
if (c1.get_etat() == ETATZERO) {
return -c2 ;
}
if (c2.get_etat() == ETATZERO) {
return c1 ;
}
assert(c1.get_etat() == ETATQCQ) ; // sinon...
assert(c2.get_etat() == ETATQCQ) ; // sinon...
// Cas general
if ( c1.dz_nonzero() && c2.dz_nonzero() ) {
if ( c1.get_dzpuis() != c2.get_dzpuis() ) {
cout << "Operation Cmp - Cmp forbidden in the external " << endl;
cout << " compactified domain ! " << endl ;
abort() ;
}
}
Cmp r(c1) ; // Le resultat
r.va -= c2.va ;
if (c1.dz_nonzero()) {
r.set_dzpuis( c1.get_dzpuis() ) ;
}
else{
r.set_dzpuis( c2.get_dzpuis() ) ;
}
// Termine
return r ;
}
// Cmp - double
// ------------
Cmp operator-(const Cmp& t1, double x)
{
// Protections
assert(t1.get_etat() != ETATNONDEF) ;
// Cas particuliers
if (x == double(0)) {
return t1 ;
}
assert( t1.check_dzpuis(0) ) ;
Cmp resu(t1) ;
if (t1.get_etat() == ETATZERO) {
resu = - x ;
}
else{
assert(resu.get_etat() == ETATQCQ) ; // sinon ...
resu.va = resu.va - x ;
}
resu.set_dzpuis(0) ;
return resu ;
}
// double - Cmp
// ------------
Cmp operator-(double x, const Cmp& t1)
{
return - (t1 - x) ;
}
// Cmp - int
// ---------
Cmp operator-(const Cmp& t1, int m)
{
return t1 - double(m) ;
}
// int - Cmp
// ---------
Cmp operator-(int m, const Cmp& t1)
{
return double(m) - t1 ;
}
//****************//
// MULTIPLICATION //
//****************//
// Cmp * Cmp
// ---------
Cmp operator*(const Cmp& c1, const Cmp& c2) {
// Cas particuliers
if ((c1.get_etat() == ETATZERO) || (c1.get_etat() == ETATNONDEF)){
return c1 ;
}
if ((c2.get_etat() == ETATZERO)|| (c2.get_etat() == ETATNONDEF)) {
return c2 ;
}
assert(c1.get_etat() == ETATQCQ) ; // sinon...
assert(c2.get_etat() == ETATQCQ) ; // sinon...
// Protection
assert(*(c1.get_mp()) == *(c2.get_mp())) ;
// Cas general
Cmp r(c1) ; // Le resultat
r.va *= c2.va ;
r.set_dzpuis( c1.get_dzpuis() + c2.get_dzpuis() ) ;
// Termine
return r ;
}
// Cmp % Cmp (multiplication with desaliasing)
// -------------------------------------------
Cmp operator%(const Cmp& c1, const Cmp& c2) {
// Cas particuliers
if ((c1.get_etat() == ETATZERO) || (c1.get_etat() == ETATNONDEF)){
return c1 ;
}
if ((c2.get_etat() == ETATZERO)|| (c2.get_etat() == ETATNONDEF)) {
return c2 ;
}
assert(c1.get_etat() == ETATQCQ) ; // sinon...
assert(c2.get_etat() == ETATQCQ) ; // sinon...
// Protection
assert(c1.get_mp() == c2.get_mp()) ;
// Cas general
Cmp r( c1.get_mp() ) ; // Le resultat
r.set_etat_qcq() ;
r.va = c1.va % c2.va ;
r.set_dzpuis( c1.get_dzpuis() + c2.get_dzpuis() ) ;
// Termine
return r ;
}
// double * Cmp
// ------------
Cmp operator*(double a, const Cmp& c1) {
// Cas particuliers
if ((c1.get_etat() == ETATZERO) || (c1.get_etat() == ETATNONDEF)) {
return c1 ;
}
assert(c1.get_etat() == ETATQCQ) ; // sinon...
// Cas general
Cmp r(c1.get_mp()) ;
r.set_dzpuis( c1.get_dzpuis() ) ;
if ( a == double(0) ) {
r.set_etat_zero() ;
}
else {
r.set_etat_qcq() ;
r.va = a * c1.va ;
}
// Termine
return r ;
}
// Cmp * double
// ------------
Cmp operator*(const Cmp& t1, double x)
{
return x * t1 ;
}
// Cmp * int
// ---------
Cmp operator*(const Cmp& t1, int m)
{
return t1 * double(m) ;
}
// int * Cmp
// ---------
Cmp operator*(int m, const Cmp& t1)
{
return double(m) * t1 ;
}
//**********//
// DIVISION //
//**********//
// Cmp / Cmp
// ---------
Cmp operator/(const Cmp& c1, const Cmp& c2) {
// Protections
assert(c1.get_etat() != ETATNONDEF) ;
assert(c2.get_etat() != ETATNONDEF) ;
assert(c1.get_mp() == c2.get_mp()) ;
// Cas particuliers
if (c2.get_etat() == ETATZERO) {
cout << "Division by 0 in Cmp / Cmp !" << endl ;
abort() ;
}
if (c1.get_etat() == ETATZERO) {
return c1 ;
}
// Cas general
assert(c1.get_etat() == ETATQCQ) ; // sinon...
assert(c2.get_etat() == ETATQCQ) ; // sinon...
Cmp r(c1.get_mp()) ; // Le resultat
r.set_etat_qcq() ;
r.va = c1.va / c2.va ;
r.set_dzpuis( c1.get_dzpuis() - c2.get_dzpuis() ) ;
// Termine
return r ;
}
// Cmp / double
// -------------
Cmp operator/(const Cmp& c1, double x) {
if (c1.get_etat() == ETATNONDEF)
return c1 ;
// Cas particuliers
if ( x == double(0) ) {
cout << "Division by 0 in Cmp / double !" << endl ;
abort() ;
}
if (c1.get_etat() == ETATZERO) {
return c1 ;
}
assert(c1.get_etat() == ETATQCQ) ; // sinon...
Cmp r(c1.get_mp()) ; // Le resultat
r.set_etat_qcq() ;
r.va = c1.va / x ;
r.set_dzpuis( c1.get_dzpuis() ) ;
// Termine
return r ;
}
// double / Cmp
// ------------
Cmp operator/(double x, const Cmp& c2) {
if (c2.get_etat() == ETATNONDEF)
return c2 ;
if (c2.get_etat() == ETATZERO) {
cout << "Division by 0 in Cmp / Cmp !" << endl ;
abort() ;
}
assert(c2.get_etat() == ETATQCQ) ; // sinon...
Cmp r(c2.get_mp()) ; // Le resultat
r.set_dzpuis( - c2.get_dzpuis() ) ;
if ( x == double(0) ) {
r.set_etat_zero() ;
}
else {
r.set_etat_qcq() ;
r.va = x / c2.va ;
}
// Termine
return r ;
}
// Cmp / int
// ---------
Cmp operator/(const Cmp& c1, int m) {
return c1 / double(m) ;
}
// int / Cmp
// ---------
Cmp operator/(int m, const Cmp& c2) {
return double(m) / c2 ;
}
//*******************//
// operateurs +=,... //
//*******************//
//---------
// += Cmp
//---------
void Cmp::operator+=(const Cmp & ci) {
// Protection
assert(mp == ci.get_mp()) ; // meme mapping
if (etat == ETATNONDEF)
return ;
// Cas particulier
if (ci.get_etat() == ETATZERO) {
return ;
}
if (ci.get_etat() == ETATNONDEF) {
set_etat_nondef() ;
return ;
}
// Cas general
if ( dz_nonzero() && ci.dz_nonzero() ) {
if ( dzpuis != ci.dzpuis ) {
cout << "Operation += Cmp forbidden in the external " << endl;
cout << " compactified domain ! " << endl ;
abort() ;
}
}
if (etat == ETATZERO) {
(*this) = ci ;
}
else {
va += ci.va ;
if( ci.dz_nonzero() ) {
set_dzpuis(ci.dzpuis) ;
}
}
// Menage (a ne faire qu'a la fin seulement)
del_deriv() ;
}
//---------
// -= Cmp
//---------
void Cmp::operator-=(const Cmp & ci) {
// Protection
assert(mp == ci.get_mp()) ; // meme mapping
if (etat == ETATNONDEF)
return ;
// Cas particulier
if (ci.get_etat() == ETATZERO) {
return ;
}
if (ci.get_etat() == ETATNONDEF) {
set_etat_nondef() ;
return ;
}
// Cas general
if ( dz_nonzero() && ci.dz_nonzero() ) {
if ( dzpuis != ci.dzpuis ) {
cout << "Operation -= Cmp forbidden in the external " << endl;
cout << " compactified domain ! " << endl ;
abort() ;
}
}
if (etat == ETATZERO) {
(*this) = -ci ;
}
else {
va -= ci.va ;
if( ci.dz_nonzero() ) {
set_dzpuis(ci.dzpuis) ;
}
}
// Menage (a ne faire qu'a la fin seulement)
del_deriv() ;
}
//---------
// *= Cmp
//---------
void Cmp::operator*=(const Cmp & ci) {
// Protection
assert(mp == ci.get_mp()) ; // meme mapping
if (etat == ETATNONDEF)
return ;
// Cas particulier
if (ci.get_etat() == ETATZERO) {
set_etat_zero() ;
return ;
}
if (etat == ETATZERO) {
return ;
}
if (ci.get_etat() == ETATNONDEF) {
set_etat_nondef() ;
return ;
}
// Cas general
assert(etat == ETATQCQ) ; // sinon....
va *= ci.va ;
dzpuis += ci.dzpuis ;
// Menage (a ne faire qu'a la fin seulement)
del_deriv() ;
}
}
Lorene::Cmp
Component of a tensorial field *** DEPRECATED : use class Scalar instead ***.
Definition cmp.h:446
Lorene::Cmp::mp
const Map * mp
Reference mapping.
Definition cmp.h:451
Lorene::Cmp::Cmp
Cmp(const Map &map)
Constructor from mapping.
Definition cmp.C:208
Lorene::Cmp::dzpuis
int dzpuis
Power of r by which the quantity represented by this must be divided in the external compactified z...
Definition cmp.h:461
Lorene::Cmp::get_etat
int get_etat() const
Returns the logical state.
Definition cmp.h:899
Lorene::Cmp::va
Valeur va
The numerical value of the Cmp.
Definition cmp.h:464
Lorene::Cmp::etat
int etat
Logical state (ETATNONDEF , ETATQCQ or ETATZERO ).
Definition cmp.h:454
Lorene::Cmp::get_dzpuis
int get_dzpuis() const
Returns dzpuis.
Definition cmp.h:903
Lorene::Cmp::operator+=
void operator+=(const Cmp &)
+= Cmp
Definition cmp_arithm.C:575
Lorene::Cmp::dz_nonzero
bool dz_nonzero() const
Returns true if the last domain is compactified and *this is not zero in this domain.
Definition cmp.C:660
Lorene::Cmp::set_etat_zero
void set_etat_zero()
Sets the logical state to ETATZERO (zero).
Definition cmp.C:289
Lorene::Cmp::operator*=
void operator*=(const Cmp &)
*= Cmp
Definition cmp_arithm.C:668
Lorene::Cmp::set_dzpuis
void set_dzpuis(int)
Set a value to dzpuis.
Definition cmp.C:654
Lorene::Cmp::check_dzpuis
bool check_dzpuis(int dzi) const
Returns false if the last domain is compactified and *this is not zero in this domain and dzpuis is n...
Definition cmp.C:715
Lorene::Cmp::get_mp
const Map * get_mp() const
Returns the mapping.
Definition cmp.h:901
Lorene::Cmp::del_deriv
void del_deriv()
Logical destructor of the derivatives.
Definition cmp.C:265
Lorene::Cmp::operator-=
void operator-=(const Cmp &)
-= Cmp
Definition cmp_arithm.C:623
Lorene::Cmp::set_etat_nondef
void set_etat_nondef()
Sets the logical state to ETATNONDEF (undefined).
Definition cmp.C:297
Lorene::operator*
Base_val operator*(const Base_val &, const Base_val &)
This operator is used when calling multiplication or division of Valeur .
Definition base_val_mult.C:102
Lorene::operator-
Cmp operator-(const Cmp &)
- Cmp
Definition cmp_arithm.C:108
Lorene::operator/
Cmp operator/(const Cmp &, const Cmp &)
Cmp / Cmp.
Definition cmp_arithm.C:457
Lorene::operator%
Cmp operator%(const Cmp &, const Cmp &)
Cmp * Cmp with desaliasing.
Definition cmp_arithm.C:364
Lorene::operator+
Cmp operator+(const Cmp &)
Definition cmp_arithm.C:104
Lorene
Lorene prototypes.
Definition app_hor.h:64
Lorene::x
Coord x
x coordinate centered on the grid
Definition map.h:726
Lorene::r
Coord r
r coordinate centered on the grid
Definition map.h:718