Check if
<code>nValue &gt; nLowerBoundInclusive &amp;&amp; nValue &lt; nUpperBoundInclusive</code>

@param dValue
Value
@param sName
Name
@param dLowerBoundExclusive
Lower bound
@param dUpperBoundExclusive
Upper bound
@return The value
482655
public static double isBetweenExclusive (final double dValue,
                                           final String sName,
                                           final double dLowerBoundExclusive,
                                           final double dUpperBoundExclusive)
  {
    if (isEnabled ())
      return isBetweenExclusive (dValue, () -> sName, dLowerBoundExclusive, dUpperBoundExclusive);
    return dValue;
  }
442075
public static BooleanOperation value() {
		JcValue val = new WhenJcValue();
		BooleanOperation ret = P.valueOf(val);
		ASTNode an = APIObjectAccess.getAstNode(ret);
		an.setClauseType(ClauseType.WHEN);
		return ret;
	}
742407
private boolean isRemovableValue(Node n) {
    switch (n.getToken()) {
      case TEMPLATELIT:
      case ARRAYLIT:
        for (Node child = n.getFirstChild(); child != null; child = child.getNext()) {
          if ((!child.isEmpty()) && !isRemovableValue(child)) {
            return false;
          }
        }
        return true;

      case REGEXP:
      case STRING:
      case NUMBER:
      case NULL:
      case TRUE:
      case FALSE:
      case TEMPLATELIT_STRING:
        return true;
      case TEMPLATELIT_SUB:
      case CAST:
      case NOT:
      case VOID:
      case NEG:
        return isRemovableValue(n.getFirstChild());

      default:
        return false;
    }
  }
1112526
public static AllowableValues emptyToNull(AllowableValues newValue, AllowableValues current) {
    if (newValue != null) {
      if (newValue instanceof AllowableListValues) {
        return defaultIfAbsent(emptyListValuesToNull((AllowableListValues) newValue), current);
      } else {
        return defaultIfAbsent(newValue, current);
      }
    }
    return current;
  }
1183830
public com.google.cloud.datalabeling.v1beta1.BoundingPolyOrBuilder getBoundingPolyOrBuilder() {
    if (boundedAreaCase_ == 2) {
      return (com.google.cloud.datalabeling.v1beta1.BoundingPoly) boundedArea_;
    }
    return com.google.cloud.datalabeling.v1beta1.BoundingPoly.getDefaultInstance();
  }
1034331
@SuppressWarnings("unchecked")
  private <T> T parseBoundNamedParameter(final NamedParameterNode<T> np) {
    final T ret;

    @SuppressWarnings("rawtypes")
    final Set<Object> boundSet = c.getBoundSet((NamedParameterNode) np);
    if (!boundSet.isEmpty()) {
      final Set<T> ret2 = new MonotonicSet<>();
      for (final Object o : boundSet) {
        if (o instanceof String) {
          try {
            ret2.add(javaNamespace.parse(np, (String) o));
          } catch (final ParseException e) {
            // Parsability is now pre-checked in bindSet, so it should not be reached!
            throw new IllegalStateException("Could not parse " + o + " which was passed into " + np +
                " FIXME: Parsability is not currently checked by bindSetEntry(Node,String)", e);
          }
        } else if (o instanceof Node) {
          ret2.add((T) o);
        } else {
          throw new IllegalStateException("Unexpected object " + o + " in bound set.  " +
              "Should consist of nodes and strings");
        }
      }
      return (T) ret2;
    }
    final List<Object> boundList = c.getBoundList((NamedParameterNode) np);
    if (boundList != null) {
      final List<T> ret2 = new ArrayList<>();
      for (final Object o : boundList) {
        if (o instanceof String) {
          try {
            ret2.add(javaNamespace.parse(np, (String) o));
          } catch (final ParseException e) {
            // Parsability is now pre-checked in bindList, so it should not be reached!
            throw new IllegalStateException("Could not parse " + o + " which was passed into " + np + " FIXME: " +
                "Parsability is not currently checked by bindList(Node,List)", e);
          }
        } else if (o instanceof Node) {
          ret2.add((T) o);
        } else {
          throw new IllegalStateException("Unexpected object " + o + " in bound list.  Should consist of nodes and " +
              "strings");
        }
      }
      return (T) ret2;
    } else if (namedParameterInstances.containsKey(np)) {
      ret = (T) namedParameterInstances.get(np);
    } else {
      final String value = c.getNamedParameter(np);
      if (value == null) {
        ret = null;
      } else {
        try {
          ret = javaNamespace.parse(np, value);
          namedParameterInstances.put(np, ret);
        } catch (final BindException e) {
          throw new IllegalStateException(
              "Could not parse pre-validated value", e);
        }
      }
    }
    return ret;
  }
953392
public double repairSolutionVariableValue(double value, double lowerBound, double upperBound) {
    if (lowerBound > upperBound) {
      throw new JMetalException("The lower bound (" + lowerBound + ") is greater than the "
          + "upper bound (" + upperBound+")") ;
    }
    double result = value ;
    if (value < lowerBound) {
      result = randomGenerator.getRandomValue(lowerBound, upperBound) ;
    }
    if (value > upperBound) {
      result = randomGenerator.getRandomValue(lowerBound, upperBound) ;
    }

    return result ;
  }
1123728
public static boolean isNameForHiddenCapacityImplementationCallingMethod(String simpleName) {
		return simpleName != null && simpleName.startsWith(PREFIX_CAPACITY_IMPLEMENTATION)
				&& simpleName.endsWith(POSTFIX_CAPACITY_IMPLEMENTATION_CALLER);
	}
342238
private boolean checkValueConstraints(int requiredType, String[] constraints, Value value)
   {
      ValueConstraintsMatcher constrMatcher =
         new ValueConstraintsMatcher(constraints, locationFactory, dataManager, nodeTypeDataManager);

      try
      {
         return constrMatcher.match(((BaseValue)value).getInternalData(), requiredType);
      }
      catch (RepositoryException e1)
      {
         return false;
      }
   }
750035
private static boolean isLocalDefaultValueAssignment(Node targetNode, Node valueNode) {
    return valueNode.isOr()
        && targetNode.isQualifiedName()
        && valueNode.getFirstChild().isEquivalentTo(targetNode)
        && NodeUtil.evaluatesToLocalValue(valueNode.getLastChild());
  }
716257
static boolean isDefinedValue(Node value) {
    switch (value.getToken()) {
      case ASSIGN: // Only the assigned value matters here.
      case CAST:
      case COMMA:
        return isDefinedValue(value.getLastChild());
      case AND:
      case OR:
        return isDefinedValue(value.getFirstChild())
            && isDefinedValue(value.getLastChild());
      case HOOK:
        return isDefinedValue(value.getSecondChild())
            && isDefinedValue(value.getLastChild());
      // Assume undefined leaks in this and call results.
      case CALL:
      case NEW:
      case GETELEM:
      case GETPROP:
      case TAGGED_TEMPLATELIT:
      case THIS:
      case YIELD:
      case AWAIT:
      case VOID:
        return false;
      case DELPROP:
      case INC:
      case DEC:
      case CLASS:
      case FUNCTION:
      case REGEXP:
      case EMPTY:
      case ARRAYLIT:
      case OBJECTLIT:
      case TEMPLATELIT:
      case STRING:
      case NUMBER:
      case NULL:
      case TRUE:
      case FALSE:
        return true;
      case TEMPLATELIT_STRING:
        return value.getCookedString() != null;
      case NAME:
        String name = value.getString();
        // We assume here that programs don't change the value of the keyword
        // undefined to something other than the value undefined.
        return "Infinity".equals(name) || "NaN".equals(name);
      default:
        // Other op force a local value:
        //  '' + g (a  string)
        //  x -= g (x is now an number)
        if (isAssignmentOp(value) || isSimpleOperator(value)) {
          return true;
        }

        throw new IllegalStateException(
            "Unexpected expression node: " + value + "\n parent:" + value.getParent());
    }
  }
1232329
private static Integer checkQuietly(final String name, final Integer value)
	{
		Integer val = 50;
		try
		{
			val = Args.withinRange(0, 100, value, name);
		}
		catch (final IllegalArgumentException e)
		{
			LOGGER.error(String.format(
				"Given argument '%s' must have a value within [%s,%s], but was %s. Default value 50% will be set.",
				name, 0, 100, value));
		}
		return val;

	}
619804
public ResolvedType findBoundType(String name) {
        for (int i = 0, len = _names.length; i < len; ++i) {
            if (name.equals(_names[i])) {
                return _types[i];
            }
        }
        return null;
    }
266708
def nodeSatisfiesValues(cntxt: Context, n: Node, nc: ShExJ.NodeConstraint, _c: DebugContext) -> bool:
    
    if nc.values is None:
        return True
    else:
        if any(_nodeSatisfiesValue(cntxt, n, vsv) for vsv in nc.values):
            return True
        else:
            cntxt.fail_reason = f"Node: {cntxt.n3_mapper.n3(n)} not in value set:\n\t " \
                f"{as_json(cntxt.type_last(nc), indent=None)[:60]}..."
            return False
261135
public static boolean equalsValue(final BigDecimal bd1, final BigDecimal bd2) {
        if (bd1 == null) {
            return bd2 == null;
        }
        return BigDecimalUtil.isSameValue(bd1, bd2);
    }
1328998
private static String getBoundedSourceName(String token, Type[] bounds, String direction)
      throws NoSourceNameException {
    List<String> boundNames = new ArrayList<String>();
    for (Type boundary : bounds) {
      boundNames.add(getSourceName(boundary));
    }
    return String.format("%s %s %s", token, direction, join(" & ", boundNames));
  }
42395
@Override
    public CloseableValue<Boolean> asBoolean() {
        final Class<?> callerClass = ReflectionHelper.getDirectCallerClass();
        return bindSingeValue(Boolean.TYPE, callerClass);
    }