static void testBitvectorInduction()
{
SlowBitvector testBitvector = new SlowBitvector();
//testBitvector.vector = new bool[]{false, true, false, false};
testBitvector.vector = new List <bool>()
{
false, true, false, true,
};
induction.BitvectorInduction.predictNextBit(testBitvector, 1);
}
/*
* public static bool equals(SlowBitvector a, SlowBitvector b) {
* if (a.vector.Count != b.vector.Count) {
* return false;
* }
*
* for (int i = 0; i < a.vector.Count; i++) {
* if (a.vector[i] != b.vector[i]) {
* return false;
* }
* }
*
* return true;
* }
*/
public SlowBitvector subvector(uint startIndex, uint endIndex)
{
Debug.Assert(endIndex >= startIndex, "Negative length is not valid!");
SlowBitvector result = new SlowBitvector();
result.vector = new List <bool>(new bool[endIndex - startIndex]);
int iResult = 0;
for (int i = (int)startIndex; i < (int)endIndex; i++)
{
result.vector[iResult] = vector[i];
iResult++;
}
return(result);
}
// for debugging
private static string debugBitvector(SlowBitvector vector)
{
StringBuilder sb = new StringBuilder();
foreach (bool iterationValue in vector.vector)
{
if (iterationValue)
{
sb.Append("1");
}
else
{
sb.Append("0");
}
}
return(sb.ToString());
}
static void testBitvectorInductionSequence1()
{
SlowBitvector testBitvector = new SlowBitvector();
/*
* testBitvector.vector = new List<bool>() {
* true, true, false, false,
* };
*/
testBitvector.vector = new List <bool>()
{
false, false, false,
false, false, true,
false, true, false,
false, true, true,
true, false, false,
true, false, true,
true, true, false,
};
bool predictedBit;
induction.BitvectorInduction.Prediction prediction;
for (int i = 0; i < 1; i++)
{
prediction = induction.BitvectorInduction.predictNextBit(testBitvector, 1);
predictedBit = prediction.trueCounter > prediction.falseCounter;
Console.WriteLine("predicted {0}", predictedBit);
testBitvector.vector.Add(predictedBit);
}
int breakHere = 1;
}
private static bool doesMatch(SlowBitvector deductionString, SlowBitvector candidateBitvector, int insertionIndex)
{
if (insertionIndex + candidateBitvector.vector.Count <= deductionString.vector.Count)
{
return(false);
}
int overlapEndIndex = Math.Min(deductionString.vector.Count, insertionIndex + candidateBitvector.vector.Count);
int overlapLength = overlapEndIndex - insertionIndex;
Debug.Assert(overlapLength >= 0, "Overlap length isn't allowed to be negative!");
// fast exit
if (overlapLength == 0)
{
return(true);
}
SlowBitvector cuttedDeductionString = deductionString.subvector((uint)insertionIndex, (uint)overlapEndIndex);
SlowBitvector cuttedCandidateBitvector = candidateBitvector.subvector(0, (uint)overlapLength);
return(checkOverlapEqual(cuttedDeductionString, cuttedCandidateBitvector));
}
public static Prediction predictNextBit(SlowBitvector deductionString, uint order)
{
Debug.Assert(order != 0, "Order is not allowed to be zero!");
if (order == 0)
{
throw new SystemException("Order is not allowed to be zero!");
}
bool isOrderInfinite = order == -1;
// TODO< implement for infinite order (== -1) and other orders
Debug.Assert(order == 1, "Only implemented for order == 1! TODO");
ulong
falseCounter = 0,
trueCounter = 0;
// should take continuation without direct evidence into account?
bool takeFloatingonsiderationIntoAccount = true;
int startIndexDeltaFromEnding = takeFloatingonsiderationIntoAccount ? 0 : -1;
for (int insertionIndex = deductionString.vector.Count + startIndexDeltaFromEnding; insertionIndex >= 1; insertionIndex--)
{
Console.WriteLine("InsertionIndex={0}", insertionIndex);
for (int startIndex = 0; startIndex < deductionString.vector.Count + 1; startIndex++)
{
for (int endIndex = startIndex + 1; endIndex < deductionString.vector.Count + 1; endIndex++)
{
SlowBitvector deductionStringSub = deductionString.subvector((uint)startIndex, (uint)endIndex);
Console.WriteLine("");
Console.WriteLine("{0}", debugBitvector(deductionString));
Console.WriteLine("{0}", generateVoidString((uint)insertionIndex) + debugBitvector(deductionStringSub));
bool matches = doesMatch(deductionString, deductionStringSub, insertionIndex);
Console.WriteLine("does match={0}", matches);
// TODO< if does match the extract the candidate bit and increment the counter >
if (matches && (insertionIndex + endIndex >= deductionString.vector.Count))
{
Console.WriteLine("==>HERE");
// extract candidate bit
int deductionStringSubIndex = deductionString.vector.Count - insertionIndex;
bool candidateSymbol = deductionStringSub.vector[deductionStringSubIndex];
if (candidateSymbol)
{
trueCounter++;
}
else
{
falseCounter++;
}
}
}
}
}
return(new Prediction(trueCounter, falseCounter));
}
/*
* private static void countPossibleExtensionsOf(SlowBitvector deductionString, SlowBitvector testVector, ref ulong falseCounter, ref ulong trueCounter) {
* Console.WriteLine("countPossibleExtensionsOf()");
*
* for (int deltaIn = 0; deltaIn < Math.Min(deductionString.vector.Length, testVector.vector.Length); deltaIn++) {
* SlowBitvector beginOverlap = deductionString.subvector((uint)(deductionString.vector.Length - 1 - deltaIn), (uint)(deductionString.vector.Length - 1));
*
* Console.WriteLine(" beginOverlapVector={0}", debugBitvector(beginOverlap));
*
* bool isValidOverlap = checkValidOverlap(beginOverlap, testVector);
* if (!isValidOverlap) {
* continue;
* }
*
* Console.WriteLine(" (is valid overlap)");
*
*
* // extract bit and count up
* // BUGGY; TODO
* bool extractedCandidateBit = testVector.vector[deltaIn];
*
* Console.WriteLine(" extractedCandidateBit={0}", extractedCandidateBit);
*
* if (extractedCandidateBit) { trueCounter++; }
* else { falseCounter++; }
* }
* }*/
private static bool checkOverlapEqual(SlowBitvector a, SlowBitvector b)
{
Debug.Assert(a.vector.Count == b.vector.Count, "Must have same length!");
return(a == b);
}
