Gets time period value for the autoplay interval. Prioritizes
times in `data-glide-autoplay` attrubutes over options.

@return {Number}
551615
function get() {
      var autoplay = Components.Html.slides[Glide.index].getAttribute('data-glide-autoplay');

      if (autoplay) {
        return toInt(autoplay);
      }

      return toInt(Glide.settings.autoplay);
    }
230581
private int getPollPeriod() {
    String period = mProperties.getProperty(CONSOLE_KEY_PERIOD);
    return period != null ? Integer.parseInt(period) : CONSOLE_DEFAULT_PERIOD;
  }
777210
private int getCurrentlyShowingValue() {
        int currentIndex = getCurrentItemShowing();
        switch(currentIndex) {
            case HOUR_INDEX:
                return mCurrentTime.getHour();
            case MINUTE_INDEX:
                return mCurrentTime.getMinute();
            case SECOND_INDEX:
                return mCurrentTime.getSecond();
            default:
                return -1;
        }
    }
417179
function getTimeIntervalMeasurementUnits(localeData, restrictedSetOfUnits)
{
	// All available time interval measurement units.
	let units = Object.keys(localeData)

	// If only a specific set of available
	// time measurement units can be used.
	if (restrictedSetOfUnits) {
		// Reduce available time interval measurement units
		// based on user's preferences.
		units = restrictedSetOfUnits.filter(_ => units.indexOf(_) >= 0)
	}

	// Stock `Intl.RelativeTimeFormat` locale data doesn't have "now" units.
	// So either "now" is present in extended locale data
	// or it's taken from ".second.current".
	if ((!restrictedSetOfUnits || restrictedSetOfUnits.indexOf('now') >= 0) &&
		units.indexOf('now') < 0) {
		if (localeData.second.current) {
			units.unshift('now')
		}
	}

	return units
}
975652
private static int getUpdatedInterval(int inputInterval, ExtractType extractType, WatermarkType watermarkType) {
    LOG.debug("Getting updated interval");
    if ((extractType == ExtractType.SNAPSHOT && watermarkType == WatermarkType.DATE)) {
      return inputInterval * 24;
    } else if (extractType == ExtractType.APPEND_DAILY) {
      return (inputInterval < 1 ? 1 : inputInterval) * 24;
    } else {
      return inputInterval;
    }
  }
872317
public int noopIntervalSeconds() {
    try {
      return parsePositiveInteger(get(Names.SET_NOOP_INTERVAL));
    } catch (IllegalArgumentException e) {
      throw new IllegalArgumentException(
          "Bad value for '" + Names.SET_NOOP_INTERVAL.value() + "'; " + e.getMessage());
    }
  }
1270779
private Integer getFrequency(Project.Calendars.Calendar.Exceptions.Exception exception)
   {
      Integer period = NumberHelper.getInteger(exception.getPeriod());
      if (period == null)
      {
         period = Integer.valueOf(1);
      }
      return period;
   }
1308835
function calculateTimeIntervals(timeColumn) {
  // First we find the last time for all of the data (this is an optomisation for the calculateAvailability operation.
  const endTime = timeColumn.values.reduce(function(latest, value, index) {
    const current = finishFromIndex(timeColumn, index);
    if (
      !defined(latest) ||
      (defined(current) && JulianDate.greaterThan(current, latest))
    ) {
      return current;
    }
    return latest;
  }, finishFromIndex(timeColumn, 0));

  return timeColumn.values.map(function(value, index) {
    return calculateAvailability(timeColumn, index, endTime);
  });
}
1218262
function getAnimationProps(selector, opts, duration, easing, interval){
  const animationProps = []
  for(let i in opts){
    const attr = i
    const currentOriginValue = getStyle(selector, attr)
    const currentValue = parseFloat(currentOriginValue)
    const targetValue = parseFloat(opts[i])
    const unit = currentOriginValue.replace(currentValue, '')
    animationProps.push({
      attr: i,
      numbers: generateNumber(currentValue, targetValue, duration, easing, interval),
      unit: unit,
    })
  }
  return animationProps
}
326305
function getGoToTrackState({
  prevState,
  index,
  track,
  shouldPlay = true,
  shouldForceLoad = false
}) {
  const isNewTrack = prevState.activeTrackIndex !== index;
  const shouldLoadAsNew = Boolean(isNewTrack || shouldForceLoad);
  const currentTime = track.startingTime || 0;
  return {
    duration: getInitialDuration(track),
    activeTrackIndex: index,
    trackLoading: shouldLoadAsNew,
    mediaCannotPlay: prevState.mediaCannotPlay && !shouldLoadAsNew,
    currentTime: convertToNumberWithinIntervalBounds(currentTime, 0),
    loop: shouldLoadAsNew ? false : prevState.loop,
    shouldRequestPlayOnNextUpdate: Boolean(shouldPlay),
    awaitingPlayAfterTrackLoad: Boolean(shouldPlay),
    awaitingForceLoad: Boolean(shouldForceLoad),
    maxKnownTime: shouldLoadAsNew ? 0 : prevState.maxKnownTime
  };
}
979427
function Interval(func, options) {
    this.func = func;
    this.delay = options.delay || 16;
    this.lifetime = options.lifetime;
    this.useRequestAnimationFrame = options.useRequestAnimationFrame && window.requestAnimationFrame && window.cancelAnimationFrame;
    this.interval = null;
    this.gcTimeout = null;
}
1202387
function () {
        var unixTime = jsdate.getTime() / 1000;
        var secondsPassedToday = unixTime % 86400 + 3600; // since it's based off of UTC+1
        if (secondsPassedToday < 0) { secondsPassedToday += 86400; }
        var beats = ((secondsPassedToday) / 86.4) % 1000;
        if (unixTime < 0) {
          return Math.ceil(beats);
        }
        return Math.floor(beats);
      }
566421
public String getTimexValueLE() {
    if (Timex3Interval_Type.featOkTst && ((Timex3Interval_Type)jcasType).casFeat_TimexValueLE == null)
      jcasType.jcas.throwFeatMissing("TimexValueLE", "de.unihd.dbs.uima.types.heideltime.Timex3Interval");
    return jcasType.ll_cas.ll_getStringValue(addr, ((Timex3Interval_Type)jcasType).casFeatCode_TimexValueLE);}
226562
function () {
            var carousel = this, timer;

            if (JS.isUndefined(carousel._autoPlayTimer)) {
                timer = carousel.get("autoPlayInterval");
                if (timer <= 0) {
                    return;
                }
                carousel._isAutoPlayInProgress = true;
                carousel.fireEvent(startAutoPlayEvent);
                carousel._autoPlayTimer = setTimeout(function () {
                    carousel._autoScroll();
                }, timer);
            }
        }
443562
function periodicActivity()
{   
    //Read & Scale Gyro/Accel Data
    var xgyro = imu.gyroScale(imu.regRead(0x04));
    var ygyro = imu.gyroScale(imu.regRead(0x06));
    var zgyro = imu.gyroScale(imu.regRead(0x08));
    var xaccl = imu.accelScale(imu.regRead(0x0A)); 
    var yaccl = imu.accelScale(imu.regRead(0x0C));
    var zaccl = imu.accelScale(imu.regRead(0x0E));
    
    //Display Scaled Data on the Console Log
    console.log('XGYRO: ' + xgyro);
    console.log('YGYRO: ' + ygyro);
    console.log('ZGYRO: ' + zgyro);
    console.log('XACCL: ' + xaccl);
    console.log('YACCL: ' + yaccl);
    console.log('ZACCL: ' + zaccl);
    console.log(' ');
    setTimeout(periodicActivity,200); //call the indicated function after 0.2 seconds (200 milliseconds)
}
407595
function (now) {

      if (this.lastFrameTime){
        // chrome bug, see: https://code.google.com/p/chromium/issues/detail?id=268213
        // http://jsfiddle.net/pehrlich/35pTx/
        // console.assert(this.lastFrameTime < now);
        if (now < this.lastFrameTime){
          // this fix will cause an extra animation frame before the lerp frame advances. no big.
          this.lastFrameTime = now;
        }else{
          this.timeSinceLastFrame += (now - this.lastFrameTime);
        }
      }

      this.lastFrameTime = now;

      console.assert(!isNaN(this.timeSinceLastFrame));


      var timeToNextFrame;

      // handle frame dropping, etc
      while ( this.timeSinceLastFrame > ( timeToNextFrame = this.recording.timeToNextFrame() ) ){
        this.timeSinceLastFrame -= timeToNextFrame;
        if (!this.recording.advanceFrame()){
          this.pause();
          this.controller.emit('playback.playbackFinished', this);
          return
        }
      }

      this.sendFrame(
        this.recording.createLerpFrameData(this.timeSinceLastFrame / timeToNextFrame)
      );

    }
937565
function getEasing(value, duration) {
        var easing = value;

        /* The easing option can either be a string that references a pre-registered easing,
           or it can be a two-/four-item array of integers to be converted into a bezier/spring function. */
        if (Type.isString(value)) {
            /* Ensure that the easing has been assigned to jQuery's Velocity.Easings object. */
            if (!Velocity.Easings[value]) {
                easing = false;
            }
        } else if (Type.isArray(value) && value.length === 1) {
            easing = generateStep.apply(null, value);
        } else if (Type.isArray(value) && value.length === 2) {
            /* springRK4 must be passed the animation's duration. */
            /* Note: If the springRK4 array contains non-numbers, generateSpringRK4() returns an easing
               function generated with default tension and friction values. */
            easing = generateSpringRK4.apply(null, value.concat([ duration ]));
        } else if (Type.isArray(value) && value.length === 4) {
            /* Note: If the bezier array contains non-numbers, generateBezier() returns false. */
            easing = generateBezier.apply(null, value);
        } else {
            easing = false;
        }

        /* Revert to the Velocity-wide default easing type, or fall back to "swing" (which is also jQuery's default)
           if the Velocity-wide default has been incorrectly modified. */
        if (easing === false) {
            if (Velocity.Easings[Velocity.defaults.easing]) {
                easing = Velocity.defaults.easing;
            } else {
                easing = EASING_DEFAULT;
            }
        }

        return easing;
    }