@Override public DBIDIter advance() { pos = BitsUtil.nextSetBit(bits, pos + 1); return this; }
@Override public int iter() { return BitsUtil.nextSetBit(bits, 0); }
@Override public int iterAdvance(int iter) { return BitsUtil.nextSetBit(bits, iter + 1); }
/** * Add a single value with weight 1.0. * * @param val Value */ @Override public void put(double[] val) { assert (val.length == elements.length); wsum += 1.0; for(int i = BitsUtil.nextSetBit(dims, 0); i >= 0; i = BitsUtil.nextSetBit(dims, i + 1)) { final double delta = val[i] - elements[i]; elements[i] += delta / wsum; } }
@Override @Deprecated public void setSelectedDimensions(long[] dimensions) { dim = BitsUtil.nextSetBit(dimensions, 0); if(dim == -1) { throw new IllegalStateException("No dimension was set."); } if(BitsUtil.nextSetBit(dimensions, dim + 1) > 0) { throw new IllegalStateException("More than one dimension was set."); } }
@Override public double norm(NumberVector obj) { double sum = 0; for(int d = BitsUtil.nextSetBit(dimensions, 0); d >= 0; d = BitsUtil.nextSetBit(dimensions, d + 1)) { sum += Math.abs(obj.doubleValue(d)); } return sum; }
@Override public double norm(NumberVector obj) { double sqrDist = 0; for(int d = BitsUtil.nextSetBit(dimensions, 0); d >= 0; d = BitsUtil.nextSetBit(dimensions, d + 1)) { final double delta = obj.doubleValue(d); sqrDist += delta * delta; } return Math.sqrt(sqrDist); }
@Override public double norm(NumberVector obj) { double agg = 0.; for(int d = BitsUtil.nextSetBit(dimensions, 0); d >= 0; d = BitsUtil.nextSetBit(dimensions, d + 1)) { double v = Math.abs(obj.doubleValue(d)); if(v > agg) { agg = v; } } return agg; }
@Override public double norm(NumberVector obj) { double sqrDist = 0; for(int d = BitsUtil.nextSetBit(dimensions, 0); d >= 0; d = BitsUtil.nextSetBit(dimensions, d + 1)) { double delta = Math.abs(obj.doubleValue(d)); sqrDist += Math.pow(delta, p); } return Math.pow(sqrDist, 1. / p); }
/** * Constructor. */ protected DBIDItr() { this.pos = BitsUtil.nextSetBit(bits, 0); this.iter = data.iter(); }
/** * Add a single value with weight 1.0. * * @param val Value */ @Override public void put(NumberVector val) { assert (val.getDimensionality() == elements.length); wsum += 1.0; for(int i = BitsUtil.nextSetBit(dims, 0); i >= 0; i = BitsUtil.nextSetBit(dims, i + 1)) { final double delta = val.doubleValue(i) - elements[i]; elements[i] += delta / wsum; } }
@Override public StringBuilder appendTo(StringBuilder buf, VectorFieldTypeInformation<BitVector> meta) { int i = BitsUtil.nextSetBit(items, 0); while(true) { String lbl = (meta != null) ? meta.getLabel(i) : null; if(lbl == null) { buf.append(i); } else { buf.append(lbl); } i = BitsUtil.nextSetBit(items, i + 1); if(i < 0) { break; } buf.append(", "); } buf.append(": ").append(support); return buf; } }
/** * Computes the weighted distance between the two specified vectors according * to the given preference vector. * * @param v1 the first vector * @param v2 the second vector * @param weightVector the preference vector * @return the weighted distance between the two specified vectors according * to the given preference vector */ public double weightedDistance(V v1, V v2, long[] weightVector) { double sqrDist = 0.; for(int i = BitsUtil.nextSetBit(weightVector, 0); i >= 0; i = BitsUtil.nextSetBit(weightVector, i + 1)) { double manhattanI = v1.doubleValue(i) - v2.doubleValue(i); sqrDist += manhattanI * manhattanI; } return Math.sqrt(sqrDist); }
/** * Computes the weighted distance between the two specified vectors according * to the given preference vector. * * @param v1 the first vector * @param v2 the second vector * @param weightVector the preference vector * @return the weighted distance between the two specified vectors according * to the given preference vector */ protected static double weightedDistance(NumberVector v1, NumberVector v2, long[] weightVector) { double sqrDist = 0; for(int i = BitsUtil.nextSetBit(weightVector, 0); i >= 0; i = BitsUtil.nextSetBit(weightVector, i + 1)) { double manhattanI = v1.doubleValue(i) - v2.doubleValue(i); sqrDist += manhattanI * manhattanI; } return Math.sqrt(sqrDist); }
/** * Add data with a given weight. * * @param val data * @param weight weight */ @Override public void put(NumberVector val, double weight) { assert (val.getDimensionality() == elements.length); if(weight == 0) { return; // Skip zero weights. } final double nwsum = weight + wsum; for(int i = BitsUtil.nextSetBit(dims, 0); i >= 0; i = BitsUtil.nextSetBit(dims, i + 1)) { final double delta = val.doubleValue(i) - elements[i]; final double rval = delta * weight / nwsum; elements[i] += rval; } wsum = nwsum; }
/** * Returns the Manhattan segmental distance between o1 and o2 relative to the * specified dimensions. * * @param o1 the first object * @param o2 the second object * @param dimensions the dimensions to be considered * @return the Manhattan segmental distance between o1 and o2 relative to the * specified dimensions */ private double manhattanSegmentalDistance(NumberVector o1, NumberVector o2, long[] dimensions) { double result = 0; int card = 0; for(int d = BitsUtil.nextSetBit(dimensions, 0); d >= 0; d = BitsUtil.nextSetBit(dimensions, d + 1)) { result += Math.abs(o1.doubleValue(d) - o2.doubleValue(d)); ++card; } result /= card; return result; }
@Override public double distance(NumberVector v1, NumberVector v2) { if(v1.getDimensionality() != v2.getDimensionality()) { throw new IllegalArgumentException("Different dimensionality of FeatureVectors\n " + "first argument: " + v1 + "\n " + "second argument: " + v2); } double sqrDist = 0; for(int d = BitsUtil.nextSetBit(dimensions, 0); d >= 0; d = BitsUtil.nextSetBit(dimensions, d + 1)) { double delta = Math.abs(v1.doubleValue(d) - v2.doubleValue(d)); sqrDist += Math.pow(delta, p); } return Math.pow(sqrDist, 1. / p); }
@Override public double distance(NumberVector v1, NumberVector v2) { if(v1.getDimensionality() != v2.getDimensionality()) { throw new IllegalArgumentException("Different dimensionality of FeatureVectors\n " + "first argument: " + v1 + "\n " + "second argument: " + v2); } double sum = 0; for(int d = BitsUtil.nextSetBit(dimensions, 0); d >= 0; d = BitsUtil.nextSetBit(dimensions, d + 1)) { sum += Math.abs(v1.doubleValue(d) - v2.doubleValue(d)); } return sum; }
@Override public double distance(NumberVector v1, NumberVector v2) { if(v1.getDimensionality() != v2.getDimensionality()) { throw new IllegalArgumentException("Different dimensionality of FeatureVectors\n " + "first argument: " + v1 + "\n " + "second argument: " + v2); } double agg = 0.; for(int d = BitsUtil.nextSetBit(dimensions, 0); d >= 0; d = BitsUtil.nextSetBit(dimensions, d + 1)) { double v = Math.abs(v1.doubleValue(d) - v2.doubleValue(d)); if(v > agg) { agg = v; } } return agg; }
/** * Set the selected ranges and the mask for the actual dimensions in the * context. * * @param x1 x-value of the first dimension * @param x2 x-value of the second dimension * @param y1 y-value of the first dimension * @param y2 y-value of the second dimension * @param ranges Ranges to update */ private void updateSelectionRectKoordinates(double x1, double x2, double y1, double y2, ModifiableHyperBoundingBox ranges) { double[] nv1 = proj.fastProjectRenderToDataSpace(x1, y1); double[] nv2 = proj.fastProjectRenderToDataSpace(x2, y2); long[] actDim = proj.getVisibleDimensions2D(); for(int d = BitsUtil.nextSetBit(actDim, 0); d >= 0; d = BitsUtil.nextSetBit(actDim, d + 1)) { ranges.setMin(d, Math.min(nv1[d], nv2[d])); ranges.setMax(d, Math.max(nv1[d], nv2[d])); } }