check if "times" is within the borders defined in the class

        :param times: "times" to check
        :type times: int
165485
def _validate_measure_count(self, times):
        
        if not self.min_measures <= times <= self.max_measures:
            raise ParameterValidationError(
                "{times} is not within the borders defined in the class".format(
                    times=times
                )
            )
25087
def size(self, time):
        
        if self.start_time <= time <= self.end_time:
            return self.masks[time - self.start_time].sum()
        else:
            return 0
533649
def Matches(self, file_entry):
    
    if not self._date_time_ranges:
      return None

    for date_time_range in self._date_time_ranges:
      time_attribute = self._TIME_VALUE_MAPPINGS.get(
          date_time_range.time_value, None)
      if not time_attribute:
        continue

      timestamp = getattr(file_entry, time_attribute, None)
      if timestamp is None:
        continue

      if (date_time_range.start_date_time is not None and
          timestamp < date_time_range.start_date_time):
        return False

      if (date_time_range.end_date_time is not None and
          timestamp > date_time_range.end_date_time):
        return False

    return True
1094329
def in_time_range?(time)
      time = Time.parse(time) if ! time.is_a?(Time)
      time_range.cover?(time)
    end
676339
def are_in_interval(s, l, r, border = 'included'):
        
        return numpy.all([IntensityRangeStandardization.is_in_interval(x, l, r, border) for x in s])
128360
function (time) {
    var data = this.data;
    var prevCheckTime = this.prevCheckTime;

    if (!data.enabled) { return; }

    // Only check for intersection if interval time has passed.
    if (prevCheckTime && (time - prevCheckTime < data.interval)) { return; }

    // Update check time.
    this.prevCheckTime = time;
    this.checkIntersections();
  }
350179
function(time) {
			var t        = this;
			var children = this.factory.$wrapper.find('ul');

			time = time ? time : (this.factory.time.time || this.factory.time.getMilitaryTime());
			
			if(time.length > children.length) {
				$.each(time, function(i, digit) {
					t.factory.lists.push(t.createList(digit));
				});
			}
			
			this.dividers.push(this.createDivider());
			this.dividers.push(this.createDivider());
			
			$(this.dividers[0]).insertBefore(this.factory.lists[this.factory.lists.length - 2].$obj);
			$(this.dividers[1]).insertBefore(this.factory.lists[this.factory.lists.length - 4].$obj);
			
			this._clearExcessDigits();
			
			if(this.autoStart) {
				this.start();
			}
		}
172893
def contains_time?(time)
      segments.each do |seg|
        return true if seg.contains_time?(time)
      end
      false
    end
1279128
function isAccessTimeValid(acceptTime){

	var isValid = true;

	if(!util.isArray(acceptTime)){
		isValid = false;
	}else{
		for(var i=0; i < acceptTime.length; i++){
			if(!(acceptTime[i] instanceof TimeInterval)){
				isValid = false;
				break;
			}
		}
	}

	return isValid;
}
803116
static <T extends Temporal<? super T>> boolean isAfter(
        Boundary<T> start,
        Boundary<T> end
    ) {

        if (start.mode == PAST) {
            return false;
        } else if (start.mode == FUTURE) {
            return (end.mode != FUTURE);
        } else if (end.mode == PAST) {
            return true;
        } else if (end.mode == FUTURE) {
            return false;
        } else {
            return start.temporal.isAfter(end.temporal);
        }

    }
471578
def repeat(value, times=None, *, interval=0):
    
    args = () if times is None else (times,)
    it = itertools.repeat(value, *args)
    agen = from_iterable.raw(it)
    return time.spaceout.raw(agen, interval) if interval else agen
920364
private static boolean javaTimeTypes(ExpressionTree tree, VisitorState state) {
    if (packageStartsWith("java.time").matches(tree, state)) {
      return false;
    }
    Symbol symbol = ASTHelpers.getSymbol(tree);
    if (symbol instanceof MethodSymbol) {
      MethodSymbol methodSymbol = (MethodSymbol) symbol;
      if (methodSymbol.owner.packge().getQualifiedName().toString().startsWith("java.time")
          && methodSymbol.getModifiers().contains(Modifier.PUBLIC)) {
        if (ALLOWED_JAVA_TIME_METHODS.matches(tree, state)) {
          return false;
        }
        return true;
      }
    }
    return false;
  }
1048101
def containsi(self, begin, end, data=None):
        
        return Interval(begin, end, data) in self
1064118
function isInside(inner, outer) {
            return (
                inner.range[0] >= outer.range[0] &&
                inner.range[1] <= outer.range[1]
            );
        }
385289
def check_time(value):
    """"""
    try:
        h, m = value.split(':')
        h = int(h)
        m = int(m)
        if h >= 24 or h < 0:
            raise ValueError
        if m >= 60 or m < 0:
            raise ValueError
    except ValueError:
        raise TimeDefinitionError("Invalid definition of time %r" % value)
881272
def validation_accepts_or_updates_time?(validations_for_type)
      res = validations_for_type.each_with_object([]) do |validation, offsets|
        r = validation.validate(@time, @start_time)
        return true if r.nil? || r == 0
        offsets << r
      end
      shift_time_by_validation(res, validations_for_type.first)
      false
    end
1055442
function(a, b) {
        if ((a.timesNotSelected || 0) < b.timesNotSelected) {
            return -1;
        }
        else if ((a.timesNotSelected || 0) > b.timesNotSelected) {
            return 1;
        }
        return 0;
    }