Update this bitfield to be the intersection of this bitfield and the passed bitfield.
337967
def intersection!(bitfield)
      raise "That's not a bitfield" if ! bitfield.is_a?(Bitfield)
      raise "bitfield lengths must be equal" if ! bitfield.length == length
        
      (@data.length).times do |i|
        @data[i] = @data[i] & bitfield.data[i]
      end
      self
    end
687594
def union_update(self, other, ignore_conflicts=False):
        """"""
        if not ignore_conflicts:
            ensure_compatible(self, other)
        self._objects |= other._objects
        self._properties |= other._properties
        self._pairs |= other._pairs
299784
public void update(ESMapping mapping, Object pkVal, Map<String, Object> esFieldData) {
        Map<String, Object> esFieldDataTmp = new LinkedHashMap<>(esFieldData.size());
        esFieldData.forEach((k, v) -> esFieldDataTmp.put(Util.cleanColumn(k), v));
        append4Update(mapping, pkVal, esFieldDataTmp);
        commitBulk();
    }
871205
def intersection_update(self, *others):
        """"""
        self.db.sinterstore(self.key, [o.key for o in [self.key] + others])
738425
public void _updateXYImpl(boolean bExact) {
		m_envelope.setEmpty();
		AttributeStreamOfDbl stream = (AttributeStreamOfDbl) m_vertexAttributes[0];
		Point2D pt = new Point2D();
		for (int i = 0; i < m_pointCount; i++) {
			stream.read(2 * i, pt);
			m_envelope.merge(pt);
		}
	}
807309
def _update_seek(self, offset, whence):
        
        with self._seek_lock:
            if whence == SEEK_SET:
                self._seek = offset
            elif whence == SEEK_CUR:
                self._seek += offset
            elif whence == SEEK_END:
                self._seek = offset + self._size
            else:
                raise ValueError('whence value %s unsupported' % whence)
        return self._seek
1159852
def update(self):
        
        if self.var_info.bits_per_pixel == 1:
            b = self._img.tobytes("raw", "1;R")
            self.mmap[:len(b)] = b

        elif self.var_info.bits_per_pixel == 16:
            self.mmap[:] = self._img_to_rgb565_bytes()

        elif self.var_info.bits_per_pixel == 32:
            self.mmap[:] = self._img.convert("RGB").tobytes("raw", "XRGB")

        else:
            raise Exception("Not supported - platform %s with bits_per_pixel %s" %
                (self.platform, self.var_info.bits_per_pixel))
716058
public void updateBitmapShader() {
		if (image == null)
			return;

		shader = new BitmapShader(image, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);

		if(canvasSize != image.getWidth() || canvasSize != image.getHeight()) {
			Matrix matrix = new Matrix();
			float scale = (float) canvasSize / (float) image.getWidth();
			matrix.setScale(scale, scale);
			shader.setLocalMatrix(matrix);
		}
	}
898488
def update(self, update_finished_cb):
        """"""
        if not self._update_finished_cb:
            self._update_finished_cb = update_finished_cb
            self.valid = False
            logger.debug('Updating content of memory {}'.format(self.id))
            # Start reading the header
            self.mem_handler.read(self, 0, 11)
826300
static void makeVersionInfoBits(Version version, BitArray bits) throws WriterException {
    bits.appendBits(version.getVersionNumber(), 6);
    int bchCode = calculateBCHCode(version.getVersionNumber(), VERSION_INFO_POLY);
    bits.appendBits(bchCode, 12);

    if (bits.getSize() != 18) {  // Just in case.
      throw new WriterException("should not happen but we got: " + bits.getSize());
    }
  }
1283322
def set_bit(self, position: int):
        
        if position > (self._bit_width - 1):
            raise ValueError('position greater than the bit width')

        self._value |= (1 << position)
        self._text_update()
1058115
def intersection_update(self, other):
        
        ivs = list(self)
        for iv in ivs:
            if iv not in other:
                self.remove(iv)
1341520
void update(long index, int b)
    {
        if (size > 0)
        {
            assert index <= hi;
            if (index < lo)
            {
                throw new IllegalStateException("lookaheadLength() too small in ChecksumProvider implementation");
            }
            hi = index;
            if ((lo == hi - size))
            {
                checksum.update(lookahead[(int)(lo % size)]);
                lo++;
            }
            lookahead[(int)(hi++ % size)] = b;
        }
        else
        {
            if (index == hi)
            {
                checksum.update(b);
                hi = index+1;
            }
            else
            {
                if (index != hi -1)
                {
                    throw new IllegalStateException("lookahead needed for checksum");
                }
            }
        }
    }
498284
public static long intersectionCount(OpenBitSet a, OpenBitSet b) {
        return BitUtil.pop_intersect( a.bits, b.bits, 0, Math.min( a.wlen, b.wlen ) );
    }
608861
def update(self, byts):
        '''
        
        '''
        self.size += len(byts)
        [h[1].update(byts) for h in self.hashes]
379040
def _handle_shift(self, other: Union[int, "BitVec"], operator: Callable) -> "BitVec":
        
        if isinstance(other, BitVecFunc):
            return operator(other, self)
        if not isinstance(other, BitVec):
            return BitVec(
                operator(self.raw, other), annotations=self.annotations
            )
        union = self.annotations + other.annotations
        return BitVec(operator(self.raw, other.raw), annotations=union)
701218
def update_field(self, name, update):
        
        for field in self.__next_descriptor['fields']:
            if field['name'] == name:
                field.update(update)
                return True
        return False