int print_vector_int(vector<int>::iterator beg, vector<int>::iterator end)
{
while (beg != end)
{
cout << *beg << " ";
print_vector_int(std::next(beg), end);
}
return 0;
}
int main()
{
vector<int> v;
int i;
cout << "Enter a number" << endl;
while (cin >> i){
v.push_back(i);
}
cout << "The numbers you've entered: " << endl;
print_vector_int(v.begin(), v.end());
return 0;
}
int main()
{
srandom(time(0));
graph_t a;
vector_int v1;
vector_int_init_value_end(&v1, -1, 1,5, 2,5, 1,2, 2,1, 0,3, 0,2, 3,4, 3,6, 4,6, 6,4, -1,7, -1);
new_graph(&a, &v1, 0, GRAPH_DIRECTED);
print_graph_vectors(&a, stdout);
printf("ec=%d\t",graph_edges_count(&a));
printf("vc=%d\n",graph_vertices_count(&a));
int vc = graph_vertices_count(&a);
vector_int mem;
vector_int_init(&mem, vc);
vector_int_fill(&mem, -1);
vector_int cs;
vector_int_init(&cs, 0);
int cc;
graph_clusters_strong(&a,&mem,&cs,&cc);
printf("mem:");
print_vector_int(&mem, stdout);
printf("<<<combine vertices\n");
graph_t b;
graph_combine_vertices(&a, &mem, &b);
print_graph_vectors(&b, stdout);
printf("ec=%d\t",graph_edges_count(&b));
printf("vc=%d\n",graph_vertices_count(&b));
double re;
printf(">>>>randomly attack\n");
re = graph_fault_propagation(&b, 0.3, 0.2, GRAPH_ATK_RANDOM);
printf("random re=%f\n",re);
printf(">>>>outgoing based attack\n");
re = graph_fault_propagation(&b, 0.3, 0.2, GRAPH_ATK_OUTGOING);
printf("outgoing re=%f\n",re);
printf(">>>>incoming based attack\n");
re = graph_fault_propagation(&b, 0.3, 0.2, GRAPH_ATK_INCOMING);
printf("incoming re=%f\n",re);
vector_int inf;
vector_int_init(&inf, 0);
int cascading_nodes_count = graph_cascading_nodes_count(&b, &inf, 0.3, 0.2, GRAPH_ATK_RANDOM);
assert(cascading_nodes_count == vector_int_sum(&inf));
vector_int_destroy(&inf);
vector_int_destroy(&mem);
vector_int_destroy(&cs);
vector_int_destroy(&v1);
graph_destroy(&b);
graph_destroy(&a);
return 0;
}
void test_Cell()
{
std::vector<int> data;
Cell * A;
Cell * B;
Cell * C;
A=new Cell();
B=new Cell();
C=new Cell();
A->print_count();
data=A->get_data();
print_vector_int(A->get_data());
print_vector_int(A->get_row(1));
print_vector_int(A->get_col(1));
delete C;
delete A;
delete B;
}
void print_graph_vectors(const graph_t *graph, FILE *f)
{
print_vector_int(&(graph->from),f);
print_vector_int(&(graph->to),f);
print_vector_int(&(graph->oi),f);
print_vector_int(&(graph->ii),f);
print_vector_int(&(graph->os),f);
print_vector_int(&(graph->is),f);
}
int main()
{
vector_int a;
vector_int_init(&a,3);
printf("<<<init &a 3>>>\n");
print_vector_int(&a, stdout);
assert(3 == vector_int_size(&a));
assert(3 == vector_int_capacity(&a));
assert(0 == vector_int_e(&a, 0));
vector_int_insert(&a, 2, 10);
printf("<<<insert &a, 2, 10>>>\n");
assert(4 == vector_int_capacity(&a));
assert(4 == vector_int_size(&a));
assert(10 == vector_int_e(&a, 2));
assert(10 == *vector_int_e_ptr(&a, 2));
print_vector_int(&a, stdout);
vector_int_push_back(&a, 60);
printf("<<<push back &a, 60>>>\n");
assert(60 == vector_int_tail(&a));
assert(8 == vector_int_capacity(&a));
assert(5 == vector_int_size(&a));
assert(60 == vector_int_max(&a));
assert(4 == vector_int_which_max(&a));
assert(1 == vector_int_contains(&a, 60));
assert(0 == vector_int_contains(&a, 100));
print_vector_int(&a, stdout);
vector_int_resize_min(&a);
printf("<<<resize min &a>>>\n");
assert(60 == vector_int_tail(&a));
assert(5 == vector_int_capacity(&a));
assert(5 == vector_int_size(&a));
print_vector_int(&a, stdout);
printf("<<<pop_back &a>>>\n");
assert(60 == vector_int_pop_back(&a));
assert(5 == vector_int_capacity(&a));
assert(4 == vector_int_size(&a));
print_vector_int(&a, stdout);
vector_int_set(&a, 2, -12);
printf("<<<set &a 2 12>>>\n");
assert(-12 == VECTOR(a)[2]);
assert(5 == vector_int_capacity(&a));
assert(4 == vector_int_size(&a));
assert(-12 == vector_int_min(&a));
assert(2 == vector_int_which_min(&a));
print_vector_int(&a, stdout);
vector_int_set(&a, 1, 12);
int min, max;
int which_min, which_max;
vector_int_minmax(&a,&min, &max);
vector_int_which_minmax(&a, &which_min, &which_max);
assert(-12 == min);
assert(12 == max);
assert(2 == which_min);
assert(1 == which_max);
vector_int_reserve(&a, 10);
printf("<<<reserve &a 10>>>\n");
assert(10 == vector_int_capacity(&a));
assert(4 == vector_int_size(&a));
print_vector_int(&a, stdout);
vector_int_null(&a);
printf("<<<null &a>>>\n");
assert(10 == vector_int_capacity(&a));
assert(4 == vector_int_size(&a));
assert(0 == VECTOR(a)[2]);
print_vector_int(&a, stdout);
vector_int_fill(&a, 15);
printf("<<<fill &a 15>>>\n");
assert(10 == vector_int_capacity(&a));
assert(4 == vector_int_size(&a));
assert(15 == VECTOR(a)[2]);
print_vector_int(&a, stdout);
vector_int_clear(&a);
printf("<<<clear &a>>>\n");
assert(10 == vector_int_capacity(&a));
assert(0 == vector_int_size(&a));
print_vector_int(&a, stdout);
vector_int_destroy(&a);
printf("<<<destroy &a>>>\n");
// assert(0 == vector_int_capacity(&a));
// assert(0 == vector_int_size(&a));
// print_vector_int(&a, stdout);
int hehe[5] = {1,2,3,4,5};
vector_int_init_copy(&a, hehe, 5);
printf("<<<init_copy &a {1,2,3,4,5}>>>\n");
assert(5 == vector_int_capacity(&a));
assert(5 == vector_int_size(&a));
assert(3 == VECTOR(a)[2]);
print_vector_int(&a, stdout);
int hehe2[5];
vector_int_copy_to(&a, hehe2);
for (int i = 0; i < 5; i++)
assert(hehe[i] == hehe2[i]);
vector_int_add_constant(&a, 1);
printf("<<<add_constant &a 1>>>\n");
assert(4 == VECTOR(a)[2]);
print_vector_int(&a, stdout);
vector_int a2;
vector_int af;
vector_int_init(&af,0);
vector_int_init_value(&a2, 5, 5,4,3,2,1);
vector_int_add(&a2, &a);
assert(7 == VECTOR(a2)[2]);
print_vector_int(&a2, stdout);
vector_int_ele_freq_min_max(&af, &a2, &min, &max);
print_vector_int(&af,stdout);
vector_int_ele_freq_min_max(&af, &a2, &min, &max);
print_vector_int(&af,stdout);
vector_int_sub(&a2, &a);
assert(3 == VECTOR(a2)[2]);
print_vector_int(&a2, stdout);
vector_int_cumsum(&a2, &a);
assert(20 == VECTOR(a2)[4]);
print_vector_int(&a2, stdout);
int sum = vector_int_sum(&a);
assert(sum == VECTOR(a2)[4]);
vector_int b;
printf("<<<copy &a &b>>>\n");
print_vector_int(&a, stdout);
vector_int_copy(&b, &a);
for (int i = 0; i < vector_int_size(&b); i++)
assert(VECTOR(a)[i] == VECTOR(b)[i]);
print_vector_int(&b, stdout);
vector_int b2;
vector_int_init_value(&b2, 5, 0,1,2,3,4,5);
printf("<<<init_value &b2 5 0,1,2,3,4,5>>>\n");
assert(5 == vector_int_capacity(&b2));
assert(5 == vector_int_size(&b2));
assert(2 == VECTOR(b2)[2]);
print_vector_int(&b2, stdout);
vector_int_remove_section(&b2, 1, 3);
printf("<<<remove_section &b2 1 3>>>\n");
assert(5 == vector_int_capacity(&b2));
assert(3 == vector_int_size(&b2));
assert(3 == VECTOR(b2)[1]);
print_vector_int(&b2, stdout);
vector_int_remove(&b2, 1);
printf("<<<remove &b2, 1>>>\n");
assert(5 == vector_int_capacity(&b2));
assert(2 == vector_int_size(&b2));
assert(4 == VECTOR(b2)[1]);
print_vector_int(&b2, stdout);
vector_int c;
vector_int_init_value_end(&c, 14, 1,2,14,4);
printf("<<<init_value_end &c 14 1,2,14,4>>>\n");
assert(2 == vector_int_capacity(&c));
assert(2 == vector_int_size(&c));
assert(2 == VECTOR(c)[1]);
print_vector_int(&c, stdout);
vector_int v1,v2,res,res2;
vector_int_init_value(&v1, 8, 4,5,2,3,7,1,6,1);
vector_int_init_value(&v2, 8, 3,4,1,7,2,5,1,3);
vector_int_init(&res, 1);
vector_int_init(&res2, 1);
print_vector_int(&res2, stdout);
vector_int_order_inc2(&v1, &v2, &res, 8);
vector_int_scan_tie(&res2, &v1, &res, 8);
printf("<<<order&v1, &v2, &res, 7>>>\n");
print_vector_int(&v1, stdout);
print_vector_int(&v2, stdout);
print_vector_int(&res, stdout);
print_vector_int(&res2, stdout);
assert(7 == VECTOR(res)[0]);
assert(5 == VECTOR(res)[1]);
assert(2 == VECTOR(res)[2]);
assert(3 == VECTOR(res)[3]);
assert(0 == VECTOR(res)[4]);
assert(1 == VECTOR(res)[5]);
assert(6 == VECTOR(res)[6]);
assert(4 == VECTOR(res)[7]);
assert(0 == VECTOR(res2)[0]);
assert(0 == VECTOR(res2)[1]);
assert(2 == VECTOR(res2)[2]);
assert(3 == VECTOR(res2)[3]);
assert(4 == VECTOR(res2)[4]);
assert(5 == VECTOR(res2)[5]);
assert(6 == VECTOR(res2)[6]);
assert(7 == VECTOR(res2)[7]);
vector_double d;
vector_double_init(&d, 3);
print_vector_double(&d, stdout);
vector_double e;
vector_double_init_value(&e, 3, 1.0, 1.2, 1.3);
print_vector_double(&e, stdout);
vector_double f;
vector_double_init_value_end(&f, 1.4, 1.0, 1.3, 1.4, 10.0);
print_vector_double(&f, stdout);
vector_test_t g;
vector_test_t_init(&g, 3);
test_t tmp_test_t = {1,3};
vector_test_t_set(&g, 1, tmp_test_t);
print_vector_test_t(&g, stdout);
assert(1 == vector_test_t_contains_op(&g, tmp_test_t, test_t_op));
vector_char aaa;
vector_char_init(&aaa, 4);
VECTOR(aaa)[0] = 'a';
VECTOR(aaa)[1] = 'a';
VECTOR(aaa)[2] = 'a';
VECTOR(aaa)[3] = '\0';
printf("%s\n",VECTOR(aaa));
vector_int haha;
vector_int_init_value_end(&haha, -1, 3,4,7,1,6,5, -1);
print_vector_int(&haha, stdout);
vector_int order;
vector_int_init(&order, 0);
vector_int_order_inc(&haha, &order,8);
print_vector_int(&order, stdout);
vector_int_order_dec(&haha, &order,8);
print_vector_int(&order, stdout);
vector_int_destroy(&order);
vector_int_destroy(&haha);
return 0;
}
void test_Sudoku()
{
Sudoku Game=Sudoku();
Game.print_data();
print_vector_int(Game.get_col(0));
}
