code: private void addRawSparseProbabilistic(final long rawValue) {
          // p(w): position of the least significant set bit (one-indexed)
          // By contract: p(w) <= 2^(registerValueInBits) - 1 (the max register value)
          //
          // By construction of pwMaxMask (see #Constructor()),
          //      lsb(pwMaxMask) = 2^(registerValueInBits) - 2,
          // thus lsb(any_long | pwMaxMask) <= 2^(registerValueInBits) - 2,
          // thus 1 + lsb(any_long | pwMaxMask) <= 2^(registerValueInBits) -1.
          final long substreamValue = (rawValue >>> log2m);
          final byte p_w;
  
          if(substreamValue == 0L) {
              // The paper does not cover p(0x0), so the special value 0 is used.
              // 0 is the original initialization value of the registers, so by
              // doing this the multiset simply ignores it. This is acceptable
              // because the probability is 1/(2^(2^registerSizeInBits)).
              p_w = 0;
          } else {
              p_w = (byte)(1 + BitUtil.leastSignificantBit(substreamValue| pwMaxMask));
          }
  
          // Short-circuit if the register is being set to zero, since algorithmically
          // this corresponds to an "unset" register, and "unset" registers aren't
          // stored to save memory. (The very reason this sparse implementation
          // exists.) If a register is set to zero it will break the #algorithmCardinality
          // code.
          if(p_w == 0) {
              return;
          }
  
          // NOTE:  no +1 as in paper since 0-based indexing
          final int j = (int)(rawValue & mBitsMask);
  
          final byte currentValue = sparseProbabilisticStorage.get(j);
          if(p_w > currentValue) {
              sparseProbabilisticStorage.put(j, p_w);
          }
      }
docs: Adds the raw value to the {@link #sparseProbabilisticStorage}.
  {@link #type} must be {@link HLLType#SPARSE}.
  
  @param rawValue the raw value to add to the sparse storage.