src/foam/matrices/simpleMatrix/simpleMatrix.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     Foam::simpleMatrix
  26
  27 Description
  28     A simple square matrix solver with scalar coefficients.
  29     Simple dense matrix class with direct solvers.
  30
  31 Author
  32     Hrvoje Jasak, Wikki Ltd.  All rights reserved
  33
  34 SourceFiles
  35     simpleMatrix.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef simpleMatrix_H
  40 #define simpleMatrix_H
  41
  42 #include "scalarMatrices.H"
  43
  44 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  45
  46 namespace Foam
  47 {
  48
  49 // Forward declaration of friend functions and operators
  50
  51 template<class Type>
  52 class simpleMatrix;
  53
  54 template<class Type>
  55 simpleMatrix<Type> operator+
  56 (
  57     const simpleMatrix<Type>&,
  58     const simpleMatrix<Type>&
  59 );
  60
  61 template<class Type>
  62 simpleMatrix<Type> operator-
  63 (
  64     const simpleMatrix<Type>&,
  65     const simpleMatrix<Type>&
  66 );
  67
  68 template<class Type>
  69 simpleMatrix<Type> operator*
  70 (
  71     const scalar,
  72     const simpleMatrix<Type>&
  73 );
  74
  75 template<class Type>
  76 Ostream& operator<<
  77 (
  78     Ostream&,
  79     const simpleMatrix<Type>&
  80 );
  81
  82
  83 /*---------------------------------------------------------------------------*\
  84                            Class simpleMatrix Declaration
  85 \*---------------------------------------------------------------------------*/
  86
  87 template<class Type>
  88 class simpleMatrix
  89 :
  90     public scalarSquareMatrix
  91 {
  92     // Private data
  93
  94         Field<Type> source_;
  95
  96
  97 public:
  98
  99     // Constructors
 100
 101         //- Construct given size
 102         //  Note: this does not initialise the coefficients or the source.
 103         simpleMatrix(const label);
 104
 105         //- Construct given size and initial values for the
 106         //  coefficients and source
 107         simpleMatrix(const label, const scalar, const Type&);
 108
 109         //- Construct from components
 110         simpleMatrix(const scalarSquareMatrix&, const Field<Type>&);
 111
 112         //- Construct from Istream
 113         simpleMatrix(Istream&);
 114
 115         //- Construct as copy
 116         simpleMatrix(const simpleMatrix<Type>&);
 117
 118
 119     // Member Functions
 120
 121         // Access
 122
 123             //- Return access to the source
 124             Field<Type>& source()
 125             {
 126                 return source_;
 127             }
 128
 129             //- Return const-access to the source
 130             const Field<Type>& source() const
 131             {
 132                 return source_;
 133             }
 134
 135
 136         //- Solve the matrix using Gaussian elimination with pivoting
 137         //  and return the solution
 138         Field<Type> solve() const;
 139
 140         //- Solve the matrix using LU decomposition with pivoting
 141         //  and return the solution
 142         Field<Type> LUsolve() const;
 143
 144
 145     // Member Operators
 146
 147         void operator=(const simpleMatrix<Type>&);
 148
 149
 150     // Ostream Operator
 151
 152         friend Ostream& operator<< <Type>
 153         (
 154             Ostream&,
 155             const simpleMatrix<Type>&
 156         );
 157 };
 158
 159
 160 // Global operators
 161
 162 template<class Type>
 163 simpleMatrix<Type> operator+
 164 (
 165     const simpleMatrix<Type>&,
 166     const simpleMatrix<Type>&
 167 );
 168
 169 template<class Type>
 170 simpleMatrix<Type> operator-
 171 (
 172     const simpleMatrix<Type>&,
 173     const simpleMatrix<Type>&
 174 );
 175
 176 template<class Type>
 177 simpleMatrix<Type> operator*
 178 (
 179     const scalar,
 180     const simpleMatrix<Type>&
 181 );
 182
 183
 184 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 185
 186 } // End namespace Foam
 187
 188 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 189
 190 #ifdef NoRepository
 191 #   include "simpleMatrix.C"
 192 #endif
 193
 194 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 195
 196 #endif
 197
 198 // ************************************************************************* //