void CDCStatsticsMethod::conduct_cdc_screening(std::vector<std::vector<double>> &x,
std::vector<uint> &x_variable_index,
std::vector<std::vector<double>> &distance_y,
std::vector<std::vector<double>> &kernel, double index) {
std::vector<uint> variable_sequence;
std::vector<std::vector<double>> submatrix;
std::vector<std::vector<double>> distance_x;
ConditionDistanceCovarianceStats conditionDistanceCovarianceStats = ConditionDistanceCovarianceStats(distance_x,
distance_y,
kernel, 2);
for (int i = (int) (x_variable_index.size() - 1); i >= 0; --i) {
// extract variable index
if (i != 0) {
variable_sequence = generate_sequence(x_variable_index[i - 1] + 1, x_variable_index[i]);
} else {
variable_sequence = generate_sequence(0, x_variable_index[0]);
}
submatrix = extract_submatrix_byrow(x, variable_sequence);
// compute statistics
distance_x = Euclidean_distance_byrow(submatrix, index);
conditionDistanceCovarianceStats.setDistance_x(distance_x);
conditionDistanceCovarianceStats.compute_stats();
this->cdc_statistic.push_back(conditionDistanceCovarianceStats.getCondition_distance_covariance_stats());
}
reverse(this->cdc_statistic.begin(), this->cdc_statistic.end());
}
int main(int argc, char *argv[]) {
int max_used_memory;
int allocation_factor;
int memory_required;
SEQLIST *test_sequence;
max_used_memory = 2000;
allocation_factor = 11;
printf("running with MAX_USED_MEMORY=%d and ALLOCATION_FACTOR=%d\n",
max_used_memory, allocation_factor);
test_sequence = generate_sequence(max_used_memory, allocation_factor);
if (VERBOSE)
seq_print(test_sequence);
// check that allocation can actually do something.
// This becomes upper bound on binary search.
if (try_sequence(test_sequence, max_used_memory * allocation_factor * 2)) {
// binary search for smallest MEMORY_SIZE which can accommodate
memory_required = binary_search_required_memory(test_sequence,
max_used_memory - 1, max_used_memory * allocation_factor * 2);
// run it one more time at the identified size.
// this makes sure that the data is set from a successful run.
if (try_sequence(test_sequence, memory_required)) {
// check if data contents are intact
if (check_data(test_sequence)) {
printf("Data integrity FAIL.\n");
}
else {
printf("Data integrity PASS.\n");
}
// print statistics
printf("Memory utilization: (%d/%d)=%f\n", max_used_memory, memory_required,
((double) max_used_memory / (double) memory_required));
}
else {
printf("Consistency problem: binary_search_reqruired_memory "
"returned %d, but final test failed\n", memory_required);
}
}
else {
printf("Requires more memory than the no-free case.\n");
}
}
int main(void)
{
int size;
printf("Please input the size: ");
scanf("%d", &size);
int *array = (int *) malloc (sizeof(int) * size);
generate_sequence(array, size);
print(array, size);
putchar('\n');
free(array);
return 0;
}
int main(int argc, char* argv[]) {
set_test_name(argv[0]);
HMM* hmm = malloc(sizeof(*hmm));
hmm->num_states = 3;
hmm->num_tokens = 2;
hmm->state_distribution_total = malloc(3 * sizeof(*hmm->state_distribution_total));
hmm->state_distribution = malloc(3 * sizeof(*hmm->state_distribution));
hmm->tokens = malloc(2 * sizeof(*hmm->tokens));
hmm->token_distribution_total = malloc(3 * sizeof(*hmm->token_distribution_total));
hmm->token_distribution = malloc(3 * sizeof(*hmm->token_distribution));
hmm->state_distribution_total[0] = 1;
hmm->state_distribution_total[1] = 1;
hmm->state_distribution_total[2] = 1;
hmm->state_distribution[0] = malloc(4 * sizeof(*hmm->state_distribution[0]));
hmm->state_distribution[0][0] = 0;
hmm->state_distribution[0][1] = 1;
hmm->state_distribution[0][2] = 0;
hmm->state_distribution[0][3] = 0;
hmm->state_distribution[1] = malloc(4 * sizeof(*hmm->state_distribution[1]));
hmm->state_distribution[1][0] = 0;
hmm->state_distribution[1][1] = 0;
hmm->state_distribution[1][2] = 1;
hmm->state_distribution[1][3] = 0;
hmm->state_distribution[2] = malloc(4 * sizeof(*hmm->state_distribution[2]));
hmm->state_distribution[2][0] = 0;
hmm->state_distribution[2][1] = 0;
hmm->state_distribution[2][2] = 0;
hmm->state_distribution[2][3] = 1;
hmm->tokens[0] = "a";
hmm->tokens[1] = "the";
hmm->token_distribution_total[0] = 0;
hmm->token_distribution_total[1] = 1;
hmm->token_distribution_total[2] = 1;
hmm->token_distribution[0] = malloc(2 * sizeof(*hmm->token_distribution[0]));
hmm->token_distribution[0][0] = 0;
hmm->token_distribution[0][1] = 0;
hmm->token_distribution[1] = malloc(2 * sizeof(*hmm->token_distribution[1]));
hmm->token_distribution[1][0] = 1;
hmm->token_distribution[1][1] = 0;
hmm->token_distribution[2] = malloc(2 * sizeof(*hmm->token_distribution[2]));
hmm->token_distribution[2][0] = 0;
hmm->token_distribution[2][1] = 1;
int expected_length = 2;
char** expected_sequence = malloc(2 * sizeof(*expected_sequence));
expected_sequence[0] = "a";
expected_sequence[1] = "the";
char** actual_sequence = malloc(5 * sizeof(*actual_sequence));
// Test generating full-length (nonbinding max_length)
assert_int_e(expected_length, generate_sequence(hmm, actual_sequence, 5));
assert_stra_e(expected_sequence, actual_sequence, expected_length);
expected_length = 1;
expected_sequence[0] = "a";
expected_sequence[1] = NULL;
actual_sequence[0] = NULL;
actual_sequence[1] = NULL;
// Test binding max_length
assert_int_e(expected_length, generate_sequence(hmm, actual_sequence, 1));
assert_stra_e(expected_sequence, actual_sequence, expected_length);
finish_test();
return 0;
}
