Returns whether the Array contains none of the items.

   [1, 2, 3].include_none?(1, 2)  #=> false
   [1, 2, 3].include_none?(1, 4)  #=> false
   [1, 2, 3].include_none?(4, 5)  #=> true
325550
def include_none?(*items)
      items = items.first if items.length == 1 && items.first.kind_of?(Array)
      (self & items).empty?
    end
863572
public boolean containsNaN() {
        for (int i = 0; i < values.length; i++) {
            if (s.isNaN(values[i])) {
                return true;
            }
        }
        return false;
    }
347203
def is_an_array(var, allow_none=False):
    
    return isinstance(var, np.ndarray) or (var is None and allow_none)
756360
function contains(array, value) {
    var result = false;
    each(array, function (item) {
        result = item === value;
        return !result;
    });

    return result;
}
1285245
def contains_none_of(self, elements):
        
        for element in elements:
            self._run(unittest_case.assertNotIn, (element, self._subject))
        return ChainInspector(self._subject)
144139
function(list, value) {
      if (_.isArray(value)) {
        for (var i = 0; i < value.length; i++) {
          var valueItem = value[i];
          if (_.contains(list, valueItem)) {
            return true;
          }
        }
        return false;
      } else {
        return _.contains(list, value);
      }
    }
1097621
public static boolean isIncluded(String filename, List<String> includes) {
        logger.debug("filename = [{}], includes = [{}]", filename, includes);

        // No rules ? Fine, we index everything
        if (includes == null || includes.isEmpty()) {
            logger.trace("no include rules");
            return true;
        }

        for (String include : includes) {
            String regex = include.toLowerCase().replace("?", ".?").replace("*", ".*?");
            logger.trace("regex is [{}]", regex);
            if (filename.toLowerCase().matches(regex)) {
                logger.trace("does match include regex");
                return true;
            }
        }

        logger.trace("does not match any include pattern");
        return false;
    }
1077697
def does_not_contain(self, element):
        
        self._run(unittest_case.assertNotIn, (element, self._subject))
        return ChainInspector(self._subject)
1325896
def negated(input_words, include_nt=True):
    
    input_words = [str(w).lower() for w in input_words]
    neg_words = []
    neg_words.extend(NEGATE)
    for word in neg_words:
        if word in input_words:
            return True
    if include_nt:
        for word in input_words:
            if "n't" in word:
                return True
    if "least" in input_words:
        i = input_words.index("least")
        if i > 0 and input_words[i - 1] != "at":
            return True
    return False
608950
def _remove_none(data):
    
    if isinstance(data, list) or isinstance(data, tuple):
        return [x for x in data if x is not None]

    out = OrderedDict()
    for key, val in data.iteritems():
        if val is not None:
            out[key] = val

    return out
1093727
def is_none(node):
    ""
    return isinstance(node, parso.python.tree.Keyword) and node.value == 'None'
65824
public static boolean containsNaN(DoubleTuple tuple)
    {
        for (int i=0; i<tuple.getSize(); i++)
        {
            if (Double.isNaN(tuple.get(i)))
            {
                return true;
            }
        }
        return false;
    }
500568
def is_none(node):
    '''
    '''
    if PY2:
        return isinstance(node, ast.Name) and node.id == 'None'
    return isinstance(node, ast.NameConstant) and node.value is None
932098
def contains(self, *args):
        
        self.op = '@>'
        self.negate_op = None
        self.value = self._array_value(args)
        return self
179789
function contains(arr, v) {
    var nIndex,
      nLen = arr.length;
    for (nIndex = 0; nIndex < nLen; nIndex++) {
      if (arr[nIndex][1] === v) {
        return true;
      }
    }
    return false;
  }
1143709
def rejected? label, reject
      if reject.any? && (x = reject.first[:except])
        if x.is_a?(Array)
          return true if x.find {|m| match?(label, m)}
        else
          return true if match?(label, x)
        end
      end
      false
    end
691527
def are_none(sequences: Sequence[Sized]) -> bool:
    
    if not sequences:
        return True
    return all(s is None for s in sequences)