// **Test `test`**.
static char * test() {
mpz_array in;
mpz_array out;
mpz_t b;
array_init(&in, 10);
array_init(&out, 3);
mpz_init_set_str(b, "419479", 0);
array_add(&in, b);
mpz_set_str(b, "627401", 0);
array_add(&in, b);
mpz_set_str(b, "497951", 0);
array_add(&in, b);
printf("\nin1:\n");
array_print(&in);
array_cb(&out, &in);
printf("\nout:\n");
array_print(&out);
mpz_clear(b);
array_clear(&in);
array_clear(&out);
return 0;
}
int g_main(int argc, char ** argv)
{
int * array = NULL;
int length = 0;
int case_count = 0;
while (true) {
case_count++;
array = array_read<int>(cin, length);
if (array == NULL) {
break;
}
cout << "Case " << case_count << ": ";
array_print(array, length) << '\n';
partition(array, array + length, compare_to_zero());
cout << "Result: ";
array_print(array, length) << "\n\n";
array_destroy(array);
}
return 0;
}
int main(int argc, char** argv)
{
array_number_t v1 = TOP_LEVEL_linalg_vec3(1, 2, 3);
array_number_t v2 = TOP_LEVEL_linalg_vec3(3, 5, 6);
array_number_t v1_d = TOP_LEVEL_linalg_vec3_d(1, 2, 3, 3, 0, 4);
array_number_t v2_d = TOP_LEVEL_linalg_vec3_d(3, 5, 6, 7, 8, 10);
array_print(v1_d);
array_print(v2_d);
array_number_t v3_d = TOP_LEVEL_linalg_vectorAdd_d(v1, v2, v1_d, v2_d);
array_print(v3_d);
return 0;
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
array_print(arr, 5);
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 2)
{
die("USAGE: ./main 1 2 3 4 5");
}
int count = argc - 1;
int i = 0;
char **inputs = argv + 1;
int *numbers = malloc(count * sizeof(int));
if (numbers == NULL)
{
die("Memory fail.");
}
for (i = 0; i < count; i++)
{
numbers[i] = atoi(inputs[i]);
}
int *sorted = bubble_sort(numbers, count, sorted_order);
array_print(sorted, count);
free(numbers);
free(sorted);
return 0;
}
// **Test `test`**.
static char * test() {
mpz_array in;
mpz_array out;
mpz_t b;
array_init(&in, 10);
array_init(&out, 3);
// primes: 139, 223, 317, 577, 727, 863
mpz_init_set_str(b, "139", 0);
array_add(&in, b);
mpz_set_str(b, "223", 0);
array_add(&in, b);
mpz_set_str(b, "317", 0);
array_add(&in, b);
mpz_set_str(b, "577", 0);
array_add(&in, b);
mpz_set_str(b, "727", 0);
array_add(&in, b);
/*
mpz_init_set_str(b, "863", 0);
array_add(&in, b);
*/
printf("\nin:\n");
array_print(&in);
printf("b: 627401\n"); // 727 * 863
mpz_set_str(b, "627401", 0);
cbextend(&out, &in, b);
printf("\nout:\n");
array_print(&out);
array_clear(&in);
array_clear(&out);
mpz_clear(b);
return 0;
}
int main(void)
{
/* Generate a large number of floating-point values */
float *arr = (float *) malloc(ELEMENTS * sizeof(float));
array_fill(arr, ELEMENTS);
/* array_print(arr, ELEMENTS); */
array_mergesort(arr, ELEMENTS);
array_print(arr, ELEMENTS);
}
int main (int argc, char **argv) {
array *a;
data_string *ds;
data_count *dc;
data_config *dg;
UNUSED(argc);
UNUSED(argv);
a = array_init();
ds = data_string_init();
buffer_copy_string_len(ds->key, CONST_STR_LEN("abc"));
buffer_copy_string_len(ds->value, CONST_STR_LEN("alfrag"));
array_insert_unique(a, (data_unset *)ds);
ds = data_string_init();
buffer_copy_string_len(ds->key, CONST_STR_LEN("abc"));
buffer_copy_string_len(ds->value, CONST_STR_LEN("hameplman"));
array_insert_unique(a, (data_unset *)ds);
ds = data_string_init();
buffer_copy_string_len(ds->key, CONST_STR_LEN("abc"));
buffer_copy_string_len(ds->value, CONST_STR_LEN("xiangshouding"));
array_insert_unique(a, (data_unset *)ds);
ds = data_string_init();
buffer_copy_string_len(ds->key, CONST_STR_LEN("123"));
buffer_copy_string_len(ds->value, CONST_STR_LEN("alfrag"));
array_insert_unique(a, (data_unset *)ds);
dc = data_count_init();
buffer_copy_string_len(dc->key, CONST_STR_LEN("def"));
array_insert_unique(a, (data_unset *)dc);
dc = data_count_init();
buffer_copy_string_len(dc->key, CONST_STR_LEN("def"));
array_insert_unique(a, (data_unset *)dc);
//get element
ds = (data_string *)array_get_element(a, "abc");
fprintf(stdout, "%s\n", ds->value->ptr);
array_print(a, 0);
array_free(a);
fprintf(stderr, "%d\n",
buffer_caseless_compare(CONST_STR_LEN("Content-Type"), CONST_STR_LEN("Content-type")));
return 0;
}
int main() {
std::vector<double> dataz( 8, 0.0f );
buffer_view<double> view8x1( dataz );
buffer_view<double, 2> view2x4( dataz, 2, 4 );
array_print( dataz );
view8x1[0] = 2.0f;
view8x1[1] = 2.0f;
array_print( dataz );
view2x4[{1, 1}] = 3.0f;
view2x4[{1, 0}] = 3.0f;
array_print( dataz );
// calls will fail
//buffer_view<double, 2> view2x4fail( dataz );
//view2x4[ 1 ] = 50.0f;
}
main()
{
int i,k;
int *a,size,lower;
printf("Number of elements in array ? \n\n");
fflush(stdin);
scanf("%d",&size);
a=(int *)malloc(size*sizeof(int *));
array_init(a,size);
array_print(a,size);
quicksort(a,0,size-1);
array_print(a,size);
scanf("%d",&k);
}
int main() {
int x;
int array[max];
do {
printf("Enter number between 0 and 10:\n");
scanf("%d", &x);
} while (x<=0 || x>=10);
array_init(array);
printf("Array before:\n");
array_print(array);
array_order(array, x);
printf("Array after order:\n");
array_print(array);
return 0;
}
void test_array()
{
printf("test array\n");
Array* array = new_array(10);
Blob* data0 = new_blob(1,2,3,4);
Blob* data1 = new_blob(2,3,4,5);
Blob* data2 = new_blob(3,4,5,6);
Blob* data3 = new_blob(1,2,3,4);
Blob* data4 = new_blob(2,3,4,5);
Blob* data5 = new_blob(3,4,5,6);
Blob* data6 = new_blob(1,2,3,4);
Blob* data7 = new_blob(2,3,4,5);
Blob* data8 = new_blob(3,4,5,6);
Blob* data9 = new_blob(1,2,3,4);
Blob* data10 = new_blob(2,3,4,5);
Blob* data11 = new_blob(3,4,5,6);
array_push(array, data0 , del_blob);
array_push(array, data1 , del_blob);
array_push(array, data2 , del_blob);
array_push(array, data3 , del_blob);
array_push(array, data4 , del_blob);
array_push(array, data5 , del_blob);
array_push(array, data6 , del_blob);
array_push(array, data7 , del_blob);
array_push(array, data8 , del_blob);
array_push(array, data9 , del_blob);
array_push(array, data10, del_blob);
array_push(array, data11, del_blob);
array_print(array);
int32_t length = array->length, i;
Element* element = array->elements;
for (i = 0; i < length; ++i)
{
blob_print(element->data, false);
element ++;
printf("--------------------\n");
}
array_clear(array);
array_print(array);
del_array(array);
}
// **Test `test`**.
static char * test() {
mpz_array in, out;
mpz_t b;
array_init(&in, 10);
array_init(&out, 3);
// primes: 139, 223, 317, 577, 727, 863
mpz_init_set_str(b, "139", 0);
array_add(&in, b);
mpz_set_str(b, "223", 0);
array_add(&in, b);
mpz_set_str(b, "577", 0);
array_add(&in, b);
mpz_set_str(b, "230459", 0); // 727 * 317
array_add(&in, b);
printf("\nin:\n");
array_print(&in);
printf("a: 627401 = 727 * 863\n");
mpz_set_str(b, "627401", 0);
printf("\nout:\n");
array_find_factor(&out, b, &in);
array_print(&out);
array_clear(&out);
array_clear(&in);
mpz_clear(b);
return 0;
}
//本プログラムのmain関数です。
int main(void)
{
//配列変数を定義します。
int Array1[3][3] = {0}, Array2[3][3] = {0}, ArraySUM[3][3] = {0}, ArrayMULTIPLY[3][3] = {0};
//array_inputを呼び出し。ユーザから3x3型行列を受け取ります。
printf("１つ目の3x3型行列を設定します。(Array1)\n");
printf("//////////////////////////////////////////////////\n");
array_input(Array1);
printf("//////////////////////////////////////////////////\n\n");
printf("2つ目の3x3型行列を設定します。(Array2)\n");
printf("//////////////////////////////////////////////////\n");
array_input(Array2);
printf("//////////////////////////////////////////////////\n\n");
//array_printを呼び出し、設定した２つの行列を出力します。
printf("1つ目の行列(Array1)\n");
printf("//////////////////////////////////////////////////\n");
array_print(Array1);
printf("//////////////////////////////////////////////////\n\n");
printf("2つ目の行列(Array1)\n");
printf("//////////////////////////////////////////////////\n");
array_print(Array2);
printf("//////////////////////////////////////////////////\n\n");
//array_addを呼び出し、Array1とArray2の和の行列を計算し、出力します。
array_add(Array1, Array2, ArraySUM);
printf("Array1とArray2の和の行列(ArraySUM)\n");
printf("//////////////////////////////////////////////////\n");
array_print(ArraySUM);
printf("//////////////////////////////////////////////////\n\n");
//array_mulを呼び出し、Array1とArray2の積の行列を計算し、出力します。
array_mul(Array1, Array2, ArrayMULTIPLY);
printf("Array1とArray2の積の行列(ArrayMULTIPLY)\n");
printf("//////////////////////////////////////////////////\n");
array_print(ArrayMULTIPLY);
printf("//////////////////////////////////////////////////\n\n");
return 0;
}
void test_array_array()
{
printf("test array array\n");
Array* array0 = new_array(10);
Array* array1 = new_array(10);
Array* array2 = new_array(10);
Array* array3 = new_array(10);
Array* array = new_array(10);
array_push(array, array0, del_array);
array_push(array, array1, del_array);
array_push(array, array2, del_array);
array_push(array, array3, del_array);
array_print(array);
del_array(array);
}
static void
array_print(pdf_obj *a)
{
int i;
printf("%s ", "[");
for (i = 0; i < a->value.a.len; i++)
{
pdf_obj *o = &a->value.a.items[i];
switch (o->t)
{
case eRef:
printf("ref(%d,%d) ", o->value.r.num, o->value.r.gen);
break;
case eKey:
case eName:
printf("name(%s) ", o->value.k);
break;
case eString:
case eHexString:
printf("str(");
{int i;
for (i = 0; i < o->value.s.len; i++) printf("%c", o->value.s.buf[i]);
}
printf(")");
break;
case eInt:
printf("i(%d) ", o->value.i);
break;
case eReal:
printf("f(%f) ", o->value.f);
break;
case eArray:
{
array_print(o);
}
break;
case eDict:
printf("<< ");
dict_dump(o->value.d.dict);
printf(">> ");
break;
default:
printf("%d ", o->t);
break;
}
}
printf("%s ", "]");
}
int main(
) {
t_array array = array_new();
array_append(array, 3);
array_append(array, 6);
array_append(array, 9);
printf("array size: %d\n", array_count(array));
printf("item at index 0: %d\n", array_get(array, 0));
printf("item at index 1: %d\n", array_get(array, 1));
array_print(array);
array_free(array);
return 0;
}
static void
dict_print_keyval(char *key, void *val, void *x)
{
if (!val)
printf("dict_print_key: %s\n", key);
else
{
pdf_obj *o = (pdf_obj*) val;
switch (o->t)
{
case eRef:
printf("%s = ref(%d,%d)\n", key, o->value.r.num, o->value.r.gen);
break;
case eKey:
case eName:
printf("%s = name(%s)\n", key, o->value.k);
break;
case eString:
case eHexString:
printf("%s = str(%s)\n", key, o->value.s.buf); // could out run buffer
break;
case eInt:
printf("%s = i(%d)\n", key, o->value.i);
break;
case eReal:
printf("%s = f(%f)\n", key, o->value.f);
break;
case eArray:
printf("%s = ", key);
array_print(o);
printf("\n");
break;
case eDict:
printf("%s = << ", key);
dict_dump(o->value.d.dict);
printf(">>\n");
break;
case eBool:
printf("%s = B(%d)\n", key, o->value.i);
break;
default:
printf("%s:%d\n", key, o->t);
break;
}
}
}
/* return a copied variable */
static data_unset *configparser_get_variable(config_t *ctx, const buffer *key) {
data_unset *du;
data_config *dc;
#if 0
fprintf(stderr, "get var %s\n", key->ptr);
#endif
for (dc = ctx->current; dc; dc = dc->parent) {
#if 0
fprintf(stderr, "get var on block: %s\n", dc->key->ptr);
array_print(dc->value, 0);
#endif
if (NULL != (du = array_get_element(dc->value, key->ptr))) {
return du->copy(du);
}
}
return NULL;
}
static void data_array_print(const data_unset *d, int depth) {
data_array *ds = (data_array *)d;
array_print(ds->value, depth);
}
int main( int argc, char *argv[] )
{
int el;
/*** Example for the array ***/
Array *array;
array = array_init();
printf("Empty array\n");
array_print(array);
printf("Array with 1, 2 and 3 added.\n");
array_add(array, 1);
array_add(array, 2);
array_add(array, 3);
array_print(array);
printf("Array delete the 3.\n");
array_del(array, 3);
array_print(array);
printf("Looking for element at position number 1.\n");
el = array_get(array, 1);
printf("%d\n", el);
printf("Looking for element at position number 2.\n");
el = array_get(array, 2);
printf("%d\n", el);
array_destroy(array);
/*** Example for the list ***/
printf("-----------------------------------\n");
LinkedList *list;
list = list_init();
printf("Empty list\n");
list_print(list);
printf("LinkedList with 1, 2 and 3 added.\n");
list_add(list, 1);
list_add(list, 2);
list_add(list, 3);
list_print(list);
printf("LinkedList with 3 deleted.\n");
list_del(list, 3);
list_print(list);
printf("Looking for element at position number 1.\n");
el = list_get(list, 1);
printf("%d\n", el);
printf("Looking for element at position number 2.\n");
el = list_get(list, 2);
printf("%d\n", el);
printf("Removing all items of list");
list_del(list, 1);
list_del(list, 2);
list_destroy(list);
return 0;
}
/** Prints: "<name>:\t[ data[0] data[1] ... data[n] ]" on its own line */
inline void array_print_with_name(const double *x, unsigned int len, const char* name) {
printf("%s:\t",name);
array_print(x, len);
}
