tbl_val.h
/*
* Definition of Lorene class Tbl_val
*
*/
/*
* Copyright (c) 2001 Jerome Novak
*
* 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
*
*/
#ifndef __TBL_VAL_H_
#define __TBL_VAL_H_
/*
* $Id: tbl_val.h,v 1.12 2014/10/13 08:52:37 j_novak Exp $
* $Log: tbl_val.h,v $
* Revision 1.12 2014/10/13 08:52:37 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.11 2014/10/06 15:09:40 j_novak
* Modified #include directives to use c++ syntax.
*
* Revision 1.10 2012/01/17 10:21:31 j_penner
* function added: Heaviside
*
* Revision 1.9 2010/04/14 11:45:24 j_novak
* Changed comments
*
* Revision 1.8 2007/11/02 15:45:56 j_novak
* Added an ugly method "append_array", which substitutes the argument to the
* main array t.
*
* Revision 1.7 2005/06/22 09:09:38 lm_lin
*
* Grid wedding: convert from the old C++ object "Cmp" to "Scalar".
*
* Revision 1.6 2004/11/26 17:02:18 j_novak
* Added a function giving a smooth transition to the atmosphere.
*
* Revision 1.5 2004/03/22 13:12:43 j_novak
* Modification of comments to use doxygen instead of doc++
*
* Revision 1.4 2002/11/13 11:22:57 j_novak
* Version "provisoire" de l'interpolation (sommation depuis la grille
* spectrale) aux interfaces de la grille de Valence.
*
* Revision 1.3 2002/11/12 10:03:53 j_novak
* The method "Tbl_val::get_gval" has been changed to "get_grid".
*
* Revision 1.2 2002/10/16 14:36:29 j_novak
* Reorganization of #include instructions of standard C++, in order to
* use experimental version 3 of gcc.
*
* Revision 1.1 2001/11/22 13:38:09 j_novak
* added Include files for Valencia objects: tbl_val.h and grille_val.h
*
*
* $Header: /cvsroot/Lorene/C++/Include/tbl_val.h,v 1.12 2014/10/13 08:52:37 j_novak Exp $
*
*/
// Fichiers includes
#include <cassert>
#include <cstdlib>
#include "grille_val.h"
#include "tensor.h"
namespace Lorene {
class Grille_val ;
class Tbl_val {
// Data :
// -----
private:
int etat ;
const Dim_tbl* dim ;
const Grille_val* gval ;
public:
double* t ;
double* tzri ;
double* txti ;
double* typi ;
// Constructors - Destructor
// -------------------------
public:
explicit Tbl_val(const Grille_val* ) ;
explicit Tbl_val(const Grille_val*, FILE* ) ;
Tbl_val(const Tbl_val& ) ;
~Tbl_val() ;
// Assignement
// -----------
void operator=(const Tbl_val& ) ;
void operator=(double ) ;
void operator=(int ) ;
// Memory management
// -----------------
private:
void del_t() ;
public:
void set_etat_nondef() ;
void set_etat_zero() ;
void set_etat_qcq() ;
void append_array(double* t_in) ;
void annule_hard() ;
// Access to individual elements
// -----------------------------
public:
double& set(int i) {
assert (etat == ETATQCQ) ;
assert( dim->ndim == 1 ) ;
int fant = gval->get_fantome() ;
assert( i >= - fant) ;
assert( i < dim->dim[0] + fant) ;
return t[i + fant] ;
} ;
double& set_zri(int i) {
assert (etat == ETATQCQ) ;
assert( dim->ndim == 1 ) ;
int fant = gval->get_fantome() ;
assert( i >= -fant ) ;
assert( i < dim->dim[0] + fant + 1) ;
return tzri[i+fant] ;
} ;
double operator()(int i) const {
assert(etat != ETATNONDEF) ;
assert( dim->ndim == 1 ) ;
int fant = gval->get_fantome() ;
assert( i >= -fant ) ;
assert( i < dim->dim[0] + fant ) ;
if (etat == ETATZERO) {
double zero = 0. ;
return zero ;
}
else return t[i+fant] ;
};
double get_zri(int i) const {
assert(etat != ETATNONDEF) ;
assert( dim->ndim == 1 ) ;
int fant = gval->get_fantome() ;
assert( i >= -fant ) ;
assert( i < dim->dim[0] + fant +1) ;
if (etat == ETATZERO) {
double zero = 0. ;
return zero ;
}
else return tzri[i+fant] ;
};
double& set(int j, int i) {
assert (etat == ETATQCQ) ;
assert( dim->ndim == 2 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0]+fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1]+fant) ) ;
return t[(dim->dim[0] +2*fant)* (j+fant) + i + fant] ;
};
double& set_xti(int j, int i) {
assert (etat == ETATQCQ) ;
assert( dim->ndim == 2 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0]+fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1]+fant+1) ) ;
return txti[(dim->dim[0] +2*fant)*(j+fant) + i + fant] ;
};
double& set_zri(int j, int i) {
assert (etat == ETATQCQ) ;
assert( dim->ndim == 2 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant+1) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
return tzri[(dim->dim[0] +2*fant+1)*(j+fant) + i + fant] ;
};
double operator()(int j, int i) const {
assert(etat != ETATNONDEF) ;
assert( dim->ndim == 2 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
if (etat == ETATZERO) {
double zero = 0. ;
return zero ;
}
else return t[(dim->dim[0] + 2*fant) *(j+fant) + i + fant] ;
};
double get_xti(int j, int i) const {
assert(etat != ETATNONDEF) ;
assert( dim->ndim == 2 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant + 1) ) ;
if (etat == ETATZERO) {
double zero = 0. ;
return zero ;
}
else return txti[(dim->dim[0] + 2*fant) *(j+fant) + i + fant] ;
};
double get_zri(int j, int i) const {
assert(etat != ETATNONDEF) ;
assert( dim->ndim == 2 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant + 1) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
if (etat == ETATZERO) {
double zero = 0. ;
return zero ;
}
else return tzri[(dim->dim[0] + 2*fant + 1) *(j+fant) + i + fant] ;
};
double& set(int k, int j, int i) {
assert (etat == ETATQCQ) ;
assert( dim->ndim == 3 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
return t[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant)*(k+fant) +
(dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
};
double& set_ypi(int k, int j, int i) {
assert (etat == ETATQCQ) ;
assert( dim->ndim == 3 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
assert( (k>=-fant) && (k<dim->dim[2] + fant + 1) ) ;
return typi[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant)*(k+fant) +
(dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
};
double& set_xti(int k, int j, int i) {
assert (etat == ETATQCQ) ;
assert( dim->ndim == 3 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant + 1) ) ;
assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
return txti[(dim->dim[1]+2*fant+1)*(dim->dim[0]+2*fant)*(k+fant) +
(dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
};
double& set_zri(int k, int j, int i) {
assert (etat == ETATQCQ) ;
assert( dim->ndim == 3 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant + 1) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
return tzri[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant+1)*(k+fant) +
(dim->dim[0]+2*fant+1)*(j+fant) + i +fant] ;
};
double operator()(int k, int j, int i) const {
assert(etat != ETATNONDEF) ;
assert( dim->ndim == 3 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
if (etat == ETATZERO) {
double zero = 0. ;
return zero ;
}
else return t[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant)*(k+fant)
+ (dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
};
double get_ypi(int k, int j, int i) const {
assert(etat != ETATNONDEF) ;
assert( dim->ndim == 3 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
assert( (k>=-fant) && (k<dim->dim[2] + fant + 1) ) ;
if (etat == ETATZERO) {
double zero = 0. ;
return zero ;
}
else return typi[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant)*(k+fant)
+ (dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
};
double get_xti(int k, int j, int i) const {
assert(etat != ETATNONDEF) ;
assert( dim->ndim == 3 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant + 1) ) ;
assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
if (etat == ETATZERO) {
double zero = 0. ;
return zero ;
}
else return txti[(dim->dim[1]+2*fant+1)*(dim->dim[0]+2*fant)*(k+fant)
+ (dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
};
double get_zri(int k, int j, int i) const {
assert(etat != ETATNONDEF) ;
assert( dim->ndim == 3 ) ;
int fant = gval->get_fantome() ;
assert( (i>=-fant) && (i<dim->dim[0] + fant + 1) ) ;
assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
if (etat == ETATZERO) {
double zero = 0. ;
return zero ;
}
else return tzri[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant+1)*(k+fant)
+ (dim->dim[0]+2*fant+1)*(j+fant) + i +fant] ;
};
// Extraction of information
// -------------------------
int get_etat() const { return etat ; };
int get_taille() const {
int resu = 1 ;
for (int i=0; i<dim->ndim; i++)
resu *= dim->dim[i] + 2*(gval->get_fantome()) ;
return resu ; };
int get_taille_i(int i) const {
assert (i<dim->ndim) ;
int resu = 1 ;
for (int j=0; j<dim->ndim; j++)
if (j!=i) {
resu *= dim->dim[j] + 2*gval->get_fantome() ;
}
else {
resu *= dim->dim[j] + 2*gval->get_fantome() + 1 ;
}
return resu ; };
int get_ndim() const { return dim->ndim ; };
int get_dim(int i) const {
assert( (i>=0) && (i<dim->ndim) ) ;
return dim->dim[i] ;
};
const Grille_val* get_grille() const { return gval ; } ;
// Outputs
// -------
public:
void sauve(FILE* ) const ;
void affiche_seuil(ostream& ostr, int precision = 4,
double threshold = 1.e-7) const ;
friend ostream& operator<<(ostream& , const Tbl_val& ) ;
// Member arithmetics
// ------------------
public:
void operator+=(const Tbl_val &) ;
void operator+=(double) ;
void operator-=(const Tbl_val &) ;
void operator-=(double) ;
void operator*=(const Tbl_val &) ;
void operator*=(double) ;
void operator/=(const Tbl_val &) ;
void operator/=(double) ;
Scalar to_spectral(const Map& map, const int lmax, const int lmin=0,
int type_inter = 2) const ;
void from_spectral(const Scalar& meudon, int lmax, int lmin=0,
bool interfr = false, bool interft = false) ;
void smooth_atmosphere(double atmosphere_thr) ;
} ;
Tbl_val operator+(const Tbl_val&) ;
Tbl_val operator-(const Tbl_val&) ;
Tbl_val operator+(const Tbl_val&, const Tbl_val&) ;
Tbl_val operator+(const Tbl_val&, double) ;
Tbl_val operator+(double, const Tbl_val&) ;
Tbl_val operator+(const Tbl_val&, int) ;
Tbl_val operator+(int, const Tbl_val&) ;
Tbl_val operator-(const Tbl_val&, const Tbl_val&) ;
Tbl_val operator-(const Tbl_val&, double) ;
Tbl_val operator-(double, const Tbl_val&) ;
Tbl_val operator-(const Tbl_val&, int) ;
Tbl_val operator-(int, const Tbl_val&) ;
Tbl_val operator*(const Tbl_val&, const Tbl_val&) ;
Tbl_val operator*(const Tbl_val&, double) ;
Tbl_val operator*(double, const Tbl_val&) ;
Tbl_val operator*(const Tbl_val&, int) ;
Tbl_val operator*(int, const Tbl_val&) ;
Tbl_val operator/(const Tbl_val&, const Tbl_val&) ;
Tbl_val operator/(const Tbl_val&, double) ;
Tbl_val operator/(double, const Tbl_val&) ;
Tbl_val operator/(const Tbl_val&, int) ;
Tbl_val operator/(int, const Tbl_val&) ;
Tbl_val sin(const Tbl_val& ) ;
Tbl_val cos(const Tbl_val& ) ;
Tbl_val tan(const Tbl_val& ) ;
Tbl_val asin(const Tbl_val& ) ;
Tbl_val acos(const Tbl_val& ) ;
Tbl_val atan(const Tbl_val& ) ;
Tbl_val exp(const Tbl_val& ) ;
Tbl_val Heaviside(const Tbl_val& ) ;
Tbl_val log(const Tbl_val& ) ;
Tbl_val log10(const Tbl_val& ) ;
Tbl_val sqrt(const Tbl_val& ) ;
Tbl_val racine_cubique (const Tbl_val&) ;
Tbl_val pow(const Tbl_val& , int ) ;
Tbl_val pow(const Tbl_val& , double ) ;
Tbl_val abs(const Tbl_val& ) ;
double max(const Tbl_val& ) ;
double min(const Tbl_val& ) ;
double norme(const Tbl_val& ) ;
double diffrel(const Tbl_val& a, const Tbl_val& b) ;
double diffrelmax(const Tbl_val& a, const Tbl_val& b) ;
}
#endif
Lorene::Dim_tbl
Storage of array dimensions.
Definition dim_tbl.h:99
Lorene::Grille_val
Base class for Godunov-type grids.
Definition grille_val.h:94
Lorene::Scalar
Tensor field of valence 0 (or component of a tensorial field).
Definition scalar.h:387
Lorene::Tbl_val
Finite-difference array intended to store field values.
Definition tbl_val.h:97
Lorene::Tbl_val::del_t
void del_t()
Logical destructor: dellocates the memory occupied by the array t and sets the logical state to ETATN...
Definition tbl_val.C:267
Lorene::Tbl_val::gval
const Grille_val * gval
The Grille_val (cartesian or spherical) on which the array is defined.
Definition tbl_val.h:110
Lorene::Tbl_val::operator=
void operator=(const Tbl_val &)
Assignment to another Tbl_val.
Definition tbl_val.C:163
Lorene::Tbl_val::operator/=
void operator/=(const Tbl_val &)
Division of this by a Tbl_val.
Definition arithm_tbl_val.C:855
Lorene::Tbl_val::set_zri
double & set_zri(int i)
Read/write of a particular element on the interface (index i ) (1D case).
Definition tbl_val.h:205
Lorene::Tbl_val::get_grille
const Grille_val * get_grille() const
Returns a pointer on the grid on which the Tbl_val is defined.
Definition tbl_val.h:491
Lorene::Tbl_val::set_etat_nondef
void set_etat_nondef()
Sets the logical state to ETATNONDEF (undefined).
Definition tbl_val.C:287
Lorene::Tbl_val::set
double & set(int k, int j, int i)
Read/write of a particular element (index (k,j,i) ) (3D case).
Definition tbl_val.h:327
Lorene::Tbl_val::get_xti
double get_xti(int k, int j, int i) const
Read-only of a particular element on the x (or ) interface (index (k,j,i) ) (3D case).
Definition tbl_val.h:422
Lorene::Tbl_val::get_ndim
int get_ndim() const
Gives the number of dimensions (ie dim->ndim ).
Definition tbl_val.h:482
Lorene::Tbl_val::get_zri
double get_zri(int j, int i) const
Read-only of a particular element on the z (or r) interface (index (j,i) ) (2D case).
Definition tbl_val.h:313
Lorene::Tbl_val::set_zri
double & set_zri(int k, int j, int i)
Read/write of a particular element on the z (or r) interface (index (k,j,i) ) (3D case).
Definition tbl_val.h:372
Lorene::Tbl_val::operator*=
void operator*=(const Tbl_val &)
Multiplication of this by a Tbl_val.
Definition arithm_tbl_val.C:791
Lorene::Tbl_val::from_spectral
void from_spectral(const Scalar &meudon, int lmax, int lmin=0, bool interfr=false, bool interft=false)
Interpolation from a Scalar to a Tbl_val (spectral summation).
Definition tbl_val_interp.C:306
Lorene::Tbl_val::get_dim
int get_dim(int i) const
Gives the i th dimension (ie dim->dim[i] , without hidden cells).
Definition tbl_val.h:485
Lorene::Tbl_val::dim
const Dim_tbl * dim
The Dim_tbl giving the dimensions and number of points (without the hidden cells).
Definition tbl_val.h:108
Lorene::Tbl_val::set_ypi
double & set_ypi(int k, int j, int i)
Read/write of a particular element on the y (or ) interface (index (k,j,i) ) (3D case).
Definition tbl_val.h:342
Lorene::Tbl_val::get_taille_i
int get_taille_i(int i) const
Gives the size of the interface arrays (including the hidden cells).
Definition tbl_val.h:469
Lorene::Tbl_val::set_xti
double & set_xti(int k, int j, int i)
Read/write of a particular element on the x (or ) interface (index (k,j,i) ) (3D case).
Definition tbl_val.h:357
Lorene::Tbl_val::txti
double * txti
The array at x (or ) interfaces.
Definition tbl_val.h:118
Lorene::Tbl_val::get_zri
double get_zri(int k, int j, int i) const
Read-only of a particular element on the z (or r) interface (index (k,j,i) ) (3D case).
Definition tbl_val.h:441
Lorene::Tbl_val::operator()
double operator()(int i) const
Read-only of a particular element (index i ) (1D case).
Definition tbl_val.h:215
Lorene::Tbl_val::tzri
double * tzri
The array at z (or r) interfaces.
Definition tbl_val.h:116
Lorene::Tbl_val::get_xti
double get_xti(int j, int i) const
Read-only of a particular element on the x (or ) interface (index (j,i) ) (2D case).
Definition tbl_val.h:296
Lorene::Tbl_val::annule_hard
void annule_hard()
Sets the Tbl_val to zero in a hard way.
Definition tbl_val.C:311
Lorene::Tbl_val::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition tbl_val.C:294
Lorene::Tbl_val::set
double & set(int i)
Read/write of a particular element (index i ) (1D case).
Definition tbl_val.h:195
Lorene::Tbl_val::operator()
double operator()(int k, int j, int i) const
Read-only of a particular element (index (k,j,i) ) (3D case).
Definition tbl_val.h:384
Lorene::Tbl_val::operator<<
friend ostream & operator<<(ostream &, const Tbl_val &)
Display.
Definition tbl_val.C:351
Lorene::Tbl_val::to_spectral
Scalar to_spectral(const Map &map, const int lmax, const int lmin=0, int type_inter=2) const
Interpolation from a Tbl_val to a Scalar .
Definition tbl_val_interp.C:94
Lorene::Tbl_val::set
double & set(int j, int i)
Read/write of a particular element (index (j,i) ) (2D case).
Definition tbl_val.h:243
Lorene::Tbl_val::t
double * t
The array of double at the nodes.
Definition tbl_val.h:114
Lorene::Tbl_val::get_etat
int get_etat() const
Gives the logical state.
Definition tbl_val.h:459
Lorene::Tbl_val::get_ypi
double get_ypi(int k, int j, int i) const
Read-only of a particular element on the y (or ) interface (index (k,j,i) ) (3D case).
Definition tbl_val.h:403
Lorene::Tbl_val::Tbl_val
Tbl_val(const Grille_val *)
Constructor from a 3D grid.
Definition tbl_val.C:83
Lorene::Tbl_val::sauve
void sauve(FILE *) const
Save in a file.
Definition tbl_val.C:249
Lorene::Tbl_val::set_zri
double & set_zri(int j, int i)
Read/write of a particular element on the z (or r) interface (index (j,i) ) (2D case).
Definition tbl_val.h:269
Lorene::Tbl_val::~Tbl_val
~Tbl_val()
Destructor.
Definition tbl_val.C:154
Lorene::Tbl_val::operator-=
void operator-=(const Tbl_val &)
Subtraction of a Tbl_val to this.
Definition arithm_tbl_val.C:683
Lorene::Tbl_val::set_xti
double & set_xti(int j, int i)
Read/write of a particular element on the x (or ) interface (index (j,i) ) (2D case).
Definition tbl_val.h:256
Lorene::Tbl_val::typi
double * typi
The array at y (or ) interfaces.
Definition tbl_val.h:120
Lorene::Tbl_val::operator+=
void operator+=(const Tbl_val &)
Addition of a Tbl_val to this.
Definition arithm_tbl_val.C:577
Lorene::Tbl_val::get_taille
int get_taille() const
Gives the size of the node array (including the hidden cells).
Definition tbl_val.h:462
Lorene::Tbl_val::operator()
double operator()(int j, int i) const
Read-only of a particular element (index (j,i) ) (2D case).
Definition tbl_val.h:279
Lorene::Tbl_val::get_zri
double get_zri(int i) const
Read-only of a particular element on the interface (index i ) (1D case).
Definition tbl_val.h:229
Lorene::Tbl_val::set_etat_zero
void set_etat_zero()
Sets the logical state to ETATZERO (zero).
Definition tbl_val.C:280
Lorene::Tbl_val::affiche_seuil
void affiche_seuil(ostream &ostr, int precision=4, double threshold=1.e-7) const
Prints only the values greater than a given threshold.
Definition tbl_val.C:429
Lorene::Tbl_val::etat
int etat
logical state (ETATNONDEF , ETATQCQ or ETATZERO ).
Definition tbl_val.h:103
Lorene::Tbl_val::append_array
void append_array(double *t_in)
Appends an array of doubles as the main array t of this (DO NOT use it, unless you REALLY know how it...
Definition tbl_val.C:336
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::atan
Cmp atan(const Cmp &)
Arctangent.
Definition cmp_math.C:195
Lorene::sqrt
Cmp sqrt(const Cmp &)
Square root.
Definition cmp_math.C:220
Lorene::log10
Cmp log10(const Cmp &)
Basis 10 logarithm.
Definition cmp_math.C:322
Lorene::operator/
Cmp operator/(const Cmp &, const Cmp &)
Cmp / Cmp.
Definition cmp_arithm.C:457
Lorene::exp
Cmp exp(const Cmp &)
Exponential.
Definition cmp_math.C:270
Lorene::sin
Cmp sin(const Cmp &)
Sine.
Definition cmp_math.C:69
Lorene::diffrel
Tbl diffrel(const Cmp &a, const Cmp &b)
Relative difference between two Cmp (norme version).
Definition cmp_math.C:504
Lorene::norme
Tbl norme(const Cmp &)
Sums of the absolute values of all the values of the Cmp in each domain.
Definition cmp_math.C:481
Lorene::acos
Cmp acos(const Cmp &)
Arccosine.
Definition cmp_math.C:169
Lorene::asin
Cmp asin(const Cmp &)
Arcsine.
Definition cmp_math.C:144
Lorene::racine_cubique
Cmp racine_cubique(const Cmp &)
Cube root.
Definition cmp_math.C:245
Lorene::min
Tbl min(const Cmp &)
Minimum values of a Cmp in each domain.
Definition cmp_math.C:458
Lorene::max
Tbl max(const Cmp &)
Maximum values of a Cmp in each domain.
Definition cmp_math.C:435
Lorene::pow
Cmp pow(const Cmp &, int)
Power .
Definition cmp_math.C:348
Lorene::cos
Cmp cos(const Cmp &)
Cosine.
Definition cmp_math.C:94
Lorene::abs
Cmp abs(const Cmp &)
Absolute value.
Definition cmp_math.C:410
Lorene::diffrelmax
Tbl diffrelmax(const Cmp &a, const Cmp &b)
Relative difference between two Cmp (max version).
Definition cmp_math.C:539
Lorene::operator+
Cmp operator+(const Cmp &)
Definition cmp_arithm.C:104
Lorene::tan
Cmp tan(const Cmp &)
Tangent.
Definition cmp_math.C:120
Lorene::log
Cmp log(const Cmp &)
Neperian logarithm.
Definition cmp_math.C:296
Lorene::Heaviside
Mtbl Heaviside(const Mtbl &)
Heaviside function.
Definition mtbl_math.C:317
Lorene
Lorene prototypes.
Definition app_hor.h:64
Lorene::Map
Map(const Mg3d &)
Constructor from a multi-domain 3D grid.
Definition map.C:139