src/foam/primitives/ops/ops.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     |
   5     \\  /    A nd           | For copyright notice see file Copyright
   6      \\/     M anipulation  |
   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 InClass
  25     Foam::Pstream
  26
  27 Description
  28     Combination-Reduction operation for a parallel run.
  29
  30     The information from all nodes is collected on the master node,
  31     combined using the given combination function and the result is
  32     broadcast to all nodes
  33
  34 Note:
  35     Format of this file has considerably changed to remove cpp pre-processor
  36     definition in order to help Swig with parsing in.  Implemented by
  37     Alexey Petrov; merged by HJ, 14/Oct/2010
  38
  39 \*---------------------------------------------------------------------------*/
  40
  41 #ifndef ops_H
  42 #define ops_H
  43
  44 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  45
  46 namespace Foam
  47 {
  48
  49 template<class T1, class T2>
  50 class eqOp2
  51 { public: void operator()(T1& x, const T2& y) const { x = y; } };
  52
  53 template<class T>
  54 class eqOp
  55 { public: void operator()(T& x, const T& y) const { x = y; } };
  56
  57 template<class T1, class T2>
  58 class plusEqOp2
  59 { public: void operator()(T1& x, const T2& y) const { x += y; } };
  60
  61 template<class T>
  62  class plusEqOp
  63 { public: void operator()(T& x, const T& y) const { x += y; } };
  64
  65 template<class T1, class T2>
  66  class minusEqOp2
  67 { public: void operator()(T1& x, const T2& y) const { x -= y; } };
  68
  69 template<class T>
  70 class minusEqOp
  71 { public: void operator()(T& x, const T& y) const { x -= y; } };
  72
  73 template<class T1, class T2>
  74 class multiplyEqOp2
  75 { public: void operator()(T1& x, const T2& y) const { x *= y; } };
  76
  77 template<class T>
  78 class multiplyEqOp
  79 { public: void operator()(T& x, const T& y) const { x *= y; } };
  80
  81 template<class T1, class T2>
  82 class divideEqOp2
  83 { public: void operator()(T1& x, const T2& y) const { x /= y; } };
  84
  85 template<class T>
  86 class divideEqOp
  87 { public: void operator()(T& x, const T& y) const { x /= y; } };
  88
  89 template<class T1, class T2>
  90 class eqMagOp2
  91 { public: void operator()(T1& x, const T2& y) const { x = mag(y); } };
  92
  93 template<class T>
  94 class eqMagOp
  95 { public: void operator()(T& x, const T& y) const { x = mag(y); } };
  96
  97 template<class T1, class T2>
  98 class plusEqMagSqrOp2
  99 { public: void operator()(T1& x, const T2& y) const { x += magSqr(y); } };
 100
 101 template<class T>
 102 class plusEqMagSqrOp
 103 { public: void operator()(T& x, const T& y) const { x += magSqr(y); } };
 104
 105 template<class T1, class T2>
 106 class maxEqOp2
 107 { public: void operator()(T1& x, const T2& y) const { x = max(x, y); } };
 108
 109 template<class T>
 110 class maxEqOp
 111 { public: void operator()(T& x, const T& y) const { x = max(x, y); } };
 112
 113 template<class T1, class T2>
 114 class minEqOp2
 115 { public: void operator()(T1& x, const T2& y) const { x = min(x, y); } };
 116
 117 template<class T>
 118 class minEqOp
 119 { public: void operator()(T& x, const T& y) const { x = min(x, y); } };
 120
 121 template<class T1, class T2>
 122 class andEqOp2
 123 { public: void operator()(T1& x, const T2& y) const { x = (x && y); } };
 124
 125 template<class T>
 126 class andEqOp
 127 { public: void operator()(T& x, const T& y) const { x = (x && y); } };
 128
 129 template<class T1, class T2>
 130 class orEqOp2
 131 { public: void operator()(T1& x, const T2& y) const { x = (x || y); } };
 132
 133 template<class T>
 134 class orEqOp
 135 { public: void operator()(T& x, const T& y) const { x = (x || y); } };
 136
 137 template<class T1, class T2>
 138 class eqMinusOp2
 139 { public: void operator()(T1& x, const T2& y) const { x = -y; } };
 140
 141 template<class T>
 142 class eqMinusOp
 143 { public: void operator()(T& x, const T& y) const { x = -y; } };
 144
 145
 146 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 147
 148 template<class T, class T1, class T2>
 149 class sumOp3
 150 { public: T operator()(const T1& x, const T2& y) const { return x + y; } };
 151
 152 template<class T1, class T2>
 153 class sumOp2
 154 { public: T1 operator()(const T1& x, const T2& y) const { return x + y; } };
 155
 156 template<class T>
 157 class sumOp
 158 { public: T operator()(const T& x, const T& y) const { return x + y; } };
 159
 160 template<class T, class T1, class T2>
 161 class plusOp3
 162 { public: T operator()(const T1& x, const T2& y) const { return x + y; } };
 163
 164 template<class T1, class T2>
 165 class plusOp2
 166 { public: T1 operator()(const T1& x, const T2& y) const { return x + y; } };
 167
 168 template<class T>
 169 class plusOp
 170 { public: T operator()(const T& x, const T& y) const { return x + y; } };
 171
 172 template<class T, class T1, class T2>
 173 class minusOp3
 174 { public: T operator()(const T1& x, const T2& y) const { return x - y; } };
 175
 176 template<class T1, class T2>
 177 class minusOp2
 178 { public: T1 operator()(const T1& x, const T2& y) const { return x - y; } };
 179
 180 template<class T>
 181 class minusOp
 182 { public: T operator()(const T& x, const T& y) const { return x - y; } };
 183
 184 template<class T, class T1, class T2>
 185 class multiplyOp3
 186 { public: T operator()(const T1& x, const T2& y) const { return x * y; } };
 187
 188 template<class T1, class T2>
 189 class multiplyOp2
 190 { public: T1 operator()(const T1& x, const T2& y) const { return x * y; } };
 191
 192 template<class T>
 193 class multiplyOp
 194 { public: T operator()(const T& x, const T& y) const { return x * y; } };
 195
 196 template<class T, class T1, class T2>
 197 class divideOp3
 198 { public: T operator()(const T1& x, const T2& y) const { return x / y; } };
 199
 200 template<class T1, class T2>
 201 class divideOp2
 202 { public: T1 operator()(const T1& x, const T2& y) const { return x / y; } };
 203
 204 template<class T>
 205 class divideOp
 206 { public: T operator()(const T& x, const T& y) const { return x / y; } };
 207
 208 template<class T, class T1, class T2>
 209 class cmptMultiplyOp3
 210 { public: T operator()(const T1& x, const T2& y) const { return cmptMultiply(x, y); } };
 211
 212 template<class T1, class T2>
 213 class cmptMultiplyOp2
 214 { public: T1 operator()(const T1& x, const T2& y) const { return cmptMultiply(x, y); } };
 215
 216 template<class T>
 217 class cmptMultiplyOp
 218 { public: T operator()(const T& x, const T& y) const { return cmptMultiply(x, y); } };
 219
 220 template<class T, class T1, class T2>
 221 class cmptDivideOp3
 222 { public: T operator()(const T1& x, const T2& y) const { return cmptDivide(x, y); } };
 223
 224 template<class T1, class T2>
 225 class cmptDivideOp2
 226 { public: T1 operator()(const T1& x, const T2& y) const { return cmptDivide(x, y); } };
 227
 228 template<class T>
 229 class cmptDivideOp
 230 { public: T operator()(const T& x, const T& y) const { return cmptDivide(x, y); } };
 231
 232 template<class T, class T1, class T2>
 233 class stabiliseOp3
 234 { public: T operator()(const T1& x, const T2& y) const { return stabilise(x, y); } };
 235
 236 template<class T1, class T2>
 237 class stabiliseOp2
 238 { public: T1 operator()(const T1& x, const T2& y) const { return stabilise(x, y); } };
 239
 240 template<class T>
 241 class stabiliseOp
 242 { public: T operator()(const T& x, const T& y) const { return stabilise(x, y); } };
 243
 244 template<class T, class T1, class T2>
 245 class maxOp3
 246 { public: T operator()(const T1& x, const T2& y) const { return max(x, y); } };
 247
 248 template<class T1, class T2>
 249 class maxOp2
 250 { public: T1 operator()(const T1& x, const T2& y) const { return max(x, y); } };
 251
 252 template<class T>
 253 class maxOp
 254 { public: T operator()(const T& x, const T& y) const { return max(x, y); } };
 255
 256 template<class T, class T1, class T2>
 257 class minOp3
 258 { public: T operator()(const T1& x, const T2& y) const { return min(x, y); } };
 259
 260 template<class T1, class T2>
 261 class minOp2
 262 { public: T1 operator()(const T1& x, const T2& y) const { return min(x, y); } };
 263
 264 template<class T>
 265 class minOp
 266 { public: T operator()(const T& x, const T& y) const { return min(x, y); } };
 267
 268 template<class T, class T1, class T2>
 269 class minModOp3
 270 { public: T operator()(const T1& x, const T2& y) const { return minMod(x, y); } };
 271
 272 template<class T1, class T2>
 273 class minModOp2
 274 { public: T1 operator()(const T1& x, const T2& y) const { return minMod(x, y); } };
 275
 276 template<class T>
 277 class minModOp
 278 { public: T operator()(const T& x, const T& y) const { return minMod(x, y); } };
 279
 280 template<class T, class T1, class T2>
 281 class andOp3
 282 { public: T operator()(const T1& x, const T2& y) const { return x && y; } };
 283
 284 template<class T1, class T2>
 285 class andOp2
 286 { public: T1 operator()(const T1& x, const T2& y) const { return x && y; } };
 287
 288 template<class T>
 289 class andOp
 290 { public: T operator()(const T& x, const T& y) const { return x && y; } };
 291
 292 template<class T, class T1, class T2>
 293 class orOp3
 294 { public: T operator()(const T1& x, const T2& y) const { return x || y; } };
 295
 296 template<class T1, class T2>
 297 class orOp2
 298 { public: T1 operator()(const T1& x, const T2& y) const { return x || y; } };
 299
 300 template<class T>
 301 class orOp
 302 { public: T operator()(const T& x, const T& y) const { return x || y; } };
 303
 304 template<class T, class T1, class T2>
 305 class eqEqOp3
 306 { public: T operator()(const T1& x, const T2& y) const { return x == y; } };
 307
 308 template<class T1, class T2>
 309 class eqEqOp2
 310 { public: T1 operator()(const T1& x, const T2& y) const { return x == y; } };
 311
 312 template<class T>
 313 class eqEqOp
 314 { public: T operator()(const T& x, const T& y) const { return x == y; } };
 315
 316
 317 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 318
 319 } // End namespace Foam
 320
 321 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 322
 323 #endif
 324
 325 // ************************************************************************* //