diff.h
/*
* Definition of Lorene class Diff.
*
*/
/*
* Copyright (c) 2005 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 version 2
* as published by the Free Software Foundation.
*
* 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 __DIFF_H_
#define __DIFF_H_
/*
* $Id: diff.h,v 1.4 2014/10/13 08:52:33 j_novak Exp $
* $Log: diff.h,v $
* Revision 1.4 2014/10/13 08:52:33 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.3 2006/04/10 15:20:51 j_novak
* Operators dsdx and sx can now be used in the nucleus.
*
* Revision 1.2 2005/01/11 15:16:58 j_novak
* More Diff operators.
*
* Revision 1.1 2005/01/10 16:39:21 j_novak
* New class for 1D mono-domain differential operators.
*
*
*
* $Header: /cvsroot/Lorene/C++/Include/diff.h,v 1.4 2014/10/13 08:52:33 j_novak Exp $
*
*/
#include "type_parite.h"
#include "matrice.h"
namespace Lorene {
class Diff {
// Data :
// -----
public:
static const int max_points = 50 ;
protected:
int base ;
int npoints ;
// Constructors - Destructor
// -------------------------
protected:
Diff(int base_r, int nr) ;
Diff(const Diff& ) ;
virtual ~Diff() ;
// Mutators / assignment
// ---------------------
protected:
void operator=(const Diff&) ;
// Accessors
// ---------
public:
int get_base() const {return base ;} ;
int get_npoints() const { return npoints ;} ;
operator Matrice() const { return get_matrice() ; }
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const = 0 ;
// Outputs
// -------
public:
friend ostream& operator<<(ostream& , const Diff& ) ;
protected:
virtual ostream& operator>>(ostream&) const = 0 ;
};
class Diff_dsdx : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_dsdx(int base_r, int nr) ;
Diff_dsdx(const Diff_dsdx& ) ;
virtual ~Diff_dsdx() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_dsdx&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_dsdx2 : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_dsdx2(int base_r, int nr) ;
Diff_dsdx2(const Diff_dsdx2& ) ;
virtual ~Diff_dsdx2() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_dsdx2&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_id : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_id(int base_r, int nr) ;
Diff_id(const Diff_id& ) ;
virtual ~Diff_id() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_id&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_mx : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_mx(int base_r, int nr) ;
Diff_mx(const Diff_mx& ) ;
virtual ~Diff_mx() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_mx&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_mx2 : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_mx2(int base_r, int nr) ;
Diff_mx2(const Diff_mx2& ) ;
virtual ~Diff_mx2() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_mx2&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_sx : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_sx(int base_r, int nr) ;
Diff_sx(const Diff_sx& ) ;
virtual ~Diff_sx() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_sx&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_sx2 : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_sx2(int base_r, int nr) ;
Diff_sx2(const Diff_sx2& ) ;
virtual ~Diff_sx2() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_sx2&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_xdsdx : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_xdsdx(int base_r, int nr) ;
Diff_xdsdx(const Diff_xdsdx& ) ;
virtual ~Diff_xdsdx() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_xdsdx&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_sxdsdx : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_sxdsdx(int base_r, int nr) ;
Diff_sxdsdx(const Diff_sxdsdx& ) ;
virtual ~Diff_sxdsdx() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_sxdsdx&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_x2dsdx2 : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_x2dsdx2(int base_r, int nr) ;
Diff_x2dsdx2(const Diff_x2dsdx2& ) ;
virtual ~Diff_x2dsdx2() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_x2dsdx2&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_xdsdx2 : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_xdsdx2(int base_r, int nr) ;
Diff_xdsdx2(const Diff_xdsdx2& ) ;
virtual ~Diff_xdsdx2() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_xdsdx2&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_x2dsdx : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_x2dsdx(int base_r, int nr) ;
Diff_x2dsdx(const Diff_x2dsdx& ) ;
virtual ~Diff_x2dsdx() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_x2dsdx&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_x3dsdx : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_x3dsdx(int base_r, int nr) ;
Diff_x3dsdx(const Diff_x3dsdx& ) ;
virtual ~Diff_x3dsdx() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_x3dsdx&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_x3dsdx2 : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_x3dsdx2(int base_r, int nr) ;
Diff_x3dsdx2(const Diff_x3dsdx2& ) ;
virtual ~Diff_x3dsdx2() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_x3dsdx2&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
class Diff_x4dsdx2 : public Diff {
// Constructors - Destructor
// -------------------------
public:
Diff_x4dsdx2(int base_r, int nr) ;
Diff_x4dsdx2(const Diff_x4dsdx2& ) ;
virtual ~Diff_x4dsdx2() ;
private:
void initialize() ;
// Mutators / assignment
// ---------------------
public:
void operator=(const Diff_x4dsdx2&) ;
// Computational routines
//-----------------------
public:
virtual const Matrice& get_matrice() const ;
// Outputs
// -------
protected:
virtual ostream& operator>>(ostream&) const ;
};
}
#endif
Lorene::Diff_dsdx2::operator=
void operator=(const Diff_dsdx2 &)
Assignment to another Diff_dsdx2.
Definition diff_dsdx2.C:85
Lorene::Diff_dsdx2::initialize
void initialize()
Initializes arrays.
Definition diff_dsdx2.C:73
Lorene::Diff_dsdx2::Diff_dsdx2
Diff_dsdx2(int base_r, int nr)
Standard constructor.
Definition diff_dsdx2.C:63
Lorene::Diff_dsdx2::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_dsdx2.C:129
Lorene::Diff_dsdx2::~Diff_dsdx2
virtual ~Diff_dsdx2()
Destructor.
Definition diff_dsdx2.C:71
Lorene::Diff_dsdx2::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_dsdx2.C:91
Lorene::Diff_dsdx::Diff_dsdx
Diff_dsdx(int base_r, int nr)
Standard constructor, the base is that of the functions the operator is acting on (starting base).
Definition diff_dsdx.C:66
Lorene::Diff_dsdx::~Diff_dsdx
virtual ~Diff_dsdx()
Destructor.
Definition diff_dsdx.C:74
Lorene::Diff_dsdx::initialize
void initialize()
Initializes arrays.
Definition diff_dsdx.C:76
Lorene::Diff_dsdx::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_dsdx.C:94
Lorene::Diff_dsdx::operator=
void operator=(const Diff_dsdx &)
Assignment to another Diff_dsdx.
Definition diff_dsdx.C:88
Lorene::Diff_dsdx::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_dsdx.C:131
Lorene::Diff_id::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_id.C:91
Lorene::Diff_id::~Diff_id
virtual ~Diff_id()
Destructor.
Definition diff_id.C:71
Lorene::Diff_id::initialize
void initialize()
Initializes arrays.
Definition diff_id.C:73
Lorene::Diff_id::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_id.C:123
Lorene::Diff_id::Diff_id
Diff_id(int base_r, int nr)
Standard constructor.
Definition diff_id.C:63
Lorene::Diff_id::operator=
void operator=(const Diff_id &)
Assignment to another Diff_id.
Definition diff_id.C:85
Lorene::Diff_mx2::~Diff_mx2
virtual ~Diff_mx2()
Destructor.
Definition diff_mx2.C:75
Lorene::Diff_mx2::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_mx2.C:95
Lorene::Diff_mx2::initialize
void initialize()
Initializes arrays.
Definition diff_mx2.C:77
Lorene::Diff_mx2::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_mx2.C:147
Lorene::Diff_mx2::operator=
void operator=(const Diff_mx2 &)
Assignment to another Diff_mx2.
Definition diff_mx2.C:89
Lorene::Diff_mx2::Diff_mx2
Diff_mx2(int base_r, int nr)
Standard constructor.
Definition diff_mx2.C:67
Lorene::Diff_mx::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_mx.C:96
Lorene::Diff_mx::~Diff_mx
virtual ~Diff_mx()
Destructor.
Definition diff_mx.C:76
Lorene::Diff_mx::initialize
void initialize()
Initializes arrays.
Definition diff_mx.C:78
Lorene::Diff_mx::operator=
void operator=(const Diff_mx &)
Assignment to another Diff_mx.
Definition diff_mx.C:90
Lorene::Diff_mx::Diff_mx
Diff_mx(int base_r, int nr)
Standard constructor.
Definition diff_mx.C:66
Lorene::Diff_mx::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_mx.C:147
Lorene::Diff_sx2::Diff_sx2
Diff_sx2(int base_r, int nr)
Standard constructor.
Definition diff_sx2.C:68
Lorene::Diff_sx2::initialize
void initialize()
Initializes arrays.
Definition diff_sx2.C:80
Lorene::Diff_sx2::operator=
void operator=(const Diff_sx2 &)
Assignment to another Diff_sx2.
Definition diff_sx2.C:92
Lorene::Diff_sx2::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_sx2.C:98
Lorene::Diff_sx2::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_sx2.C:143
Lorene::Diff_sx2::~Diff_sx2
virtual ~Diff_sx2()
Destructor.
Definition diff_sx2.C:78
Lorene::Diff_sx::Diff_sx
Diff_sx(int base_r, int nr)
Standard constructor.
Definition diff_sx.C:70
Lorene::Diff_sx::~Diff_sx
virtual ~Diff_sx()
Destructor.
Definition diff_sx.C:80
Lorene::Diff_sx::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_sx.C:144
Lorene::Diff_sx::initialize
void initialize()
Initializes arrays.
Definition diff_sx.C:82
Lorene::Diff_sx::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_sx.C:100
Lorene::Diff_sx::operator=
void operator=(const Diff_sx &)
Assignment to another Diff_sx.
Definition diff_sx.C:94
Lorene::Diff_sxdsdx::~Diff_sxdsdx
virtual ~Diff_sxdsdx()
Destructor.
Definition diff_sxdsdx.C:77
Lorene::Diff_sxdsdx::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_sxdsdx.C:142
Lorene::Diff_sxdsdx::operator=
void operator=(const Diff_sxdsdx &)
Assignment to another Diff_sxdsdx.
Definition diff_sxdsdx.C:91
Lorene::Diff_sxdsdx::initialize
void initialize()
Initializes arrays.
Definition diff_sxdsdx.C:79
Lorene::Diff_sxdsdx::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_sxdsdx.C:97
Lorene::Diff_sxdsdx::Diff_sxdsdx
Diff_sxdsdx(int base_r, int nr)
Standard constructor.
Definition diff_sxdsdx.C:67
Lorene::Diff_x2dsdx2::~Diff_x2dsdx2
virtual ~Diff_x2dsdx2()
Destructor.
Definition diff_x2dsdx2.C:75
Lorene::Diff_x2dsdx2::Diff_x2dsdx2
Diff_x2dsdx2(int base_r, int nr)
Standard constructor.
Definition diff_x2dsdx2.C:67
Lorene::Diff_x2dsdx2::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_x2dsdx2.C:95
Lorene::Diff_x2dsdx2::initialize
void initialize()
Initializes arrays.
Definition diff_x2dsdx2.C:77
Lorene::Diff_x2dsdx2::operator=
void operator=(const Diff_x2dsdx2 &)
Assignment to another Diff_x2dsdx2.
Definition diff_x2dsdx2.C:89
Lorene::Diff_x2dsdx2::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_x2dsdx2.C:148
Lorene::Diff_x2dsdx::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_x2dsdx.C:100
Lorene::Diff_x2dsdx::Diff_x2dsdx
Diff_x2dsdx(int base_r, int nr)
Standard constructor.
Definition diff_x2dsdx.C:70
Lorene::Diff_x2dsdx::operator=
void operator=(const Diff_x2dsdx &)
Assignment to another Diff_x2dsdx.
Definition diff_x2dsdx.C:94
Lorene::Diff_x2dsdx::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_x2dsdx.C:152
Lorene::Diff_x2dsdx::initialize
void initialize()
Initializes arrays.
Definition diff_x2dsdx.C:82
Lorene::Diff_x2dsdx::~Diff_x2dsdx
virtual ~Diff_x2dsdx()
Destructor.
Definition diff_x2dsdx.C:80
Lorene::Diff_x3dsdx2::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_x3dsdx2.C:156
Lorene::Diff_x3dsdx2::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_x3dsdx2.C:101
Lorene::Diff_x3dsdx2::operator=
void operator=(const Diff_x3dsdx2 &)
Assignment to another Diff_x3dsdx2.
Definition diff_x3dsdx2.C:95
Lorene::Diff_x3dsdx2::~Diff_x3dsdx2
virtual ~Diff_x3dsdx2()
Destructor.
Definition diff_x3dsdx2.C:81
Lorene::Diff_x3dsdx2::Diff_x3dsdx2
Diff_x3dsdx2(int base_r, int nr)
Standard constructor.
Definition diff_x3dsdx2.C:71
Lorene::Diff_x3dsdx2::initialize
void initialize()
Initializes arrays.
Definition diff_x3dsdx2.C:83
Lorene::Diff_x3dsdx::initialize
void initialize()
Initializes arrays.
Definition diff_x3dsdx.C:84
Lorene::Diff_x3dsdx::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_x3dsdx.C:159
Lorene::Diff_x3dsdx::Diff_x3dsdx
Diff_x3dsdx(int base_r, int nr)
Standard constructor.
Definition diff_x3dsdx.C:74
Lorene::Diff_x3dsdx::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_x3dsdx.C:102
Lorene::Diff_x3dsdx::operator=
void operator=(const Diff_x3dsdx &)
Assignment to another Diff_x3dsdx.
Definition diff_x3dsdx.C:96
Lorene::Diff_x3dsdx::~Diff_x3dsdx
virtual ~Diff_x3dsdx()
Destructor.
Definition diff_x3dsdx.C:82
Lorene::Diff_x4dsdx2::initialize
void initialize()
Initializes arrays.
Definition diff_x4dsdx2.C:80
Lorene::Diff_x4dsdx2::~Diff_x4dsdx2
virtual ~Diff_x4dsdx2()
Destructor.
Definition diff_x4dsdx2.C:78
Lorene::Diff_x4dsdx2::operator=
void operator=(const Diff_x4dsdx2 &)
Assignment to another Diff_x4dsdx2.
Definition diff_x4dsdx2.C:92
Lorene::Diff_x4dsdx2::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_x4dsdx2.C:98
Lorene::Diff_x4dsdx2::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_x4dsdx2.C:154
Lorene::Diff_x4dsdx2::Diff_x4dsdx2
Diff_x4dsdx2(int base_r, int nr)
Standard constructor.
Definition diff_x4dsdx2.C:70
Lorene::Diff_xdsdx2::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_xdsdx2.C:149
Lorene::Diff_xdsdx2::initialize
void initialize()
Initializes arrays.
Definition diff_xdsdx2.C:79
Lorene::Diff_xdsdx2::operator=
void operator=(const Diff_xdsdx2 &)
Assignment to another Diff_xdsdx2.
Definition diff_xdsdx2.C:91
Lorene::Diff_xdsdx2::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_xdsdx2.C:97
Lorene::Diff_xdsdx2::Diff_xdsdx2
Diff_xdsdx2(int base_r, int nr)
Standard constructor.
Definition diff_xdsdx2.C:67
Lorene::Diff_xdsdx2::~Diff_xdsdx2
virtual ~Diff_xdsdx2()
Destructor.
Definition diff_xdsdx2.C:77
Lorene::Diff_xdsdx::Diff_xdsdx
Diff_xdsdx(int base_r, int nr)
Standard constructor.
Definition diff_xdsdx.C:70
Lorene::Diff_xdsdx::initialize
void initialize()
Initializes arrays.
Definition diff_xdsdx.C:80
Lorene::Diff_xdsdx::get_matrice
virtual const Matrice & get_matrice() const
Returns the matrix associated with the operator.
Definition diff_xdsdx.C:98
Lorene::Diff_xdsdx::~Diff_xdsdx
virtual ~Diff_xdsdx()
Destructor.
Definition diff_xdsdx.C:78
Lorene::Diff_xdsdx::operator>>
virtual ostream & operator>>(ostream &) const
Operator >> (virtual function called by the operator <<).
Definition diff_xdsdx.C:160
Lorene::Diff_xdsdx::operator=
void operator=(const Diff_xdsdx &)
Assignment to another Diff_xdsdx.
Definition diff_xdsdx.C:92
Lorene::Diff::npoints
int npoints
Number of coefficients.
Definition diff.h:75
Lorene::Diff::operator=
void operator=(const Diff &)
Assignment to another Diff.
Definition diff.C:75
Lorene::Diff::get_npoints
int get_npoints() const
Returns the number of coefficients (size of the matrix).
Definition diff.h:99
Lorene::Diff::get_base
int get_base() const
Returns the base on which the operator is defined.
Definition diff.h:96
Lorene::Diff::operator>>
virtual ostream & operator>>(ostream &) const =0
Operator >> (virtual function called by the operator <<).
Lorene::Diff::Diff
Diff(int base_r, int nr)
Standard constructor.
Definition diff.C:61
Lorene::Diff::operator<<
friend ostream & operator<<(ostream &, const Diff &)
Display.
Definition diff.C:83
Lorene::Diff::get_matrice
virtual const Matrice & get_matrice() const =0
Returns the matrix associated with the operator.
Lorene::Diff::max_points
static const int max_points
Maximal number of matrices stored per base.
Definition diff.h:71
Lorene::Diff::~Diff
virtual ~Diff()
Destructor.
Definition diff.C:73
Lorene::Diff::base
int base
Base in radial direction.
Definition diff.h:74
Lorene::Matrice
Matrix handling.
Definition matrice.h:152
Lorene
Lorene prototypes.
Definition app_hor.h:64