Method to construct the between expression for double

@param startValue the start value
@param endValue the end value
@return Expression
421649
public Expression<Double> between(Double startValue, Double endValue) {
		String valueString = "'" + startValue + "' AND '" + endValue + "'";
		return new Expression<Double>(this, Operation.between, valueString);
	}
869951
public static int datedif(EvaluationContext ctx, Object startDate, Object endDate, Object unit) {
        LocalDate _startDate = Conversions.toDate(startDate, ctx);
        LocalDate _endDate = Conversions.toDate(endDate, ctx);
        String _unit = Conversions.toString(unit, ctx).toLowerCase();

        if (_startDate.isAfter(_endDate)) {
            throw new RuntimeException("Start date cannot be after end date");
        }

        switch (_unit) {
        case "y":
            return (int) ChronoUnit.YEARS.between(_startDate, _endDate);
        case "m":
            return (int) ChronoUnit.MONTHS.between(_startDate, _endDate);
        case "d":
            return (int) ChronoUnit.DAYS.between(_startDate, _endDate);
        case "md":
            return Period.between(_startDate, _endDate).getDays();
        case "ym":
            return Period.between(_startDate, _endDate).getMonths();
        case "yd":
            return (int) ChronoUnit.DAYS.between(_startDate.withYear(_endDate.getYear()), _endDate);
        }

        throw new RuntimeException("Invalid unit value: " + _unit);
    }
167770
@Override
    public double getDoubleValue( final String       key,
                                  final double       defaultValue )
    {
        return formatDoubleValue( key, getFormattedPropValue( key ), defaultValue );
    }
997822
public static double durationSeconds(LocalDateTime start, LocalDateTime end)
   {
	   return Duration.between(start, end).getSeconds();
   }
572435
function (start, end) {
      start = start.replace(/\$/g, '');
      end = end.replace(/\$/g, '');

      return instance.helper.cellRangeValue.call(this, start, end);
    }
1098299
public static Scheme rangeValue(final Float fixedMinValue, final Float fixedMaxValue) {
        return rangeValue(fixedMinValue.doubleValue(), fixedMaxValue.doubleValue());
    }
105591
public StrBuilder del(int start, int end) {
		if (start < 0) {
			start = 0;
		}
		if (end > this.position) {
			end = this.position;
		}
		if (start > end) {
			throw new StringIndexOutOfBoundsException("Start is greater than End.");
		}
		if (end == this.position) {
			this.position = start;
		}

		int len = end - start;
		if (len > 0) {
			System.arraycopy(value, start + len, value, start, this.position - end);
			this.position -= len;
		}
		return this;
	}
1363388
public static Between between( String property, int minimum, int maximum)
    {
    return new Between( notLessThan( property, minimum), notMoreThan( property, maximum));
    }
912628
public static Range range(final double minValue, final double maxValue) {
        if (minValue > maxValue) {
            throw new IllegalArgumentException("minValue should be less then or equal to maxValue (" + minValue+ ", " + maxValue + ")");
        }
        return new Range() {

            @Override
            public Number getMinimum() {
                return minValue;
            }

            @Override
            public Number getMaximum() {
                return maxValue;
            }

            @Override
            public String toString() {
                return Ranges.toString(this);
            }
            
        };
    }
1157316
@SuppressWarnings("WeakerAccess") // Public API
    public static void interpolate(State out, State start, State end, float factor) {
        interpolate(out, start, start.getX(), start.getY(), end, end.getX(), end.getY(), factor);
    }
117187
public Expression<Double> lte(double value) {
		String valueString = "'" + value + "'";
		return new Expression<Double>(this, Operation.lte, valueString);
	}
864290
public static boolean isBetween(final Date start, final Date end, final Date between)
	{
		final long min = start.getTime();
		final long max = end.getTime();
		final long index = between.getTime();
		return min <= index && index <= max;
	}
395698
public static ExprDouble toExprDouble(Expression expr, Position start, Position end) {
	if (expr instanceof Literal) {
	    Double d = ((Literal) expr).getDouble(null);
	    if (d != null) {
		return expr.getFactory().createLitDouble(-d.doubleValue(), start, end);
	    }
	}
	return new OpNegateNumber(expr, start, end);
    }
926282
public Expression<Double> gt(double value) {
		String valueString = "'" + value + "'";
		return new Expression<Double>(this, Operation.gt, valueString);
	}
593642
public final <A extends Number & Comparable<?>> BooleanExpression between(@Nullable Expression<A> from, @Nullable Expression<A> to) {
        if (from == null) {
            if (to != null) {
                return Expressions.booleanOperation(Ops.LOE, mixin, to);
            } else {
                throw new IllegalArgumentException("Either from or to needs to be non-null");
            }
        } else if (to == null) {
            return Expressions.booleanOperation(Ops.GOE, mixin, from);
        } else {
            return Expressions.booleanOperation(Ops.BETWEEN, mixin, from, to);
        }
    }
625908
public Expression<Byte> between(Byte startValue, Byte endValue) {
		String valueString = "'" + startValue + "' AND '" + endValue + "'";
		return new Expression<Byte>(this, Operation.between, valueString);
	}
273325
public static Between notBetween(final Expression exp1, final Expression exp2, final Expression exp3) {
        return new Between(exp1, and(exp2, exp3)).not();
    }