Class: Hyperll::HyperLogLogPlus

Inherits:

Object

• Object
• Hyperll::HyperLogLogPlus

Defined in:

lib/hyperll/hyper_log_log_plus.rb,
ext/hyperll/hyper_log_log_plus.c

Class Method Summary

• .new(*args) ⇒ Object
• .unserialize(serialized) ⇒ Object

Instance Method Summary

• #cardinality ⇒ Object
• #convert_to_normal ⇒ Object
• #format ⇒ Object
• #format=(format) ⇒ Object
• #merge(*args) ⇒ Object
• #p ⇒ Object
• #serialize ⇒ Object
• #sp ⇒ Object

Class Method Details

.new(*args) ⇒ Object

# File 'ext/hyperll/hyper_log_log_plus.c', line 305

static VALUE rb_hyperllp_new(int argc, VALUE *argv, VALUE klass) {
  VALUE p, sp, register_set_values, sparse_set_values;
  rb_scan_args(argc, argv, "13", &p, &sp, &register_set_values, &sparse_set_values);

  if (NIL_P(sp)) sp = INT2NUM(0);

  hyperllp *hllp = ALLOC(hyperllp);
  hyperllp_init(hllp, NUM2INT(p), NUM2INT(sp));
  VALUE hllpv = Data_Wrap_Struct(klass, 0, hyperllp_free, hllp);

  if (hllp->p < 4) rb_raise(rb_eArgError, "p must be >= 4");
  if (hllp->sp >= 32) rb_raise(rb_eArgError, "sp must be < 32");
  if (hllp->sp != 0 && hllp->p > hllp->sp) rb_raise(rb_eArgError, "p must be <= sp");

  if (!NIL_P(register_set_values)) {
    Check_Type(register_set_values, T_ARRAY);

    register_set *rset = hllp->register_set;
    if (RARRAY_LEN(register_set_values) == rset->size) {
      for (int i = 0; i < rset->size; i++) {
        rset->values[i] = NUM2ULONG(rb_ary_entry(register_set_values, i));
      }
    } else {
      rb_raise(rb_eArgError, "initial register set values is not of the correct size");
    }
  }

  if (!NIL_P(sparse_set_values)) {
    Check_Type(sparse_set_values, T_ARRAY);

    sparse_set *sset = hllp->sparse_set;
    if (RARRAY_LEN(sparse_set_values) <= sset->capacity) {
      sset->size = RARRAY_LEN(sparse_set_values);
      for (int i = 0; i < sset->size; i++) {
        sset->values[i] = NUM2ULONG(rb_ary_entry(sparse_set_values, i));
      }
    } else {
      rb_raise(rb_eArgError, "initial sparse set values have too many values");
    }
  }

  return hllpv;
}

.unserialize(serialized) ⇒ Object

# File 'lib/hyperll/hyper_log_log_plus.rb', line 5

def self.unserialize(serialized)
  unpacked = serialized.unpack("C*")
  version = unpacked.shift(4) # integer, we don't currently use it

  p = Varint.read_unsigned_var_int(unpacked)
  sp = Varint.read_unsigned_var_int(unpacked)
  case format_type = Varint.read_unsigned_var_int(unpacked)
  when 0 # :normal
    size = Varint.read_unsigned_var_int(unpacked)
    rs_values = unpacked.pack("C*").unpack("N*")

    new(p, sp, rs_values).tap { |hllp|
      hllp.format = :normal
    }
  when 1 # :sparse
    ss_length = Varint.read_unsigned_var_int(unpacked)
    sparse_set = DeltaBytes.uncompress(unpacked)
    new(p, sp, nil, sparse_set)
  else
    raise ArgumentError, "invalid format: #{format_type}"
  end
end

Instance Method Details

#cardinality ⇒ Object

# File 'ext/hyperll/hyper_log_log_plus.c', line 392

static VALUE rb_hyperllp_cardinality(VALUE self) {
  hyperllp *hllp;
  Data_Get_Struct(self, hyperllp, hllp);

  return INT2NUM(hyperllp_cardinality(hllp));
}

#convert_to_normal ⇒ Object

# File 'ext/hyperll/hyper_log_log_plus.c', line 450

static VALUE rb_hyperllp_convert_to_normal(VALUE self) {
  hyperllp *hllp;
  Data_Get_Struct(self, hyperllp, hllp);

  hyperllp_convert_to_normal(hllp);
  return self;
}

#format ⇒ Object

# File 'ext/hyperll/hyper_log_log_plus.c', line 349

static VALUE rb_hyperllp_format(VALUE self) {
  hyperllp *hllp;
  Data_Get_Struct(self, hyperllp, hllp);

  switch(hllp->format) {
    case FORMAT_NORMAL:
      return ID2SYM(rb_intern("normal"));
    case FORMAT_SPARSE:
      return ID2SYM(rb_intern("sparse"));
  }

  return Qnil;
}

#format=(format) ⇒ Object

# File 'ext/hyperll/hyper_log_log_plus.c', line 363

static VALUE rb_hyperllp_format_set(VALUE self, VALUE format) {
  Check_Type(format, T_SYMBOL);

  hyperllp *hllp;
  Data_Get_Struct(self, hyperllp, hllp);

  if (format == ID2SYM(rb_intern("normal"))) {
    hllp->format = FORMAT_NORMAL;
  } else if (format == ID2SYM(rb_intern("sparse"))) {
    hllp->format = FORMAT_SPARSE;
  }

  return format;
}

#merge(*args) ⇒ Object

# File 'ext/hyperll/hyper_log_log_plus.c', line 399

static VALUE rb_hyperllp_merge(int argc, VALUE *argv, VALUE self) {
  VALUE others;
  rb_scan_args(argc, argv, "*", &others);

  hyperllp *hllp;
  Data_Get_Struct(self, hyperllp, hllp);

  int len = RARRAY_LEN(others);
  for (int i = 0; i < len; i++) {
    hyperllp *ohllp;
    Data_Get_Struct(rb_ary_entry(others, i), hyperllp, ohllp);
    if (!ohllp || hllp->p != ohllp->p) {
      rb_raise(rb_eArgError, "cannot merge estimators of different sizes");
      return Qnil;
    } else {
      hyperllp_merge(hllp, ohllp);
    }
  }

  return self;
}

#p ⇒ Object

# File 'ext/hyperll/hyper_log_log_plus.c', line 378

static VALUE rb_hyperllp_p(VALUE self) {
  hyperllp *hllp;
  Data_Get_Struct(self, hyperllp, hllp);

  return INT2NUM(hllp->p);
}

#serialize ⇒ Object

# File 'lib/hyperll/hyper_log_log_plus.rb', line 28

def serialize
  str = ""
  str << [-2].pack("N") # -VERSION
  str << Varint.write_unsigned_var_int(p).pack("C*")
  str << Varint.write_unsigned_var_int(sp).pack("C*")

  case format
  when :normal
    str << Varint.write_unsigned_var_int(0).pack("C*")

    rs_bytes = raw_register_set
    str << Varint.write_unsigned_var_int(rs_bytes.length * 4).pack("C*")
    str << rs_bytes.pack("N*")
  when :sparse
    str << Varint.write_unsigned_var_int(1).pack("C*")

    ss_bytes = raw_sparse_set
    str << Varint.write_unsigned_var_int(ss_bytes.length).pack("C*")
    str << DeltaBytes.compress(ss_bytes).pack("C*")
  end

  str
end

#sp ⇒ Object

# File 'ext/hyperll/hyper_log_log_plus.c', line 385

static VALUE rb_hyperllp_sp(VALUE self) {
  hyperllp *hllp;
  Data_Get_Struct(self, hyperllp, hllp);

  return INT2NUM(hllp->sp);
}