Method to construct the less than or equals expression for float

@param value the float
@return Expression
962974
public Expression<Float> lte(float value) {
		String valueString = "'" + value + "'";
		return new Expression<Float>(this, Operation.lte, valueString);
	}
1353824
public static <A extends Comparable<A>> Restriction lessThan(String property, A value) {
        return new LessThan(property, value);

    }
1324767
public static Float asFloat(String expression, Node node, XPath xpath)
            throws XPathExpressionException {
        String floatString = evaluateAsString(expression, node, xpath);
        return (isEmptyString(floatString)) ? null : Float.valueOf(floatString);
    }
681528
public Expression<Float> gte(float value) {
		String valueString = "'" + value + "'";
		return new Expression<Float>(this, Operation.gte, valueString);
	}
778108
private Double zeroIsNull(Double value)
   {
      if (value != null && value.doubleValue() == 0)
      {
         value = null;
      }
      return value;
   }
379794
public static <T extends Comparable<T>> T lt(T value) {
        reportMatcher(new LessThan<T>(value));
        return null;
    }
926726
public QueryExpression lt(String propertyName,String value)
    {
        return new SimpleQueryExpression(propertyName, ComparisonOperator.LESS_THAN,wrap(value));
    }
502890
public Expression<Double> lt(double value) {
		String valueString = "'" + value + "'";
		return new Expression<Double>(this, Operation.lt, valueString);
	}
989295
public Expression<Enum<?>> eq(Enum<?> value) {
		String valueString = "'" + EnumPath.getValue(value) + "'";
		return new Expression<Enum<?>>(this, Operation.eq, valueString);
	}
116328
public Expression<Short> eq(short value) {
		String valueString = "'" + value + "'";
		return new Expression<Short>(this, Operation.eq, valueString);
	}
1154132
protected function _validate_float($value)
    {
        if (is_int($value) || is_float($value)) {
            return $value;
        }

        if (filter_var($value, FILTER_VALIDATE_FLOAT) !== false
            && preg_match('#^[+-]?[\d\.]+$#', $value) === 1
        ) {
            return (float)$value;
        } else {
            return null;
        }
    }
373081
public float min(float... values) {
        float min = Float.MAX_VALUE;
        for (int i = 0; i < values.length; i++) {
            if (i == 0 || values[i] < min) {
                min = values[i];
            }
        }
        
        return min;
    }
434681
public CALC val(String value, char decimalSeparator) {
        infix.add(new Num(value, decimalSeparator));
        return getThis();
    }
931885
public static ColorFilter adjustHue( float value )
    {
        ColorMatrix cm = new ColorMatrix();

        adjustHue(cm, value);

        return new ColorMatrixColorFilter(cm);
    }
931184
private Item newFloat(final float value) {
        Item result = get(key.set(FLOAT, value));
        if (result == null) {
            pool.putByte(FLOAT).putInt(Float.floatToIntBits(value));
            result = new Item(poolIndex++, key);
            put(result);
        }
        return result;
    }
787080
public Float convertStringToFloat(String value) {
        Float result;
        try {
            result = Float.valueOf(value);
        } catch (NumberFormatException e) {
            result = DEFAULT_FLOAT_VALUE;
        }
        return result;
    }
320826
public static boolean isBetween(Number value, Number min, Number max) {
		Assert.notNull(value);
		Assert.notNull(min);
		Assert.notNull(max);
		final double doubleValue = value.doubleValue();
		return (doubleValue >= min.doubleValue()) && (doubleValue <= max.doubleValue());
	}