Enlarge value from startValue to endValue

@param startValue start size
@param endValue   end size
@param time       time of animation
@return new size value
961529
public static float enlarge(float startValue, float endValue, float time) {
        if (startValue > endValue)
            throw new IllegalArgumentException("Start size can't be larger than end size.");
        return startValue + (endValue - startValue) * time;
    }
9258
public void setEndtime(Object endtime) throws PageException {
	if (StringUtil.isEmpty(endtime)) return;
	this.endtime = DateCaster.toTime(pageContext.getTimeZone(), endtime);
    }
899368
public static long getMillisDifference(Date startDate, Date endDate) {
		long startTime = startDate.getTime();
		long endTime = endDate.getTime();
		long diffTime = endTime - startTime;
		return diffTime;
	}
657035
public void updateAnimation()
  {
    Date time = new Date();
    long currentTime = time.getTime() - this.beginAnimation;
    if (currentTime > animationTime)
    {
      this.currentQuaternion.set(endQuaternion);
      for (int i = 0; i < 3; i++)
      {

        this.currentPos[i] = this.endPos[i];
      }
      this.animate = false;
    }

    else
    {
      float t = (float) currentTime / animationTime;
      this.currentQuaternion = this.beginQuaternion.slerp(this.endQuaternion,
                                                          t);
      for (int i = 0; i < 3; i++)
      {
        this.currentPos[i] = this.beginPos[i] + totalTranslation[i] * t;
      }

    }
  }
784859
public static PeriodValue createFromDuration(DateValue start, DateValue dur) {
        DateValue end = TimeUtils.add(start, dur);
        if (end instanceof TimeValue && !(start instanceof TimeValue)) {
            start = TimeUtils.dayStart(start);
        }
        return new PeriodValueImpl(start, end);
    }
99169
public void setEndTime(final Date date) {

        if (!Objects.equals(m_model.getEnd(), date)) {
            m_model.setEnd(date);
            valueChanged();
        }

    }
376768
@Override
  public void setStartTime(final long timestamp) {
    if (timestamp < 0 || ((timestamp & Const.SECOND_MASK) != 0 && 
        timestamp > 9999999999999L)) {
      throw new IllegalArgumentException("Invalid timestamp: " + timestamp);
    } else if (end_time != UNSET && timestamp >= getEndTime()) {
      throw new IllegalArgumentException("new start time (" + timestamp
          + ") is greater than or equal to end time: " + getEndTime());
    }
    start_time = timestamp;
  }
326329
public void startScroll(float startValue, float finalValue) {
        finished = false;
        startRtc = SystemClock.elapsedRealtime();

        this.startValue = startValue;
        this.finalValue = finalValue;
        currValue = startValue;
    }
886859
public void setEndType(final String value) {

        final EndType endType = EndType.valueOf(value);
        if (!endType.equals(m_model.getEndType())) {
            removeExceptionsOnChange(new Command() {

                public void execute() {

                    switch (endType) {
                        case SINGLE:
                            m_model.setOccurrences(0);
                            m_model.setSeriesEndDate(null);
                            break;
                        case TIMES:
                            m_model.setOccurrences(10);
                            m_model.setSeriesEndDate(null);
                            break;
                        case DATE:
                            m_model.setOccurrences(0);
                            m_model.setSeriesEndDate(m_model.getStart() == null ? new Date() : m_model.getStart());
                            break;
                        default:
                            break;
                    }
                    m_model.setEndType(endType);
                    valueChanged();
                }
            });
        }

    }
1054758
@Override
    public ElementOperator<PlainTime> newValue(V value) {

        return new TimeOperator(this, ElementOperator.OP_NEW_VALUE, value);

    }
231698
@Nonnull
  public static TimeValue runMeasured (@Nonnull final Runnable aRunnable)
  {
    final StopWatch aSW = createdStarted ();
    aRunnable.run ();
    final long nNanos = aSW.stopAndGetNanos ();
    return new TimeValue (TimeUnit.NANOSECONDS, nNanos);
  }
663504
public void setEnd(ReadableInstant end) {
        long endMillis = DateTimeUtils.getInstantMillis(end);
        super.setInterval(getStartMillis(), endMillis, getChronology());
    }
762049
@Override
    ChronoInterval<T> newInterval(
        Boundary<T> start,
        Boundary<T> end
    ) {

        SimpleInterval.Factory<T> factory =  SimpleInterval.on(this.timeLine);

        if (start.isInfinite()) {
            T e = end.getTemporal();
            if (e != null) {
                if (this.timeLine.isCalendrical()) {
                    if (end.isOpen()) {
                        e = this.timeLine.stepBackwards(e);
                    }
                } else if (end.isClosed()) {
                    e = this.timeLine.stepForward(e);
                }
            }
            if (e == null) {
                return new SimpleInterval<>(start, Boundary.infiniteFuture(), this.timeLine);
            } else {
                return factory.until(e);
            }
        } else if (end.isInfinite()) {
            T s = start.getTemporal();
            if (start.isOpen()) {
                s = this.timeLine.stepForward(s);
            }
            return factory.since(s);
        } else {
            T s = start.getTemporal();
            if (start.isOpen()) {
                s = this.timeLine.stepForward(s);
            }
            T e = end.getTemporal();
            if (this.timeLine.isCalendrical()) {
                if (end.isOpen()) {
                    e = this.timeLine.stepBackwards(e);
                }
            } else if (end.isClosed()) {
                e = this.timeLine.stepForward(e);
            }
            return factory.between(s, e);
        }

    }
218681
public void setValueRange(int min, int max, boolean animation){
        if(max < min || (min == mMinValue && max == mMaxValue))
            return;

        float oldValue = getExactValue();
        float oldPosition = getPosition();
        mMinValue = min;
        mMaxValue = max;

        setValue(oldValue, animation);
        if(mOnPositionChangeListener != null && oldPosition == getPosition() && oldValue != getExactValue())
            mOnPositionChangeListener.onPositionChanged(this, false, oldPosition, oldPosition, Math.round(oldValue), getValue());
    }
1313423
public static function initDatetimesInRange($start_datetime, $end_datetime, $hoursDifference = 1){
        $dates_in_range = [];
        $begin = new DateTime($start_datetime);
        $end = new DateTime($end_datetime);
        $endModify = $end->modify( '+'.$hoursDifference.' hour' ); 

        $interval = new DateInterval('PT'.$hoursDifference.'H');
        $daterange = new DatePeriod($begin, $interval ,$endModify);

        foreach($daterange as $date){
            $dates_in_range[$date->getTimestamp()] = $date->format("Y-m-d H:i:s");
        }
        return $dates_in_range;
    }
89089
public Expression<java.sql.Date> between(java.sql.Date startValue, java.sql.Date endValue) {
		SimpleDateFormat formatter = getDateFormatter();
		String valueString = "'" + formatter.format(startValue).concat("Z") + "' AND '" + formatter.format(endValue) + "'";
		return new Expression<java.sql.Date>(this, Operation.between, valueString);
	}
22104
function(startVal, endVal, drawFn, finishCallback) {
            var animationRange = endVal - startVal,
                duration = 500,
                animationProperties = {
                    duration: duration,
                    step: function(now, fx) {
                        drawFn(startVal + now);
                        this.nudgeChart();
                    }.bind(this)
                };

            if(finishCallback) {
                animationProperties.complete = function() {
                    finishCallback(endVal);
                };
            }
            // for the animation start and end values, use 0 and animationRange for consistency with the way jQuery handles
            // css properties that it doesn't recognize
            $(this.renderTo)
                .stop(true, true)
                .css({'animation-progress': 0})
                .animate({'animation-progress': animationRange}, animationProperties);
        }