this = this AND NOT other
424318
void andNot(LongBitSet other) {
		int pos = Math.min(numWords, other.numWords);
		while (--pos >= 0) {
			bits[pos] &= ~other.bits[pos];
		}
	}
265299
function extendThis() {
		var i, ni, objects, object, prop;
		objects = arguments;
		for (i = 0, ni = objects.length; i < ni; i++) {
			object = objects[i];
			for (prop in object) {
				this[prop] = object[prop];
			}
		}

		return this;
	}
1016033
function (other) {
        assertNotNull(other);

        var c = collectionCount(other);

        if (c !== -1) {
            // if other is the empty set then this is a superset
            if (c === 0) {
                return true;
            }

            else if (areEqualityComparersEqual(this, other)) {
                if (c > this.count()) {
                    return false;
                }
            }
        }

        return containsAllElements(this, other);
    }
1073087
def eq_or_parent(self, other):
        
        return self.parts[: len(other.parts)] == other.parts[: len(self.parts)]
19815
def equals(self, other):
        
        if self.is_(other):
            return True

        if not isinstance(other, Index):
            return False

        if is_object_dtype(self) and not is_object_dtype(other):
            # if other is not object, use other's logic for coercion
            return other.equals(self)

        try:
            return array_equivalent(com.values_from_object(self),
                                    com.values_from_object(other))
        except Exception:
            return False
105278
def identical(self, other):
        
        return (self.equals(other) and
                all((getattr(self, c, None) == getattr(other, c, None)
                     for c in self._comparables)) and
                type(self) == type(other))
202116
public function equals(self $other) : bool
    {
        if ($other === $this) {
            return true;
        }
        
        return $other->from->equals($this->from) && $other->until->equals($this->until);
    }
874642
def is_not_equal_to(self, other):
        
        self._run(unittest_case.assertNotEqual, (self._subject, other))
        return ChainInspector(self._subject)
1101671
def update(self, other):
        
        if isinstance(other, Properties):
            other = other.defined
        for n, v in other.items():
            self.set(n, v)
        return self
92334
def equality(self, other):
        """"""
        if not len(self) == len(other):
            return False
        return super().equality(other)
130651
def isDescendantOf(self, other):
    '''

    '''
    if isinstance(other, Key):
      return other.isAncestorOf(self)
    raise TypeError('%s is not of type %s' % (other, Key))
396174
def difference(other)
      if other.is_a?(RelativeComplement)
        # A ∖ ¬B = A ∩ B
        intersection(other.complement)
      elsif other.is_a?(AbstractSet)
        if other.empty?
          self
        else
          # A ∖ B = A ∩ ¬B
          hash = @hash.clone.delete_if{|o,_| other.include?(o) }

          if hash.empty?
            NullSet.build
          else
            RelativeSet.new(hash)
          end
        end
      else
        difference(Cantor.build(other))
      end
    end
1286158
def instance(self, other):
    ''''''
    assert '/' not in str(other)
    return Key(str(self) + ':' + str(other))
563222
public Predicate<T> and( final Predicate<T> other ) {
        if (other == null || other == this) return this;
        return new Predicate<T>() {
            @Override
            public boolean test( T input ) {
                return Predicate.this.test(input) && other.test(input);
            }
        };
    }
1313275
def is_entailed_by(self, other):
        
        other = self.coerce(other)
        to_i = self.to_i
        return to_i(other.low) >= to_i(self.low) and \
                to_i(other.high) <= to_i(self.high)
54594
def **(other)
      if other.is_a?(Numeric)
        new(value ** other, unit ** other)
      else
        fail TypeError, "Can't raise #{self} to #{other} power."
      end
    end
915229
def logical_and(self, other):
        """"""
        return self.operation(other, lambda x, y: int(x and y))