src/OpenFOAM/matrices/Matrix/Matrix.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::Matrix
  27
  28 Description
  29     A templated 2D matrix of objects of \<T\>, where the n x m matrix
  30     dimensions are known and used for subscript bounds checking, etc.
  31
  32 SourceFiles
  33     Matrix.C
  34     MatrixI.H
  35     MatrixIO.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef Matrix_H
  40 #define Matrix_H
  41
  42 #include "bool.H"
  43 #include "label.H"
  44 #include "uLabel.H"
  45 #include "List.H"
  46 #include "autoPtr.H"
  47
  48 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  49
  50 namespace Foam
  51 {
  52
  53 // Forward declaration of friend functions and operators
  54
  55 template<class Form, class Type> class Matrix;
  56
  57 template<class Form, class Type> Istream& operator>>
  58 (
  59     Istream&,
  60     Matrix<Form, Type>&
  61 );
  62
  63 template<class Form, class Type> Ostream& operator<<
  64 (
  65     Ostream&,
  66     const Matrix<Form, Type>&
  67 );
  68
  69
  70 /*---------------------------------------------------------------------------*\
  71                            Class Matrix Declaration
  72 \*---------------------------------------------------------------------------*/
  73
  74 template<class Form, class Type>
  75 class Matrix
  76 {
  77     // Private data
  78
  79         //- Number of rows and columns in Matrix.
  80         label n_, m_;
  81
  82         //- Row pointers
  83         Type** __restrict__ v_;
  84
  85         //- Allocate the storage for the row-pointers and the data
  86         //  and set the row pointers
  87         void allocate();
  88
  89
  90 public:
  91
  92     // Static Member Functions
  93
  94         //- Return a null Matrix
  95         inline static const Matrix<Form, Type>& null();
  96
  97
  98     // Constructors
  99
 100         //- Null constructor.
 101         inline Matrix();
 102
 103         //- Construct given number of rows and columns.
 104         Matrix(const label n, const label m);
 105
 106         //- Construct with given number of rows and columns
 107         //  and value for all elements.
 108         Matrix(const label n, const label m, const Type&);
 109
 110         //- Copy constructor.
 111         Matrix(const Matrix<Form, Type>&);
 112
 113         //- Construct from Istream.
 114         Matrix(Istream&);
 115
 116         //- Clone
 117         inline autoPtr<Matrix<Form, Type> > clone() const;
 118
 119
 120     // Destructor
 121
 122         ~Matrix();
 123
 124
 125     // Member Functions
 126
 127         // Access
 128
 129             //- Return the number of rows
 130             inline label n() const;
 131
 132             //- Return the number of columns
 133             inline label m() const;
 134
 135             //- Return the number of elements in matrix (n*m)
 136             inline label size() const;
 137
 138
 139         // Check
 140
 141             //- Check index i is within valid range (0 ... n-1).
 142             inline void checki(const label i) const;
 143
 144             //- Check index j is within valid range (0 ... m-1).
 145             inline void checkj(const label j) const;
 146
 147
 148         // Edit
 149
 150             //- Clear the Matrix, i.e. set sizes to zero.
 151             void clear();
 152
 153             //- Transfer the contents of the argument Matrix into this Matrix
 154             //  and annull the argument Matrix.
 155             void transfer(Matrix<Form, Type>&);
 156
 157
 158         //- Return the transpose of the matrix
 159         Form T() const;
 160
 161
 162     // Member operators
 163
 164         //- Return subscript-checked element of Matrix.
 165         inline Type* operator[](const label);
 166
 167         //- Return subscript-checked element of constant Matrix.
 168         inline const Type* operator[](const label) const;
 169
 170         //- Assignment operator. Takes linear time.
 171         void operator=(const Matrix<Form, Type>&);
 172
 173         //- Assignment of all entries to the given value
 174         void operator=(const Type&);
 175
 176
 177     // IOstream operators
 178
 179         //- Read Matrix from Istream, discarding contents of existing Matrix.
 180         friend Istream& operator>> <Form, Type>(Istream&, Matrix<Form, Type>&);
 181
 182         // Write Matrix to Ostream.
 183         friend Ostream& operator<< <Form, Type>(Ostream&, const Matrix<Form, Type>&);
 184 };
 185
 186
 187 // Global functions and operators
 188
 189 template<class Form, class Type> const Type& max(const Matrix<Form, Type>&);
 190 template<class Form, class Type> const Type& min(const Matrix<Form, Type>&);
 191
 192 template<class Form, class Type> Form operator-(const Matrix<Form, Type>&);
 193
 194 template<class Form, class Type> Form operator+
 195 (
 196     const Matrix<Form, Type>&,
 197     const Matrix<Form, Type>&
 198 );
 199
 200 template<class Form, class Type> Form operator-
 201 (
 202     const Matrix<Form, Type>&,
 203     const Matrix<Form, Type>&
 204 );
 205
 206 template<class Form, class Type> Form operator*
 207 (
 208     const scalar,
 209     const Matrix<Form, Type>&
 210 );
 211
 212
 213 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 214
 215 } // End namespace Foam
 216
 217 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 218
 219 #   include "MatrixI.H"
 220
 221 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 222
 223 #ifdef NoRepository
 224 #   include "Matrix.C"
 225 #endif
 226
 227 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 228
 229 #endif
 230
 231 // ************************************************************************* //