ENH: make op names unambiguous

* lessEqOp    -> lessEqualOp
  * greaterEqOp -> greaterEqualOp

  to avoid ambiguitity with other forms such as 'plusEqOp' where the
  'Eq' implies an assigment. The name change also aligns better with
  C++ <functional> names such as std::less_equal, std::greater_equal

ENH: simple labelRange predicates gt0/ge0/lt0/le0

- mirrors scalarRange tests.
  Lower overhead than using labelMinMax::ge(0) etc since it does not
  create an intermediate (is stateless) and can be used as a constexpr

applications/test/scalarPredicates/Test-scalarPredicates.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -184,7 +184,7 @@ int main(int argc, char *argv[])
         testPredicate(values, greaterOp1<scalar>(100));
 
         // Also with dissimilar type
-        testPredicate(values, lessEqOp1<label>(0));
+        testPredicate(values, lessEqualOp1<label>(0));
     }
 
     Info<< "\nEnd\n" << endl;

src/OpenFOAM/expressions/fields/fieldExprLemonParser.h

@@ -13,9 +13,9 @@
 #define TOK_EQUAL                           13
 #define TOK_NOT_EQUAL                       14
 #define TOK_LESS                            15
-#define TOK_LESS_EQ                         16
+#define TOK_LESS_EQUAL                      16
 #define TOK_GREATER                         17
-#define TOK_GREATER_EQ                      18
+#define TOK_GREATER_EQUAL                   18
 #define TOK_PLUS                            19
 #define TOK_MINUS                           20
 #define TOK_TIMES                           21

src/OpenFOAM/expressions/fields/fieldExprScanner.cc

@@ -657,7 +657,7 @@ tr68:
 	goto st14;
 tr69:
 #line 251 "fieldExprScanner.rl"
-	{te = p+1;{ EMIT_TOKEN(LESS_EQ); }}
+	{te = p+1;{ EMIT_TOKEN(LESS_EQUAL); }}
 	goto st14;
 tr70:
 #line 252 "fieldExprScanner.rl"
@@ -665,7 +665,7 @@ tr70:
 	goto st14;
 tr71:
 #line 253 "fieldExprScanner.rl"
-	{te = p+1;{ EMIT_TOKEN(GREATER_EQ); }}
+	{te = p+1;{ EMIT_TOKEN(GREATER_EQUAL); }}
 	goto st14;
 tr72:
 #line 206 "fieldExprScanner.rl"

src/OpenFOAM/expressions/fields/fieldExprScanner.rl

@@ -248,9 +248,9 @@ static int driverTokenType
     '?'  =>{ EMIT_TOKEN(QUESTION); };
     ':'  =>{ EMIT_TOKEN(COLON); };
     '<'  =>{ EMIT_TOKEN(LESS); };
-    '<=' =>{ EMIT_TOKEN(LESS_EQ); };
+    '<=' =>{ EMIT_TOKEN(LESS_EQUAL); };
     '>'  =>{ EMIT_TOKEN(GREATER); };
-    '>=' =>{ EMIT_TOKEN(GREATER_EQ); };
+    '>=' =>{ EMIT_TOKEN(GREATER_EQUAL); };
     '==' =>{ EMIT_TOKEN(EQUAL); };
     '!=' =>{ EMIT_TOKEN(NOT_EQUAL); };
     '&&' =>{ EMIT_TOKEN(LAND); };

src/OpenFOAM/include/m4/lemon/operator-precedence.m4

@@ -6,7 +6,7 @@ divert(-1)dnl
 #     \\  /    A nd           | www.openfoam.com
 #      \\/     M anipulation  |
 #------------------------------------------------------------------------------
-#     Copyright (C) 2019-2021 OpenCFD Ltd.
+#     Copyright (C) 2019-2022 OpenCFD Ltd.
 #------------------------------------------------------------------------------
 # License
 #     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -26,7 +26,7 @@ define([operator_precedence],
 %left BIT_XOR .                         // 9
 %left BIT_AND .                         // 8
 %left EQUAL NOT_EQUAL .                 // 7
-%left LESS LESS_EQ GREATER GREATER_EQ . // 6
+%left LESS LESS_EQUAL GREATER GREATER_EQUAL . // 6
 %left PLUS MINUS .                      // 4
 %left TIMES DIVIDE PERCENT .            // 3
 %right NEGATE LNOT BIT_NOT .            // 2: right-to-left
@@ -41,7 +41,7 @@ define([standard_tokens],
   QUESTION COLON LOR LAND LNOT
   BIT_OR BIT_XOR BIT_AND BIT_NOT
   EQUAL NOT_EQUAL
-  LESS LESS_EQ GREATER GREATER_EQ
+  LESS LESS_EQUAL GREATER GREATER_EQUAL
   PLUS MINUS TIMES DIVIDE PERCENT
   NEGATE DOT
   BOOL LTRUE LFALSE

src/OpenFOAM/include/m4/lemon/rules-operations.m4

@@ -6,7 +6,7 @@ divert(-1)dnl
 #     \\  /    A nd           | www.openfoam.com
 #      \\/     M anipulation  |
 #------------------------------------------------------------------------------
-#     Copyright (C) 2019 OpenCFD Ltd.
+#     Copyright (C) 2019-2022 OpenCFD Ltd.
 #------------------------------------------------------------------------------
 # License
 #     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -62,9 +62,9 @@ define([rules_compare_operations],
 [rule_binary_logical_op($1, $2, $3, equalOp, EQUAL, ==)
 rule_binary_logical_op($1, $2, $3, notEqualOp, NOT_EQUAL, !=)
 rule_binary_logical_op($1, $2, $3, lessOp, LESS, <)
-rule_binary_logical_op($1, $2, $3, lessEqOp, LESS_EQ, <=)
+rule_binary_logical_op($1, $2, $3, lessEqualOp, LESS_EQUAL, <=)
 rule_binary_logical_op($1, $2, $3, greaterOp, GREATER, >)
-rule_binary_logical_op($1, $2, $3, greaterEqOp, GREATER_EQ, >=)
+rule_binary_logical_op($1, $2, $3, greaterEqualOp, GREATER_EQUAL, >=)
 rule_ternary_op($2, $1, $3)
 ])
 

src/OpenFOAM/interpolations/interpolationWeights/linearInterpolationWeights/linearInterpolationWeights.C

@@ -171,7 +171,7 @@ bool Foam::linearInterpolationWeights::integrationWeights
     // Currently no fancy logic on cached index like in value
 
     //- Find lower or equal index
-    const label i1 = findLower(samples_, t1, 0, lessEqOp<scalar>());
+    const label i1 = findLower(samples_, t1, 0, lessEqualOp<scalar>());
 
     if (t2 <= t1 + ROOTVSMALL)
     {

src/OpenFOAM/primitives/ops/ops.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -236,16 +236,19 @@ BoolOp(xor, (!x) != (!y))   // With forced bool context
 BoolOp(equal, x == y)
 BoolOp(notEqual, x != y)
 BoolOp(less, x < y)
-BoolOp(lessEq, x <= y)
+BoolOp(lessEqual, x <= y)
 BoolOp(greater, x > y)
-BoolOp(greaterEq, x >= y)
+BoolOp(greaterEqual, x >= y)
+
+BoolOp(lessEq, x <= y)          // OpenFOAM-v2112 and earlier
+BoolOp(greaterEq, x >= y)       // OpenFOAM-v2112 and earlier
 
 Bool1Op(equal, x == value)
 Bool1Op(notEqual, x != value)
 Bool1Op(less, x < value)
-Bool1Op(lessEq, x <= value)
+Bool1Op(lessEqual, x <= value)
 Bool1Op(greater, x > value)
-Bool1Op(greaterEq, x >= value)
+Bool1Op(greaterEqual, x >= value)
 
 WeightedOp(multiply, (weight*y))
 

src/OpenFOAM/primitives/predicates/scalar/scalarPredicates.C

@@ -44,12 +44,14 @@ Foam::predicates::scalars::opNames
     { opType::NOT_EQUAL,  "notEqual" },
     { opType::LESS, "lt" },
     { opType::LESS, "less" },
-    { opType::LESS_EQ, "le" },
+    { opType::LESS_EQUAL, "le" },
-    { opType::LESS_EQ, "lessEq" },
+    { opType::LESS_EQUAL, "lessEqual" },
+    { opType::LESS_EQUAL, "lessEq" },
     { opType::GREATER, "gt" },
     { opType::GREATER, "greater" },
-    { opType::GREATER_EQ, "ge" },
+    { opType::GREATER_EQUAL, "ge" },
-    { opType::GREATER_EQ, "greaterEq" },
+    { opType::GREATER_EQUAL, "greaterEqual" },
+    { opType::GREATER_EQUAL, "greaterEq" },
 });
 
 
@@ -73,14 +75,14 @@ std::function<bool(Foam::scalar)> Foam::predicates::scalars::operation
         case opType::LESS:
             return lessOp(opVal);
             break;
-        case opType::LESS_EQ:
+        case opType::LESS_EQUAL:
-            return lessEqOp(opVal);
+            return lessEqualOp(opVal);
             break;
         case opType::GREATER:
             return greaterOp(opVal);
             break;
-        case opType::GREATER_EQ:
+        case opType::GREATER_EQUAL:
-            return greaterEqOp(opVal);
+            return greaterEqualOp(opVal);
             break;
         case opType::ALWAYS:
             return trueOp();

src/OpenFOAM/primitives/predicates/scalar/scalarPredicates.H

@@ -81,11 +81,15 @@ public:
             EQUAL,              //!< "eq", "equal"
             NOT_EQUAL,          //!< "neq", "notEqual"
             LESS,               //!< "lt", "less"
-            LESS_EQ,            //!< "le", "lessEq"
+            LESS_EQUAL,         //!< "le", "lessEqual", "lessEq"
             GREATER,            //!< "gt", "greater"
-            GREATER_EQ,         //!< "ge", "greaterEq"
+            GREATER_EQUAL,      //!< "ge", "greaterEqual", "greaterEq"
             ALWAYS,             //!< Always matches
             NEVER,              //!< Never matches
+
+            // OpenFOAM-v2112 and earlier:
+            LESS_EQ = LESS_EQUAL,
+            GREATER_EQ = GREATER_EQUAL,
         };
 
         //- Names for the opType enumeration.
@@ -133,7 +137,7 @@ public:
 
 
         //- Test if value is 'less_equal' to prescribed
-        static unary lessEqOp(const scalar opVal)
+        static unary lessEqualOp(const scalar opVal)
         {
             return std::bind
             (
@@ -154,7 +158,7 @@ public:
 
 
         //- Test if value is 'greater_equal' to prescribed
-        static unary greaterEqOp(const scalar opVal)
+        static unary greaterEqualOp(const scalar opVal)
         {
             return std::bind
             (

src/OpenFOAM/primitives/ranges/IntRange/IntRange.H

@@ -104,6 +104,49 @@ public:
         class const_reverse_iterator;
 
 
+    // Public Classes
+
+        //- Unary predicate for greater than 0 (int values)
+        struct gt0
+        {
+            template<class Int>
+            constexpr bool operator()(const Int val) const noexcept
+            {
+                return val > 0;
+            }
+        };
+
+        //- Unary predicate for less than 0 (int values)
+        struct lt0
+        {
+            template<class Int>
+            constexpr bool operator()(const Int val) const noexcept
+            {
+                return val < 0;
+            }
+        };
+
+        //- Unary predicate for greater-equal 0 (int values)
+        struct ge0
+        {
+            template<class Int>
+            constexpr bool operator()(const Int val) const noexcept
+            {
+                return val >= 0;
+            }
+        };
+
+        //- Unary predicate for less-equal 0 (int values)
+        struct le0
+        {
+            template<class Int>
+            constexpr bool operator()(const Int val) const noexcept
+            {
+                return val <= 0;
+            }
+        };
+
+
     // Generated Methods: copy/move construct, copy/move assignment
 
 

src/finiteVolume/expressions/patch/patchExprLemonParser.h

@@ -13,9 +13,9 @@
 #define TOK_EQUAL                           13
 #define TOK_NOT_EQUAL                       14
 #define TOK_LESS                            15
-#define TOK_LESS_EQ                         16
+#define TOK_LESS_EQUAL                      16
 #define TOK_GREATER                         17
-#define TOK_GREATER_EQ                      18
+#define TOK_GREATER_EQUAL                   18
 #define TOK_PLUS                            19
 #define TOK_MINUS                           20
 #define TOK_TIMES                           21

src/finiteVolume/expressions/patch/patchExprScanner.cc

@@ -789,7 +789,7 @@ tr70:
 	goto st14;
 tr71:
 #line 383 "patchExprScanner.rl"
-	{te = p+1;{ EMIT_TOKEN(LESS_EQ); }}
+	{te = p+1;{ EMIT_TOKEN(LESS_EQUAL); }}
 	goto st14;
 tr72:
 #line 384 "patchExprScanner.rl"
@@ -797,7 +797,7 @@ tr72:
 	goto st14;
 tr73:
 #line 385 "patchExprScanner.rl"
-	{te = p+1;{ EMIT_TOKEN(GREATER_EQ); }}
+	{te = p+1;{ EMIT_TOKEN(GREATER_EQUAL); }}
 	goto st14;
 tr74:
 #line 338 "patchExprScanner.rl"

src/finiteVolume/expressions/patch/patchExprScanner.rl

@@ -380,9 +380,9 @@ static int driverTokenType
     '?'  =>{ EMIT_TOKEN(QUESTION); };
     ':'  =>{ EMIT_TOKEN(COLON); };
     '<'  =>{ EMIT_TOKEN(LESS); };
-    '<=' =>{ EMIT_TOKEN(LESS_EQ); };
+    '<=' =>{ EMIT_TOKEN(LESS_EQUAL); };
     '>'  =>{ EMIT_TOKEN(GREATER); };
-    '>=' =>{ EMIT_TOKEN(GREATER_EQ); };
+    '>=' =>{ EMIT_TOKEN(GREATER_EQUAL); };
     '==' =>{ EMIT_TOKEN(EQUAL); };
     '!=' =>{ EMIT_TOKEN(NOT_EQUAL); };
     '&&' =>{ EMIT_TOKEN(LAND); };

src/finiteVolume/expressions/volume/volumeExprLemonParser.h

@@ -13,9 +13,9 @@
 #define TOK_EQUAL                           13
 #define TOK_NOT_EQUAL                       14
 #define TOK_LESS                            15
-#define TOK_LESS_EQ                         16
+#define TOK_LESS_EQUAL                      16
 #define TOK_GREATER                         17
-#define TOK_GREATER_EQ                      18
+#define TOK_GREATER_EQUAL                   18
 #define TOK_PLUS                            19
 #define TOK_MINUS                           20
 #define TOK_TIMES                           21

src/finiteVolume/expressions/volume/volumeExprScanner.cc

@@ -809,7 +809,7 @@ tr69:
 	goto st14;
 tr70:
 #line 403 "volumeExprScanner.rl"
-	{te = p+1;{ EMIT_TOKEN(LESS_EQ); }}
+	{te = p+1;{ EMIT_TOKEN(LESS_EQUAL); }}
 	goto st14;
 tr71:
 #line 404 "volumeExprScanner.rl"
@@ -817,7 +817,7 @@ tr71:
 	goto st14;
 tr72:
 #line 405 "volumeExprScanner.rl"
-	{te = p+1;{ EMIT_TOKEN(GREATER_EQ); }}
+	{te = p+1;{ EMIT_TOKEN(GREATER_EQUAL); }}
 	goto st14;
 tr73:
 #line 358 "volumeExprScanner.rl"

src/finiteVolume/expressions/volume/volumeExprScanner.rl

@@ -400,9 +400,9 @@ static int driverTokenType
     '?'  =>{ EMIT_TOKEN(QUESTION); };
     ':'  =>{ EMIT_TOKEN(COLON); };
     '<'  =>{ EMIT_TOKEN(LESS); };
-    '<=' =>{ EMIT_TOKEN(LESS_EQ); };
+    '<=' =>{ EMIT_TOKEN(LESS_EQUAL); };
     '>'  =>{ EMIT_TOKEN(GREATER); };
-    '>=' =>{ EMIT_TOKEN(GREATER_EQ); };
+    '>=' =>{ EMIT_TOKEN(GREATER_EQUAL); };
     '==' =>{ EMIT_TOKEN(EQUAL); };
     '!=' =>{ EMIT_TOKEN(NOT_EQUAL); };
     '&&' =>{ EMIT_TOKEN(LAND); };

src/finiteVolume/fvMesh/fvGeometryScheme/averageNeighbour/averageNeighbourFvGeometryScheme.C

@@ -572,10 +572,7 @@ Foam::averageNeighbourFvGeometryScheme::averageNeighbourFvGeometryScheme
         (
             "nIters",
             1,
-            [&](const label& nIters)
+            [](label val) { return val >= 0; }
-            {
-                return nIters >= 0;
-            }
         )
     ),
     relax_
@@ -583,10 +580,7 @@ Foam::averageNeighbourFvGeometryScheme::averageNeighbourFvGeometryScheme
         dict.getCheck<scalar>
         (
             "relax",
-            [&](const scalar& relax)
+            [](scalar val) { return val > 0 && val <= 1; }
-            {
-                return relax > 0 && relax <= 1;
-            }
         )
     ),
     minRatio_
@@ -595,10 +589,7 @@ Foam::averageNeighbourFvGeometryScheme::averageNeighbourFvGeometryScheme
         (
             "minRatio",
             0.5,
-            [&](const scalar& minRatio)
+            [](scalar val) { return val >= 0 && val <= 1; }
-            {
-                return minRatio >= 0 && minRatio <= 1;
-            }
         )
     )
 {

src/functionObjects/field/blendingFactor/blendingFactor.C

@@ -116,7 +116,7 @@ bool Foam::functionObjects::blendingFactor::read(const dictionary& dict)
             (
                 "tolerance",
                 0.001,
-                [&](const scalar tol){ return (tol > 0) && (tol < 1); }
+                [](scalar tol){ return (tol > 0 && tol < 1); }
             );
 
         return true;

src/functionObjects/lagrangian/common/parcelSelectionDetail.H

@@ -98,9 +98,9 @@ Description
     The expressions are a (op scalar) pair that form a unary scalar
     predicate. The \a op is one of the following:
     - lt, less
-    - le, lessEq
+    - le, lessEqual, lessEq
     - gt, greater
-    - ge, greaterEq
+    - ge, greaterEqual, greaterEq
     - eq, equal
     - neq, notEqual
 

src/fvOptions/sources/derived/buoyancyTurbSource/buoyancyTurbSource.C

@@ -148,7 +148,7 @@ Foam::fv::buoyancyTurbSource::buoyancyTurbSource
             (
                 "beta",
                 3.3e-3,
-                [&](const scalar x){ return x > SMALL; }
+                [=](const scalar x){ return x > SMALL; }
             )
         )
     ),