/// <summary>
/// Replaces the bits of the receiver in the given range with the bits of another bit vector.
/// Replaces the range <i>[from,to]</i> with the contents of the range <i>[sourceFrom,sourceFrom+to-from]</i>, all inclusive.
/// If <i>source==this</i> and the source and destination range intersect in an ambiguous way, then replaces as if using an intermediate auxiliary copy of the receiver.
/// <p>
/// Optimized for speedd Preliminary performance (200Mhz Pentium Pro, JDK 1.2, NT): replace 10^6 ill aligned bits --> 0.02 seconds elapsed time.
/// </summary>
/// <param name="from">the start index within the receiver, inclusive.</param>
/// <param name="to">the end index within the receiver, inclusive.</param>
/// <param name="source">the source bitvector to copy from.</param>
/// <param name="sourceFrom">the start index within <i>source</i>, inclusive.</param>
/// <exception cref="IndexOutOfRangeException">if <i>Size>0 && (from<0 || from>to || to>=Size || sourceFrom<0 || sourceFrom+to-from+1>source.Count))</i>.</exception>
public void ReplaceFromToWith(int from, int to, BitVector source, int sourceFrom)
{
if (nbits == 0 || to == from - 1)
{
return;
}
CheckRangeFromTo(from, to, nbits);
int Length = to - from + 1;
if (sourceFrom < 0 || sourceFrom + Length > source.Size)
{
throw new IndexOutOfRangeException();
}
if (source.bits == this.bits && from <= sourceFrom && sourceFrom <= to)
{ // dangerous intersection
source = source.Copy();
}
long[] theBits = this.bits; // cached for speed.
long[] sourceBits = source.bits; // cached for speed.
/*
* This version is equivalent to the version below but 20 times slower..
* for (int i=from; --Length >= 0; i++, sourceFrom++) {
* QuickBitVector.Put(theBits,i,QuickBitVector.Get(sourceBits,sourceFrom));
* }
*/
// Low level implementation for speed.
// This could be done even faster by implementing on even lower levelsd But then the code would probably become a "don't touch" piece.
int width = to - from + 1;
int blocks = QuickBitVector.Unit(width); // width/64
int bitsPerUnit = QuickBitVector.BITS_PER_UNIT;
int bitsPerUnitMinusOne = bitsPerUnit - 1;
// copy entire 64 bit blocks, if any.
for (int i = blocks; --i >= 0;)
{
long val1 = QuickBitVector.GetLongFromTo(sourceBits, sourceFrom, sourceFrom + bitsPerUnitMinusOne);
QuickBitVector.PutLongFromTo(theBits, val1, from, from + bitsPerUnitMinusOne);
sourceFrom += bitsPerUnit;
from += bitsPerUnit;
}
// copy trailing bits, if any.
int offset = QuickBitVector.Offset(width); //width%64
long val2 = QuickBitVector.GetLongFromTo(sourceBits, sourceFrom, sourceFrom + offset - 1);
QuickBitVector.PutLongFromTo(theBits, val2, from, from + offset - 1);
}
/// <summary>
/// Sets bits of the receiver from index <code>from</code> to index <code>to</code> to the bits of <code>value</code>.
/// Bit <code>from</code> is set to bit 0 of <code>value</code>, .d, bit <code>to</code> is set to bit <code>to-from</code> of <code>value</code>.
/// All other bits stay unaffected.
/// If <i>to-from+1==0</i> then does nothing.
/// </summary>
/// <param name="value">the value to be copied into the receiver.</param>
/// <param name="from">index of start bit (inclusive).</param>
/// <param name="to">index of end bit (inclusive).</param>
/// <exception cref="IndexOutOfRangeException">if <i>from<0 || from>=Size || to<0 || to>=Size || to-from+1<0 || to-from+1>64</i>.</exception>
public void PutLongFromTo(long value, int from, int to)
{
int width = to - from + 1;
if (width == 0)
{
return;
}
if (from < 0 || from >= nbits || to < 0 || to >= nbits || width < 0 || width > QuickBitVector.BITS_PER_UNIT)
{
throw new IndexOutOfRangeException("from:" + from + ", to:" + to);
}
QuickBitVector.PutLongFromTo(bits, value, from, to);
}
/// <summary>
/// Sets the bits in the given range to the state specified by <i>value</i>.
/// <p>
/// Optimized for speedd Preliminary performance (200Mhz Pentium Pro, JDK 1.2, NT): replace 10^6 ill aligned bits --> 0.002 seconds elapsed time.
/// </summary>
/// <param name="from">the start index, inclusive.</param>
/// <param name="to">the end index, inclusive.</param>
/// <param name="value">the value to be stored in the bits of the range.</param>
/// <exception cref="IndexOutOfRangeException">if <i>Size>0 && (from<0 || from>to || to>=Size)</i>.</exception>
public void ReplaceFromToWith(int from, int to, Boolean value)
{
if (nbits == 0 || to == from - 1)
{
return;
}
CheckRangeFromTo(from, to, nbits);
long[] theBits = this.bits; // cached for speed
int fromUnit = QuickBitVector.Unit(from);
int fromOffset = QuickBitVector.Offset(from);
int toUnit = QuickBitVector.Unit(to);
int toOffset = QuickBitVector.Offset(to);
int bitsPerUnit = QuickBitVector.BITS_PER_UNIT;
long filler;
if (value)
{
filler = ~0L;
}
else
{
filler = 0L;
}
int bitIndex = from;
if (fromUnit == toUnit)
{ // only one unit to do
QuickBitVector.PutLongFromTo(theBits, filler, bitIndex, bitIndex + to - from);
//slower: for (; bitIndex<=to; ) QuickBitVector.Put(theBits,bitIndex++,value);
return;
}
// treat leading partial unit, if any.
if (fromOffset > 0)
{ // fix by Olivier Janssens
QuickBitVector.PutLongFromTo(theBits, filler, bitIndex, bitIndex + bitsPerUnit - fromOffset);
bitIndex += bitsPerUnit - fromOffset + 1;
/* slower:
* for (int i=bitsPerUnit-fromOffset; --i >= 0; ) {
* QuickBitVector.Put(theBits,bitIndex++,value);
* }*/
fromUnit++;
}
if (toOffset < bitsPerUnit - 1)
{
toUnit--; // there is a trailing partial unit
}
// treat full units, if any.
for (int i = fromUnit; i <= toUnit;)
{
theBits[i++] = filler;
}
if (fromUnit <= toUnit)
{
bitIndex += (toUnit - fromUnit + 1) * bitsPerUnit;
}
// treat trailing partial unit, if any.
if (toOffset < bitsPerUnit - 1)
{
QuickBitVector.PutLongFromTo(theBits, filler, bitIndex, to);
/* slower:
* for (int i=toOffset+1; --i >= 0; ) {
* QuickBitVector.Put(theBits,bitIndex++,value);
* }*/
}
}
