/* =============================================================================
* data_generate
* -- Binary variables of random PDFs
* -- If seed is <0, do not reseed
* -- Returns random network
* =============================================================================
*/
net_t*
data_generate (data_t* dataPtr, long seed, long maxNumParent, long percentParent)
{
random_t* randomPtr = dataPtr->randomPtr;
if (seed >= 0) {
random_seed(randomPtr, seed);
}
/*
* Generate random Bayesian network
*/
long numVar = dataPtr->numVar;
net_t* netPtr = net_alloc(numVar);
assert(netPtr);
net_generateRandomEdges(netPtr, maxNumParent, percentParent, randomPtr);
/*
* Create a threshold for each of the possible permutation of variable
* value instances
*/
long** thresholdsTable = (long**)SEQ_MALLOC(numVar * sizeof(long*));
assert(thresholdsTable);
long v;
for (v = 0; v < numVar; v++) {
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, v);
long numThreshold = 1 << list_getSize(parentIdListPtr);
long* thresholds = (long*)SEQ_MALLOC(numThreshold * sizeof(long));
assert(thresholds);
long t;
for (t = 0; t < numThreshold; t++) {
long threshold = random_generate(randomPtr) % (DATA_PRECISION + 1);
thresholds[t] = threshold;
}
thresholdsTable[v] = thresholds;
}
/*
* Create variable dependency ordering for record generation
*/
long* order = (long*)SEQ_MALLOC(numVar * sizeof(long));
assert(order);
long numOrder = 0;
queue_t* workQueuePtr = queue_alloc(-1);
assert(workQueuePtr);
vector_t* dependencyVectorPtr = vector_alloc(1);
assert(dependencyVectorPtr);
bitmap_t* orderedBitmapPtr = bitmap_alloc(numVar);
assert(orderedBitmapPtr);
bitmap_clearAll(orderedBitmapPtr);
bitmap_t* doneBitmapPtr = bitmap_alloc(numVar);
assert(doneBitmapPtr);
bitmap_clearAll(doneBitmapPtr);
v = -1;
while ((v = bitmap_findClear(doneBitmapPtr, (v + 1))) >= 0) {
list_t* childIdListPtr = net_getChildIdListPtr(netPtr, v);
long numChild = list_getSize(childIdListPtr);
if (numChild == 0) {
bool status;
/*
* Use breadth-first search to find net connected to this leaf
*/
queue_clear(workQueuePtr);
status = queue_push(workQueuePtr, (void*)v);
assert(status);
while (!queue_isEmpty(workQueuePtr)) {
long id = (long)queue_pop(workQueuePtr);
status = bitmap_set(doneBitmapPtr, id);
assert(status);
status = vector_pushBack(dependencyVectorPtr, (void*)id);
assert(status);
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, id);
list_iter_t it;
list_iter_reset(&it, parentIdListPtr);
while (list_iter_hasNext(&it, parentIdListPtr)) {
long parentId = (long)list_iter_next(&it, parentIdListPtr);
status = queue_push(workQueuePtr, (void*)parentId);
assert(status);
}
}
/*
* Create ordering
*/
long i;
long n = vector_getSize(dependencyVectorPtr);
for (i = 0; i < n; i++) {
long id = (long)vector_popBack(dependencyVectorPtr);
if (!bitmap_isSet(orderedBitmapPtr, id)) {
bitmap_set(orderedBitmapPtr, id);
order[numOrder++] = id;
}
}
}
}
assert(numOrder == numVar);
/*
* Create records
*/
char* record = dataPtr->records;
long r;
long numRecord = dataPtr->numRecord;
for (r = 0; r < numRecord; r++) {
long o;
for (o = 0; o < numOrder; o++) {
long v = order[o];
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, v);
long index = 0;
list_iter_t it;
list_iter_reset(&it, parentIdListPtr);
while (list_iter_hasNext(&it, parentIdListPtr)) {
long parentId = (long)list_iter_next(&it, parentIdListPtr);
long value = record[parentId];
assert(value != DATA_INIT);
index = (index << 1) + value;
}
long rnd = random_generate(randomPtr) % DATA_PRECISION;
long threshold = thresholdsTable[v][index];
record[v] = ((rnd < threshold) ? 1 : 0);
}
record += numVar;
assert(record <= (dataPtr->records + numRecord * numVar));
}
/*
* Clean up
*/
bitmap_free(doneBitmapPtr);
bitmap_free(orderedBitmapPtr);
vector_free(dependencyVectorPtr);
queue_free(workQueuePtr);
SEQ_FREE(order);
for (v = 0; v < numVar; v++) {
SEQ_FREE(thresholdsTable[v]);
}
SEQ_FREE(thresholdsTable);
return netPtr;
}
int
main ()
{
bitmap_t* bitmapPtr;
long numBit = 32;
long i;
long j;
srand(0);
puts("Starting...");
bitmapPtr = bitmap_alloc(numBit);
assert(bitmapPtr->numBit == numBit);
assert(bitmapPtr->numWord == (DIVIDE_AND_ROUND_UP(numBit, NUM_BIT_PER_WORD)));
/* Check that initial is all clear */
for (i = 0; i < numBit; i++) {
assert(bitmap_isClear(bitmapPtr, i));
assert(!bitmap_isSet(bitmapPtr, i));
}
assert(bitmap_getNumClear(bitmapPtr) == numBit);
assert(bitmap_getNumSet(bitmapPtr) == 0);
/* Check bounds */
assert(!bitmap_clear(bitmapPtr, -1));
assert(!bitmap_set(bitmapPtr, -1));
assert(!bitmap_clear(bitmapPtr, numBit+1));
assert(!bitmap_set(bitmapPtr, numBit+1));
/* Set random bits */
for (i = 0, j = 0; i < numBit; i+=(rand() % 5 + 1)) {
assert(bitmap_set(bitmapPtr, i));
assert(bitmap_set(bitmapPtr, i));
assert(bitmap_clear(bitmapPtr, i));
assert(bitmap_set(bitmapPtr, i));
assert(bitmap_set(bitmapPtr, i));
assert(bitmap_isSet(bitmapPtr, i));
j++;
}
assert(bitmap_getNumClear(bitmapPtr) == (numBit - j));
assert(bitmap_getNumSet(bitmapPtr) == j);
/* Clear set bits */
while ((i = bitmap_findSet(bitmapPtr, -1)) >= 0) {
assert(bitmap_clear(bitmapPtr, i));
i++;
}
assert(bitmap_getNumClear(bitmapPtr) == numBit);
assert(bitmap_getNumSet(bitmapPtr) == 0);
assert(bitmap_findSet(bitmapPtr, -1) == -1);
/* Set all bits */
i = -1;
while ((i = bitmap_findClear(bitmapPtr, i)) >= 0) {
assert(bitmap_set(bitmapPtr, i));
i++;
}
assert(bitmap_getNumClear(bitmapPtr) == 0);
assert(bitmap_getNumSet(bitmapPtr) == numBit);
assert(bitmap_findClear(bitmapPtr, -1) == -1);
/* Clear random bits */
for (i = 0, j = 0; i < numBit; i+=(rand() % 5 + 1)) {
assert(bitmap_clear(bitmapPtr, i));
assert(bitmap_clear(bitmapPtr, i));
assert(bitmap_set(bitmapPtr, i));
assert(bitmap_clear(bitmapPtr, i));
assert(bitmap_clear(bitmapPtr, i));
assert(bitmap_isClear(bitmapPtr, i));
j++;
}
assert(bitmap_getNumClear(bitmapPtr) == j);
assert(bitmap_getNumSet(bitmapPtr) == (numBit - j));
bitmap_free(bitmapPtr);
puts("All tests passed.");
return 0;
}
