protected void invertRow(int rnum, boolean b) { BitsUtil.setI(irow, rnum); } }
@Override @Deprecated public long[] getSelectedDimensions() { long[] bs = BitsUtil.zero(dim); BitsUtil.setI(bs, dim); return bs; }
@Override public long[] getItems() { long[] bits = BitsUtil.zero(indices[indices.length - 1]); for(int item : indices) { BitsUtil.setI(bits, item); } return bits; }
/** * Creates a new one-dimensional subspace of the original data space. * * @param dimension the dimension building this subspace */ public Subspace(int dimension) { dimensions = BitsUtil.zero(dimension + 1); BitsUtil.setI(dimensions, dimension); dimensionality = 1; }
@Override public long[] getItems() { long[] bits = BitsUtil.zero(item); BitsUtil.setI(bits, item); return bits; }
/** * Select or deselect a column. * * @param cnum Column to select * @param set Value to set */ protected void selectColumn(int cnum, boolean set) { if(set) { BitsUtil.setI(cols, cnum); colcard++; } else { BitsUtil.clearI(cols, cnum); colcard--; } }
/** * Select or deselect a row. * * @param rnum Row to select * @param set Value to set */ protected void selectRow(int rnum, boolean set) { if(set) { BitsUtil.setI(rows, rnum); rowcard++; } else { BitsUtil.clearI(rows, rnum); rowcard--; } }
/** * Select the "iter" highest bit from each dimension. * * @param coords Input coordinates * @param iter Bit position (from highest position) * @return One bit per dimension */ public static long[] interleaveBits(int[] coords, int iter) { final int numdim = coords.length; final long[] bitset = BitsUtil.zero(numdim); // convert longValues into zValues final long mask = 1L << 31 - iter; for (int dim = 0; dim < numdim; dim++) { if ((coords[dim] & mask) != 0) { BitsUtil.setI(bitset, dim); } } return bitset; }
/** * Select the "iter" highest bit from each dimension. * * @param coords Input coordinates * @param iter Bit position (from highest position) * @return One bit per dimension */ public static long[] interleaveBits(long[] coords, int iter) { final int numdim = coords.length; final long[] bitset = BitsUtil.zero(numdim); // convert longValues into zValues final long mask = 1L << 63 - iter; for (int dim = 0; dim < numdim; dim++) { if ((coords[dim] & mask) != 0) { BitsUtil.setI(bitset, dim); } } return bitset; }
/** * Select the "iter" highest bit from each dimension. * * @param coords Input coordinates * @param iter Bit position (from highest position) * @return One bit per dimension */ public static long[] interleaveBits(short[] coords, int iter) { final int numdim = coords.length; final long[] bitset = BitsUtil.zero(numdim); // convert longValues into zValues final long mask = 1L << 15 - iter; for (int dim = 0; dim < numdim; dim++) { if ((coords[dim] & mask) != 0) { BitsUtil.setI(bitset, dim); } } return bitset; }
/** * Select the "iter" highest bit from each dimension. * * @param coords Input coordinates * @param iter Bit position (from highest position) * @return One bit per dimension */ public static long[] interleaveBits(byte[] coords, int iter) { final int numdim = coords.length; final long[] bitset = BitsUtil.zero(numdim); // convert longValues into zValues final long mask = 1L << 7 - iter; for (int dim = 0; dim < numdim; dim++) { if ((coords[dim] & mask) != 0) { BitsUtil.setI(bitset, dim); } } return bitset; } }
@Override public BitVector fromByteBuffer(ByteBuffer buffer) throws IOException { short dimensionality = buffer.getShort(); final int len = ByteArrayUtil.SIZE_SHORT + (dimensionality + 7) / 8; if(buffer.remaining() < len) { throw new IOException("Not enough data for a bit vector!"); } // read values long[] bits = BitsUtil.zero(dimensionality); byte b = 0; for(int i = 0; i < dimensionality; i++) { // read the next byte when needed. if((i & 7) == 0) { b = buffer.get(); } final byte bit = (byte) (1 << (i & 7)); if((b & bit) != 0) { BitsUtil.setI(bits, i); } } return new BitVector(bits, dimensionality); }
@Override public long[] getVisibleDimensions2D() { final int dim = proj.getDimensionality(); long[] actDim = BitsUtil.zero(dim); double[] vScale = new double[dim]; for(int d = 0; d < dim; d++) { Arrays.fill(vScale, 0); vScale[d] = 1; double[] vRender = fastProjectScaledToRenderSpace(vScale); // TODO: Can't we do this by inspecting the projection matrix directly? if(vRender[0] > 0.0 || vRender[0] < 0.0 || vRender[1] != 0) { BitsUtil.setI(actDim, d); } } return actDim; } }
@Override public <A> BitVector newFeatureVector(A array, ArrayAdapter<? extends Number, A> adapter) { int dim = adapter.size(array); long[] bits = BitsUtil.zero(dim); for(int i = 0; i < dim; i++) { if(adapter.get(array, i).doubleValue() >= 0.5) { BitsUtil.setI(bits, i); } } return new BitVector(bits, dim); }
/** * Constructor. * * @param clusterCore Signature */ public ClusterCandidate(Signature clusterCore) { this.dimensions = BitsUtil.zero(clusterCore.spec.length >> 1); for(int i = 0; i < clusterCore.spec.length; i += 2) { BitsUtil.setI(this.dimensions, i >> 1); } this.ids = DBIDUtil.newArray(clusterCore.ids.size()); } }
@Override public <A> BitVector newNumberVector(A array, NumberArrayAdapter<?, ? super A> adapter) { int dim = adapter.size(array); long[] bits = BitsUtil.zero(dim); for(int i = 0; i < dim; i++) { if(adapter.getDouble(array, i) >= 0.5) { BitsUtil.setI(bits, i); } } return new BitVector(bits, dim); }
@Override public <E extends SpatialComparable, A> long[] split(A entries, ArrayAdapter<E, A> getter, int minEntries) { Split<A, E> split = new Split<>(entries, getter); split.chooseSplitAxis(minEntries); split.chooseSplitPoint(minEntries); assert (split.splitPoint < split.size) : "Invalid split produced. Size: " + getter.size(entries) + " minEntries: " + minEntries + " split.size: " + split.size; long[] assignment = BitsUtil.zero(split.size); for(int i = split.splitPoint; i < split.size; i++) { BitsUtil.setI(assignment, split.bestSorting[i].second); } return assignment; }
@Override public BitVector newNumberVector(TIntDoubleMap values, int maxdim) { long[] bits = BitsUtil.zero(maxdim); // Import and sort the indexes for(TIntDoubleIterator iter = values.iterator(); iter.hasNext();) { iter.advance(); if(iter.value() != 0.) { BitsUtil.setI(bits, iter.key()); } } return new BitVector(bits, maxdim); }
@Override public <N extends AbstractRStarTreeNode<N, E>, E extends SpatialEntry> boolean handleOverflow(AbstractRStarTree<N, E, ?> tree, N node, IndexTreePath<E> path) { final int depthm1 = path.getPathCount() - 1; // No reinsertions at root level if(depthm1 == 0) { return false; } // Earlier reinsertions at the same level if(BitsUtil.capacity(reinsertions) < depthm1) { reinsertions = BitsUtil.copy(reinsertions, depthm1); } if(BitsUtil.get(reinsertions, depthm1)) { return false; } BitsUtil.setI(reinsertions, depthm1); final E entry = path.getEntry(); assert (!entry.isLeafEntry()) : "Unexpected leaf entry"; int[] cands = reinsertStrategy.computeReinserts(node, NodeArrayAdapter.STATIC, entry); if(cands == null || cands.length == 0) { return false; } tree.reInsert(node, path, cands); return true; }