コード例 #1
0
ファイル: data.c プロジェクト: jaingaurav/rstm
static void
testBasic (long numVar, long numRecord, long numMaxParent, long percentParent)
{
    random_t* randomPtr = random_alloc();

    puts("Starting...");

    data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr);
    assert(dataPtr);

    puts("Init:");
    data_generate(dataPtr, 0, numMaxParent, percentParent);

    long v;
    for (v = 0; v < numVar; v++) {
        data_sort(dataPtr, 0, numRecord, v);
        long s = data_findSplit(dataPtr, 0, numRecord, v);
        if (s < numRecord) {
            assert(dataPtr->records[numVar * s + v] == 1);
        }
        if (s > 0) {
            assert(dataPtr->records[numVar * (s - 1)  + v] == 0);
        }
    }

    memset(dataPtr->records, 0, dataPtr->numVar * dataPtr->numRecord);
    for (v = 0; v < numVar; v++) {
        data_sort(dataPtr, 0, numRecord, v);
        long s = data_findSplit(dataPtr, 0, numRecord, v);
        if (s < numRecord) {
            assert(dataPtr->records[numVar * s + v] == 1);
        }
        if (s > 0) {
            assert(dataPtr->records[numVar * (s - 1)  + v] == 0);
        }
        assert(s == numRecord);
    }

    memset(dataPtr->records, 1, dataPtr->numVar * dataPtr->numRecord);
    for (v = 0; v < numVar; v++) {
        data_sort(dataPtr, 0, numRecord, v);
        long s = data_findSplit(dataPtr, 0, numRecord, v);
        if (s < numRecord) {
            assert(dataPtr->records[numVar * s + v] == 1);
        }
        if (s > 0) {
            assert(dataPtr->records[numVar * (s - 1)  + v] == 0);
        }
        assert(s == 0);
    }

    data_free(dataPtr);
}
コード例 #2
0
ファイル: adtree.c プロジェクト: HPDCS/stmEnergyOptimization
/* =============================================================================
 * makeVary
 * =============================================================================
 */
static adtree_vary_t*
makeVary (long parentIndex,
          long index,
          long start,
          long numRecord,
          data_t* dataPtr)
{
    adtree_vary_t* varyPtr = allocVary(index);
    assert(varyPtr);

    if ((parentIndex + 1 != index) && (numRecord > 1)) {
        data_sort(dataPtr, start, numRecord, index);
    }

    long num0 = data_findSplit(dataPtr, start, numRecord, index);
    long num1 = numRecord - num0;

    long mostCommonValue = ((num0 >= num1) ? 0 : 1);
    varyPtr->mostCommonValue = mostCommonValue;

    if (num0 == 0 || mostCommonValue == 0) {
        varyPtr->zeroNodePtr = NULL;
    } else {
        varyPtr->zeroNodePtr =
            makeNode(index, index, start, num0, dataPtr);
        varyPtr->zeroNodePtr->value = 0;
    }

    if (num1 == 0 || mostCommonValue == 1) {
        varyPtr->oneNodePtr = NULL;
    } else {
        varyPtr->oneNodePtr =
            makeNode(index, index, (start + num0), num1, dataPtr);
        varyPtr->oneNodePtr->value = 1;
    }

    return varyPtr;
}
コード例 #3
0
ファイル: data.c プロジェクト: jaingaurav/rstm
static void
testAll (long numVar, long numRecord, long numMaxParent, long percentParent)
{
    random_t* randomPtr = random_alloc();

    puts("Starting...");

    data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr);
    assert(dataPtr);

    puts("Init:");
    net_t* netPtr = data_generate(dataPtr, 0, numMaxParent, percentParent);
    net_free(netPtr);
    printRecords(dataPtr);

    puts("Sort first half from 0:");
    data_sort(dataPtr, 0, numRecord/2, 0);
    printRecords(dataPtr);

    puts("Sort second half from 0:");
    data_sort(dataPtr, numRecord/2, numRecord-numRecord/2, 0);
    printRecords(dataPtr);

    puts("Sort all from mid:");
    data_sort(dataPtr, 0, numRecord, numVar/2);
    printRecords(dataPtr);

    long split = data_findSplit(dataPtr, 0, numRecord, numVar/2);
    printf("Split = %li\n", split);

    long v;
    for (v = 0; v < numVar; v++) {
        data_sort(dataPtr, 0, numRecord, v);
        long s = data_findSplit(dataPtr, 0, numRecord, v);
        if (s < numRecord) {
            assert(dataPtr->records[numVar * s + v] == 1);
        }
        if (s > 0) {
            assert(dataPtr->records[numVar * (s - 1)  + v] == 0);
        }
    }

    memset(dataPtr->records, 0, dataPtr->numVar * dataPtr->numRecord);
    for (v = 0; v < numVar; v++) {
        data_sort(dataPtr, 0, numRecord, v);
        long s = data_findSplit(dataPtr, 0, numRecord, v);
        if (s < numRecord) {
            assert(dataPtr->records[numVar * s + v] == 1);
        }
        if (s > 0) {
            assert(dataPtr->records[numVar * (s - 1)  + v] == 0);
        }
        assert(s == numRecord);
    }

    memset(dataPtr->records, 1, dataPtr->numVar * dataPtr->numRecord);
    for (v = 0; v < numVar; v++) {
        data_sort(dataPtr, 0, numRecord, v);
        long s = data_findSplit(dataPtr, 0, numRecord, v);
        if (s < numRecord) {
            assert(dataPtr->records[numVar * s + v] == 1);
        }
        if (s > 0) {
            assert(dataPtr->records[numVar * (s - 1)  + v] == 0);
        }
        assert(s == 0);
    }

    data_free(dataPtr);
}