public boolean equals(final LongArrayBitVector v, final long start, final long end) { int startWord = (int)(start >>> LongArrayBitVector.LOG2_BITS_PER_WORD); final int endWord = (int)(end >>> LongArrayBitVector.LOG2_BITS_PER_WORD); final int startBit = (int)(start & LongArrayBitVector.WORD_MASK); final int endBit = (int)(end & LongArrayBitVector.WORD_MASK); final long[] aBits = bits(); final long[] bBits = v.bits(); if (startWord == endWord) return ((aBits[startWord] ^ bBits[startWord]) & ((1L << (endBit - startBit)) - 1) << startBit) == 0; if (((aBits[startWord] ^ bBits[startWord++]) & (-1L << startBit)) != 0) return false; while(startWord < endWord) if (aBits[startWord] != bBits[startWord++]) return false; return ((aBits[endWord] ^ bBits[endWord]) & (1L << endBit) - 1) == 0; }
private void readObject(final ObjectInputStream s) throws IOException, ClassNotFoundException { s.defaultReadObject(); array = bitVector.bits(); }
private void readObject(final ObjectInputStream s) throws IOException, ClassNotFoundException { s.defaultReadObject(); array = bitVector.bits(); }
protected Modulo2Equation(final Modulo2Equation equation){ this.c = equation.c; this.bitVector = equation.bitVector.copy(); this.bits = this.bitVector.bits(); this.firstVar = equation.firstVar; this.isEmpty = equation.isEmpty; }
/** Creates a new equation. * * @param c the constant term. * @param numVars the number of variables. */ public Modulo2Equation(final long c, final int numVars){ this.c = c; this.bitVector = LongArrayBitVector.ofLength(numVars); this.bits = bitVector.bits(); this.firstVar = Integer.MAX_VALUE; this.isEmpty = true; }
protected Modulo3Equation(final Modulo3Equation equation){ this.c = equation.c; this.bitVector = equation.bitVector.copy(); this.bits = this.bitVector.bits(); this.list = this.bitVector.asLongBigList(2); this.firstVar = equation.firstVar; this.firstCoeff = equation.firstCoeff; this.isEmpty = equation.isEmpty; }
public boolean check(final LongArrayBitVector solutions) { assert solutions.length() == numVars * 2; final long[] solutionBits = solutions.bits(); for(final Modulo3Equation equation: equations) if (equation.c != Modulo3Equation.scalarProduct(equation.bits, solutionBits) % 3) return false; return true; }
/** Creates a new equation. * * @param c the constant term. * @param numVars the number of variables. */ public Modulo3Equation(final long c, final int numVars) { this.c = c; this.bitVector = LongArrayBitVector.ofLength(numVars * 2); this.bits = bitVector.bits(); this.list = bitVector.asLongBigList(2); this.firstVar = Integer.MAX_VALUE; this.isEmpty = true; }
public long append( final LongArrayBitVector bv ) throws IOException { return append( bv.bits(), bv.length() ); }
public long append( final LongArrayBitVector bv ) throws IOException { return append( bv.bits(), bv.length() ); }
public long append(final LongArrayBitVector bv) throws IOException { return append(bv.bits(), bv.length()); }
public void dump(final String file) throws IOException { final ByteBuffer buffer = ByteBuffer.allocateDirect(offsetAndSeed.length * 8 + 40).order(ByteOrder.nativeOrder()); final FileOutputStream fos = new FileOutputStream(file); final FileChannel channel = fos.getChannel(); buffer.clear(); buffer.putLong(size64()); buffer.putLong(width); buffer.putLong(chunkShift); buffer.putLong(globalSeed); buffer.putLong(offsetAndSeed.length); for(final long l : offsetAndSeed) buffer.putLong(l); buffer.flip(); channel.write(buffer); buffer.clear(); final LongArrayBitVector v = LongArrayBitVector.getInstance().ensureCapacity(data.size64() * width); for(final long d: data) v.append(d, width); final long[] array = v.bits(); buffer.putLong(array.length); for(final long l: array) { if (!buffer.hasRemaining()) { buffer.flip(); channel.write(buffer); buffer.clear(); } buffer.putLong(l); } buffer.flip(); channel.write(buffer); fos.close(); }
bits[i] = bitVector.bits(); registers[i] = bitVector.asLongBigList(registerSize);
/** Solves the system using Gaussian elimination and write the solution * in a bit vector. * * @param solution a bit vector where the solution will be written using * two bits per value. * @return true if the system is solvable. */ public boolean gaussianElimination(final LongArrayBitVector solution) { assert solution.length() == numVars * 2; for (final Modulo3Equation equation: equations) equation.updateFirstVar(); if (! echelonForm()) return false; final long[] solutionBits = solution.bits(); final LongBigList solutionList = solution.asLongBigList(2); for (int i = equations.size(); i-- != 0;) { final Modulo3Equation equation = equations.get(i); if (equation.isIdentity()) continue; assert solutionList.getLong(equation.firstVar) == 0 : equation.firstVar; long sum = (equation.c - Modulo3Equation.scalarProduct(equation.bits, solutionBits)) % 3; if (sum < 0) sum += 3; solutionList.set(equation.firstVar, sum == 0 ? 0 : equation.firstCoeff == sum ? 1 : 2); } return true; } /** Solves the system using lazy Gaussian elimination.
this.lowerBits = lowerBitsVector.bits(); selectUpper = new SimpleSelect(upperBits);
lowerBits = lowerBitsVector.bits(); selectZeroUpper = new SimpleSelectZero(upperBits); fromSelect = false;
array = bitVector.bits();
if (! denseSystem.gaussianElimination(solutions)) return false; // numVars >= denseSystem.numVars final long[] solutionBits = solutions.bits(); final LongBigList solutionList = solutions.asLongBigList(2);
array = bitVector.bits();