void process_command() { int command_ptr = 0; initialize_array(command, 80, 0); copy_string(command, buffer + C(current_line, 2)); initialize_array(argument, ARGUMENT_HEAP_SIZE, 0); send_rs(command, 10); next_line(); if (str_equal(c_exit, command, 4)) { put_char('b'); put_char('y'); put_char('e'); send_display(buffer); halt(); } else if (str_equal(c_cd, command, 3)) { int length = copy_string(argument, command + 3); change_directory(argument, length); } else if (command[0] == 0) { return; } else { int ptr = 0; while (command[command_ptr] != ' ' && command[command_ptr] != 0 && command_ptr < COLS) { int byte = command[command_ptr]; if (byte >= 'a' && byte <= 'z') { byte -= 0x20; } program_name[ptr] = byte; command_ptr += 1; ptr += 1; } program_name[ptr] = 0; while (command[command_ptr] == ' ' && command_ptr < COLS) { command_ptr += 1; } ptr = 0; while (command[command_ptr] != ' ' && command[command_ptr] != 0 && command_ptr < COLS) { argument[ptr] = command[command_ptr]; command_ptr += 1; ptr += 1; } argument[ptr] = 0; argument[ARGUMENT_HEAP_SIZE-1] = current_directory_id; execute_bin(program_name, argument); } }
int main (void) { char gameboard[BOARD_SIZE][BOARD_SIZE]; initialize_array(gameboard); print_board(gameboard); while(!(is_board_full(gameboard) ) ) { player1_turn(gameboard); player2_turn(gameboard); } switch(decide_winner(gameboard) ) { case 1: printf("Player One (X) Wins!!!\n\n"); break; case 2: printf("Player Two (O) Wins!!!\n\n"); break; case 3: printf("Tie Game!!!\n\n"); break; return 0; } }
int main(int argc,char *argv[]){ if(argc < 3 ){ printf("Usage: ./sort algorithms 3 2 3 4 5\n"); printf("algorithms: -i(insertion-sort); -s(selection-sort)\n"); exit(1); } int i = 0, *A, lenA = argc - 2; char *algorithm = argv[1]; A = (int*) calloc (lenA,sizeof(int)); if(A == NULL){ printf("Error: Insufficient Memory!\n"); exit(1); } initialize_array(A, argv, lenA); sort(algorithm,A,lenA); for(i = 0; i < argc - 2; i++){ printf("%d ",*(A + i)); // *(A + i) is the same A[i] } printf("\n"); free(A); return 0; }
void read() { int cluster_id = 0; int new_cluster_id = 0; int argument_pointer = 0; int prev_pointer = 0; int empty_index = 0; int entry_id = 0; int file_size = 0; while (argument[argument_pointer] != 0) { prev_pointer = argument_pointer; argument_pointer += basename(argument + argument_pointer, filename); argument_pointer += 1; // skip "/" } prev_pointer -= 1; while (prev_pointer < argument_pointer) { argument[prev_pointer] = 0; prev_pointer += 1; } if (resolve_argument_path(argument[ARGUMENT_HEAP_SIZE-1], argument, resolve_result) == -1) { copy_string(argument, file_not_found_error_message); return; } directory_id = resolve_result[2]; entry_id = find_entry_by_name(directory_id, filename); if (entry_id == ENTRY_NOT_FOUND_ID) { buffer[0] = EOF; file_id = 0; } else { file_id = get_cluster_id(directory_id, entry_id); file_size = get_file_size(directory_id, entry_id); read_file(file_id, file_size, file_content); { int line = 0; int column = 0; int ptr = 0; int got_newline = 0; initialize_array(buffer, 2400, 0); while (ptr < file_size) { buffer[C(line, column)] = file_content[ptr]; if (file_content[ptr] == '\n') { line += 1; column = 0; } else { column += 1; } ptr += 1; } buffer[C(line, column)] = EOF; } } }
int main(void) { srand(time(NULL)); int SIZE,counter; int a[MAX]; int b[MAX2]={0}; printf("Input the size of the first input:"); scanf("%d",&SIZE); while (check_error(SIZE)==0) { printf("Invalid input enter the size of the input again"); scanf("%d",&SIZE); } initialize_array(a,SIZE); printf("Input array\n"); print_array(a,SIZE); frequency(a,b,SIZE); printf("\nMode for the array is number %d",mode(b)); printf("\nPrinting histogram\n"); print_histogram(b); printf("Bonus part\n"); printf("\nArray before sorting\n"); print_array(a,SIZE); printf("\nArray after sorting\n"); sort_array(a,SIZE); print_array(a,SIZE); printf("\n"); }
int main(int argc, char** argv) { set_defaults(); parse_options(argc, argv); if (conf.help_flag) { print_help(); exit(0); } check_conf(); unsigned int arr_width = conf.width * conf.multiplier; unsigned int arr_height = conf.height * conf.multiplier; printf("Creating array size of %ux%u.\n", arr_width, arr_height); Array* arr = new_array(arr_width, arr_height); printf("Initializing with side temps of %f, %f, %f, %f.\n", conf.top_temp, conf.right_temp, conf.bottom_temp, conf.left_temp); initialize_array(arr, conf.top_temp, conf.right_temp, conf.bottom_temp, conf.left_temp); printf("Searching for temp balance with max iterations of %d.\n", conf.max_iters); double mean_temp = calculate_heatconduct(arr, conf.max_iters); printf("Mean temperature: %f\n", mean_temp); return 0; }
void print(int top_id) { output_pointer = 0; while (output_pointer < (indent << 1)) { output[output_pointer] = ' '; output_pointer += 1; } reconstruct(top_id); output[output_pointer] = '\n'; initialize_array(argument, ARGUMENT_HEAP_SIZE, 0); copy_n_string(argument, output, output_pointer); }
/* * Main simply calls each of the tests in turn. */ int main (int argc, char *argv[]) { test_token(); printf ("Starting tests.\n"); fflush (stdout); initialize_array (); copy_string (); bubble_sort (); return (0); }
void init_arrs() { initialize_array(freq_map, 256, -400); initialize_array(offset_map, 256, -1000); initialize_array(octave_offset, 256, -500); freq_map['A'] = 0; freq_map['H'] = 2; freq_map['C'] = 3; freq_map['D'] = 5; freq_map['E'] = 7; freq_map['F'] = 8; freq_map['G'] = 10; octave_offset['A'] = 0; octave_offset['H'] = 0; octave_offset['C'] = -1; octave_offset['D'] = -1; octave_offset['E'] = -1; octave_offset['F'] = -1; octave_offset['G'] = -1; offset_map['s'] = 1; offset_map['f'] = -1; offset_map['#'] = 1; offset_map['f'] = -1; }
int main(void) { int idx, bound; bound = 32; initialize_array(); idx = 0; printf("The first few digits of the Fibonacci sequence are:\n"); while (idx < bound) { write(fib(idx)); idx = idx + 1; } }
static void test_unbind (ACE_Naming_Context &ns_context) { int array [ACE_NS_MAX_ENTRIES]; initialize_array (array, sizeof (array) / sizeof (array[0])); randomize (array, sizeof (array) / sizeof (array[0])); // do the unbinds for (size_t i = 0; i < ACE_NS_MAX_ENTRIES; i++) { ACE_OS::sprintf (name, "%s%d", "name", array[i]); ACE_NS_WString w_name (name); int unbind = ns_context.unbind (w_name); ACE_TEST_ASSERT (unbind != -1); } }
int main (int argc, char ** argv) { int array[50]; int base = 2; total_bits = 4; debug = 0; switch (argc) { case 4: debug = 1; case 3: base = atoi(argv[2]); case 2: total_bits = atoi(argv[1]) - 1; break; default: break; } initialize_array (array, total_bits, 0); grey_code (array, total_bits, base, 1); return EXIT_SUCCESS; }
static void test_bind (ACE_Naming_Context &ns_context) { int array [ACE_NS_MAX_ENTRIES]; initialize_array (array, sizeof (array) / sizeof (array[0])); randomize (array, sizeof (array) / sizeof (array[0])); // do the binds for (size_t i = 0; i < ACE_NS_MAX_ENTRIES; i++) { ACE_OS::sprintf (name, "%s%d", "name", array[i]); ACE_NS_WString w_name (name); ACE_OS::sprintf (value, "%s%d", "value", array[i]); ACE_NS_WString w_value (value); ACE_OS::sprintf (type, "%s%d", "type", array [i]); int bind_result = ns_context.bind (w_name, w_value, type); ACE_TEST_ASSERT (bind_result != -1); } }
/** * Instantiates the plugin. */ static LV2_Handle instantiate(const LV2_Descriptor *descriptor, double rate, const char *bundle_path, const LV2_Feature *const *features) { //Actual struct declaration Nrepel *self = (Nrepel *)calloc(1, sizeof(Nrepel)); //Retrieve the URID map callback, and needed URIDs for (int i = 0; features[i]; ++i) { if (!strcmp(features[i]->URI, LV2_URID__map)) { self->map = (LV2_URID_Map *)features[i]->data; } } if (!self->map) { //bail out: host does not support urid:map free(self); return NULL; } //For lv2 state (noise profile saving) self->atom_Vector = self->map->map(self->map->handle, LV2_ATOM__Vector); self->atom_Int = self->map->map(self->map->handle, LV2_ATOM__Int); self->atom_Float = self->map->map(self->map->handle, LV2_ATOM__Float); self->prop_fftsize = self->map->map(self->map->handle, NREPEL_URI "#fftsize"); self->prop_nwindow = self->map->map(self->map->handle, NREPEL_URI "#nwindow"); self->prop_FFTp2 = self->map->map(self->map->handle, NREPEL_URI "#FFTp2"); //Sampling related self->samp_rate = (float)rate; //FFT related self->fft_size = FFT_SIZE; self->fft_size_2 = self->fft_size / 2; self->input_fft_buffer = (float *)calloc(self->fft_size, sizeof(float)); self->output_fft_buffer = (float *)calloc(self->fft_size, sizeof(float)); self->forward = fftwf_plan_r2r_1d(self->fft_size, self->input_fft_buffer, self->output_fft_buffer, FFTW_R2HC, FFTW_ESTIMATE); self->backward = fftwf_plan_r2r_1d(self->fft_size, self->output_fft_buffer, self->input_fft_buffer, FFTW_HC2R, FFTW_ESTIMATE); //STFT window related self->window_option_input = INPUT_WINDOW; self->window_option_output = OUTPUT_WINDOW; self->input_window = (float *)calloc(self->fft_size, sizeof(float)); self->output_window = (float *)calloc(self->fft_size, sizeof(float)); //buffers for OLA self->in_fifo = (float *)calloc(self->fft_size, sizeof(float)); self->out_fifo = (float *)calloc(self->fft_size, sizeof(float)); self->output_accum = (float *)calloc(self->fft_size * 2, sizeof(float)); self->overlap_factor = OVERLAP_FACTOR; self->hop = self->fft_size / self->overlap_factor; self->input_latency = self->fft_size - self->hop; self->read_ptr = self->input_latency; //the initial position because we are that many samples ahead //soft bypass self->tau = (1.f - expf(-2.f * M_PI * 25.f * 64.f / self->samp_rate)); self->wet_dry = 0.f; //Arrays for getting bins info self->fft_p2 = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->fft_magnitude = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->fft_phase = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); //noise threshold related self->noise_thresholds_p2 = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->noise_thresholds_scaled = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->noise_window_count = 0.f; self->noise_thresholds_availables = false; //noise adaptive estimation related self->auto_thresholds = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->prev_noise_thresholds = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->s_pow_spec = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->prev_s_pow_spec = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->p_min = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->prev_p_min = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->speech_p_p = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->prev_speech_p_p = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); //smoothing related self->smoothed_spectrum = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->smoothed_spectrum_prev = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); //transient preservation self->transient_preserv_prev = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->tp_window_count = 0.f; self->tp_r_mean = 0.f; self->transient_present = false; //masking related self->bark_z = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->absolute_thresholds = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->unity_gain_bark_spectrum = (float *)calloc(N_BARK_BANDS, sizeof(float)); self->spreaded_unity_gain_bark_spectrum = (float *)calloc(N_BARK_BANDS, sizeof(float)); self->spl_reference_values = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->alpha_masking = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->beta_masking = (float *)calloc((self->fft_size_2 + 1), sizeof(float)); self->SSF = (float *)calloc((N_BARK_BANDS * N_BARK_BANDS), sizeof(float)); self->input_fft_buffer_at = (float *)calloc(self->fft_size, sizeof(float)); self->output_fft_buffer_at = (float *)calloc(self->fft_size, sizeof(float)); self->forward_at = fftwf_plan_r2r_1d(self->fft_size, self->input_fft_buffer_at, self->output_fft_buffer_at, FFTW_R2HC, FFTW_ESTIMATE); //reduction gains related self->Gk = (float *)calloc((self->fft_size), sizeof(float)); //whitening related self->residual_max_spectrum = (float *)calloc((self->fft_size), sizeof(float)); self->max_decay_rate = expf(-1000.f / (((WHITENING_DECAY_RATE)*self->samp_rate) / self->hop)); self->whitening_window_count = 0.f; //final ensemble related self->residual_spectrum = (float *)calloc((self->fft_size), sizeof(float)); self->denoised_spectrum = (float *)calloc((self->fft_size), sizeof(float)); self->final_spectrum = (float *)calloc((self->fft_size), sizeof(float)); //Window combination initialization (pre processing window post processing window) fft_pre_and_post_window(self->input_window, self->output_window, self->fft_size, self->window_option_input, self->window_option_output, &self->overlap_scale_factor); //Set initial gain as unity for the positive part initialize_array(self->Gk, 1.f, self->fft_size); //Compute adaptive initial thresholds compute_auto_thresholds(self->auto_thresholds, self->fft_size, self->fft_size_2, self->samp_rate); //MASKING initializations compute_bark_mapping(self->bark_z, self->fft_size_2, self->samp_rate); compute_absolute_thresholds(self->absolute_thresholds, self->fft_size_2, self->samp_rate); spl_reference(self->spl_reference_values, self->fft_size_2, self->samp_rate, self->input_fft_buffer_at, self->output_fft_buffer_at, &self->forward_at); compute_SSF(self->SSF); //Initializing unity gain values for offset normalization initialize_array(self->unity_gain_bark_spectrum, 1.f, N_BARK_BANDS); //Convolve unitary energy bark spectrum with SSF convolve_with_SSF(self->SSF, self->unity_gain_bark_spectrum, self->spreaded_unity_gain_bark_spectrum); initialize_array(self->alpha_masking, 1.f, self->fft_size_2 + 1); initialize_array(self->beta_masking, 0.f, self->fft_size_2 + 1); return (LV2_Handle)self; }
/* main main function, sets up the gtk GUI, the graphics and physics worlds and then calls gtk_main(). parameters: argc and *argv[] from the command line */ int main ( int argc, char *argv[] ) { if (argc < 2) { printf("Must include an integer for level\n"); exit(-1); } int level = atoi(argv[1]); if (level < 1 || level > 10) { printf("Must select level between 1 and 10\n"); exit(-1); } //cpVect gravity = cpv(1, -100); cpFloat time_step = 1.0/60.0; gui_world world; world.graphics = (graphics_world *) malloc(sizeof(graphics_world)); assert(world.graphics); world.color = conv_color("red"); //world.physics = (world_status *)malloc(sizeof(world_status)); //world.physics->drawing_box = false; world.physics = world_new(level, time_step); world.graphics -> space = world.physics -> space; world.graphics -> image = cairo_image_surface_create_from_png("balkcom2000.png"); if (world.physics->drawing_box) { world.graphics->x1 = world.physics->drawing_box_x1; world.graphics->y1 = world.physics->drawing_box_y1; world.graphics->x2 = world.physics->drawing_box_x2; world.graphics->y2 = world.physics->drawing_box_y2; world.graphics->display = true; } else { world.graphics->display = false; } world.mass = 1; world.try_number = 1; world.level = level; world.stop = false; initialize_array (&world); GtkWidget *frame; GtkWidget *da; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *filemenu; GtkWidget *color_menu; GtkWidget *color; GtkWidget *red; GtkWidget *yellow; GtkWidget *green; GtkWidget *blue; gtk_init (&argc, &argv); world.graphics -> window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW(world.graphics -> window), 400, 400); gtk_window_move(GTK_WINDOW(world.graphics -> window), 100, 100); gtk_window_set_title( GTK_WINDOW(world.graphics -> window), "DropZone" ); //Menu Begin----------------------------------------------- vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); //gtk_container_add(GTK_CONTAINER(world.graphics -> window), vbox); // Make the color menu menubar = gtk_menu_bar_new(); filemenu = gtk_menu_new(); color_menu = gtk_menu_new(); GtkWidget *mass_menu = gtk_menu_new(); GtkWidget *open_menu = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL); //GtkWidget *reset = gtk_menu_item_new_with_label("Reset"); GtkWidget *file_name = gtk_menu_item_new_with_label ("File"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_name), filemenu); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), open_menu); //gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), reset); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file_name); g_signal_connect (open_menu, "activate", G_CALLBACK (cb_open_file), world.graphics->window); //g_signal_connect (reset, "activate", G_CALLBACK (reset_game), &world); // Attach the color changing callbacks color = gtk_menu_item_new_with_label("Color"); red = gtk_menu_item_new_with_label("red"); g_signal_connect (red, "activate", G_CALLBACK (cb_color_change), &world); gtk_widget_set_name (red, "red"); yellow = gtk_menu_item_new_with_label("yellow"); g_signal_connect (yellow, "activate", G_CALLBACK (cb_color_change), &world); gtk_widget_set_name (yellow, "yellow"); green = gtk_menu_item_new_with_label("green"); gtk_widget_set_name (green, "green"); g_signal_connect (green, "activate", G_CALLBACK (cb_color_change), &world); blue = gtk_menu_item_new_with_label("blue"); gtk_widget_set_name (blue, "blue"); g_signal_connect (blue, "activate", G_CALLBACK (cb_color_change), &world); gtk_menu_item_set_submenu(GTK_MENU_ITEM(color), color_menu); gtk_menu_shell_append(GTK_MENU_SHELL(color_menu), red); gtk_menu_shell_append(GTK_MENU_SHELL(color_menu), yellow); gtk_menu_shell_append(GTK_MENU_SHELL(color_menu), green); gtk_menu_shell_append(GTK_MENU_SHELL(color_menu), blue); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), color); GtkWidget *mass = gtk_menu_item_new_with_label("Mass"); GtkWidget *half = gtk_menu_item_new_with_label("0.5 kg"); g_signal_connect (half, "activate", G_CALLBACK(cb_mass_change), &world); gtk_widget_set_name (half, "1"); GtkWidget *one = gtk_menu_item_new_with_label("1 kg"); g_signal_connect (one, "activate", G_CALLBACK(cb_mass_change), &world); gtk_widget_set_name (one, "1"); GtkWidget *five = gtk_menu_item_new_with_label("5 kg"); g_signal_connect (five, "activate", G_CALLBACK(cb_mass_change), &world); gtk_widget_set_name (five, "5"); GtkWidget *ten = gtk_menu_item_new_with_label("10 kg"); g_signal_connect (ten, "activate", G_CALLBACK(cb_mass_change), &world); gtk_widget_set_name (ten, "10"); GtkWidget *twenty = gtk_menu_item_new_with_label("20 kg"); g_signal_connect (twenty, "activate", G_CALLBACK(cb_mass_change), &world); gtk_widget_set_name (twenty, "20"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(mass), mass_menu); gtk_menu_shell_append(GTK_MENU_SHELL(mass_menu), half); gtk_menu_shell_append(GTK_MENU_SHELL(mass_menu), one); gtk_menu_shell_append(GTK_MENU_SHELL(mass_menu), five); gtk_menu_shell_append(GTK_MENU_SHELL(mass_menu), ten); gtk_menu_shell_append(GTK_MENU_SHELL(mass_menu), twenty); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), mass); gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3); //Menu End----------------------------------------- // Add menu to grid GtkWidget *grid = gtk_grid_new(); gtk_container_add (GTK_CONTAINER(world.graphics->window), grid); gtk_grid_attach ((GtkGrid *)grid, vbox, 0, 0, 1, 1); g_signal_connect (GTK_WINDOW(world.graphics -> window), "destroy", G_CALLBACK (gtk_main_quit), NULL); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); //gtk_container_add (GTK_CONTAINER (world.graphics -> window), frame); gtk_grid_attach ((GtkGrid *)grid, frame, 0, 1, 400, 400); gtk_widget_set_size_request (frame, 400, 400); da = gtk_drawing_area_new (); gtk_container_add (GTK_CONTAINER (frame), da); world.graphics->drawing_screen = da; //Set up chat box stuff--------------------------- world.label = gtk_label_new(""); GtkWidget *chatbox_text = gtk_text_view_new(); GtkWidget *chatbox_button = gtk_button_new_with_label("send"); gtk_label_set_line_wrap ( (GtkLabel *) world.label, TRUE ); gtk_grid_attach ((GtkGrid *)grid, world.label, 0, 401, 200, 100); gtk_grid_attach ((GtkGrid *)grid, chatbox_text, 201, 401, 200, 90); gtk_grid_attach ((GtkGrid *)grid, chatbox_button, 201, 491, 200, 10); gtk_widget_set_size_request (world.label, 200, 100); gtk_widget_set_size_request (chatbox_text, 200, 90); gtk_widget_set_size_request (chatbox_button, 200, 10); gtk_text_view_set_wrap_mode ((GtkTextView *)chatbox_text, GTK_WRAP_CHAR); world.delete_text = false; world.textbox_buffer = gtk_text_view_get_buffer ((GtkTextView *) chatbox_text); g_signal_connect (world.textbox_buffer, "changed", G_CALLBACK (max_length_detect), &world); g_signal_connect (chatbox_button, "clicked", G_CALLBACK (chatbox_button_pressed), &world); //End chat box stuff--------------------------------- gtk_widget_add_events(da, GDK_BUTTON_PRESS_MASK); gtk_widget_add_events(da, GDK_BUTTON_RELEASE_MASK); gtk_widget_add_events(da, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); /* Signals used to handle the backing surface */ g_signal_connect (da, "draw", G_CALLBACK (draw_cb), &world); //g_signal_connect (da,"configure-event", G_CALLBACK (configure_event_cb), &world); g_signal_connect (da, "motion-notify-event", G_CALLBACK (motion_notify_event_cb), &world); g_signal_connect (da, "button-press-event", G_CALLBACK (cb_button_press), &world); g_signal_connect (da, "button-release-event", G_CALLBACK (cb_button_release), &world); g_timeout_add(40, (GSourceFunc) time_handler, (gpointer) &world); gtk_widget_show_all (world.graphics -> window); gtk_main (); //Free stuff /* world_free (world.physics); if (world.graphics -> box){ free(world.graphics -> box); if (world.graphics -> window) free(world.graphics -> window); free(world.graphics); if(world.graphics) if (world.graphics -> cr) cairo_destroy(world.graphics -> cr); } */ return 0; }
static gboolean cb_button_release (GtkWidget *widget, GdkEventMotion *event, gpointer data) { gui_world *world = (gui_world *)data; if (world->graphics->user_points->len < 50) { world->graphics->message = (char *)malloc(20 * sizeof(char)); strcpy(world->graphics->message, "Size Too Small"); g_array_free (world->graphics->user_points, TRUE); initialize_array(world); return TRUE; } else if (!world->draw_success) { world->graphics->message = (char *)malloc(20 * sizeof(char)); strcpy(world->graphics->message, "Drew Outside Box"); g_array_free (world->graphics->user_points, TRUE); initialize_array(world); return TRUE; } else { free(world->graphics->message); world->graphics->message = NULL; } if (world -> try_number > 3) { if (world->graphics->message != NULL) { free (world->graphics->message); } world->graphics->message = (char *)malloc(20 * sizeof(char)); strcpy(world->graphics->message, "You Lose!"); g_array_free (world->graphics->user_points, TRUE); initialize_array(world); new_game (world); return FALSE; //gtk_main_quit(); } (world -> try_number)++; int skip_interval = world->graphics->user_points->len / DESIRED_NUMBER_VERTICES; int counter = 0; for (int i = 0; i < world->graphics->user_points->len; i++) { counter++; if (counter % skip_interval != 0) { g_array_remove_index (world->graphics->user_points, i); i--; } } create_user_object ((cpVect *)world->graphics->user_points->data, world->graphics->user_points->len, world->color, world->physics, PLAYER_BOX_COLLISION_NUMBER, 0.7, world->mass); g_array_free (world->graphics->user_points, TRUE); initialize_array(world); return TRUE; }
int main(){ HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleTextAttribute(hStdOut, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_INTENSITY | FOREGROUND_GREEN); int i, j; for (i = 0; i < 80; i++) printf("*"); for (i = 0; i < N + 2; i++){ printf("*"); for (j = 1; j < 79; j++) printf(" "); printf("*"); } for (i = 0; i < 80; i++) printf("*"); SetConsoleTextAttribute(hStdOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY | FOREGROUND_BLUE); gotoxy(0, N + 4); int a, b; printf("Enter interval:\na = "); scanf("%d", &a); printf("b = "); scanf("%d", &b); while (a>b){ printf("Error!\nEnter :\na = "); scanf("%d", &a); printf("b = "); scanf("%d", &b); } int mas[N][N]; srand(time(NULL)); initialize_array(mas, a, b); print(mas); clean(); //-------------------------------------------------- char * str = (char*)malloc(10 * sizeof(char)); char *p = (char*)malloc(10 * sizeof(char)); getchar(); gets(str); strcpy(p, str); int len = strlen(p); for (i = 0; i < len; i++) if (p[i] == ' ') p[i] = '\0'; while (strcmp(str, "end")){ if (!strcmp(str, "help")){ clean(); help(); } else if (!strcmp(str, "res")){ reset(mas); print(mas); clean(); } else if (!strcmp(str, "initar")) { printf("Enter interval:\na = "); scanf("%d", &a); printf("b = "); scanf("%d", &b); while (a > b){ printf("Error!\nEnter :\na = "); scanf("%d", &a); printf("b = "); scanf("%d", &b); } initialize_array(mas, a, b); print(mas); clean(); } else if (!strcmp(p, "ch")){ change(mas, p); print(mas); clean(); } else if (!strcmp(str, "rev")){ rev_min_max(mas); clean(); } else if (!strcmp(str, "rot180")){ rotateCW180(mas); print(mas); clean(); } else if (!strcmp(str, "meanv")){ printf("%g\n",mean_value(mas)); } else if (!strcmp(str, "rfl")){ rotate_first_last(mas); clean(); } else if (!strcmp(str, "rll")){ rotate_last_last(mas); clean(); } else if (!strcmp(p, "sumj")){ p += strlen(p) + 1; int t = atoi(p) - 1; if (t > 0 && t <= N){ sum_elements(mas, t); } else { SetConsoleTextAttribute(hStdOut, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_INTENSITY | BACKGROUND_BLUE | FOREGROUND_RED); printf("Is not a valid number!\n"); SetConsoleTextAttribute(hStdOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY | FOREGROUND_BLUE); } } else { clean(); SetConsoleTextAttribute(hStdOut, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_INTENSITY | BACKGROUND_BLUE | FOREGROUND_RED); printf("Please, enter help!\n"); SetConsoleTextAttribute(hStdOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY | FOREGROUND_BLUE); } gets(str); strcpy(p, str); int len = strlen(p); for (i = 0; i < len; i++) if (p[i] == ' ') p[i] = '\0'; } }
static void test_find (ACE_Naming_Context &ns_context, int sign, int result) { char temp_val[BUFSIZ]; char temp_type[BUFSIZ]; int array [ACE_NS_MAX_ENTRIES]; initialize_array (array, sizeof (array) / sizeof (array[0])); randomize (array, sizeof (array) / sizeof (array[0])); // do the finds for (size_t i = 0; i < ACE_NS_MAX_ENTRIES; i++) { if (sign == 1) { ACE_OS::sprintf (temp_val, "%s%d", "value", array[i]); ACE_OS::sprintf (temp_type, "%s%d", "type", array[i]); } else { ACE_OS::sprintf (temp_val, "%s%d", "value", -array[i]); ACE_OS::sprintf (temp_type, "%s%d", "type", -array[i]); } ACE_OS::sprintf (name, "%s%d", "name", array[i]); ACE_NS_WString w_name (name); ACE_NS_WString w_value; char *type_out = 0; ACE_NS_WString val (temp_val); int const resolve_result = ns_context.resolve (w_name, w_value, type_out); if (resolve_result != result) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error, resolve result not equal to resutlt (%d != %d)\n"), resolve_result, result)); char *l_value = w_value.char_rep (); if (l_value) { ACE_TEST_ASSERT (w_value == val); if (ns_context.name_options ()->debug ()) { if (type_out) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Name: %C\tValue: %C\tType: %C\n"), name, l_value, type_out)); else ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Name: %C\tValue: %C\n"), name, l_value)); } if (type_out) { ACE_TEST_ASSERT (ACE_OS::strcmp (type_out, temp_type) == 0); delete[] type_out; } } delete[] l_value; } }
// int direction: 0: up, 1: right, 2: down, 3: left // return: 1 when quit int interpret_command(char input) { switch (input) { case 'i': insert_mode = 1; break; case 'a': insert_mode = 1; break; case 'o': move_memory(buffer + C(current_line + 1, 0), 80, C(ROWS - current_line, 0)); move_memory(buffer + C(current_line + 1, 0), 80, C(ROWS - current_line, 0)); current_line += 1; current_column = 0; initialize_array(buffer + C(current_line, 0), C(current_line, COLS-1) - C(current_line, 0), 0); buffer[C(current_line, 0)] = EOL; insert_mode = 1; break; case 'q': return 1; case 'w': write(); break; case 'j': if (current_line < ROWS && buffer[C(current_line + 1, 0)] != 0) { current_line += 1; goto_last_column(); } break; case 'k': if (current_line > 0) { current_line -= 1; goto_last_column(); } break; case 'h': if (current_column > 0) { current_column -= 1; } break; case 'l': if (current_column < COLS && buffer[C(current_line, current_column + 1)] != 0) { current_column += 1; } break; case 'x': { int current_char = buffer[C(current_line, current_column)]; if (current_char != EOF && current_char != EOL) { int end = -1; int ptr = C(current_line, current_column); move_memory(buffer + C(current_line, current_column), -1, COLS - current_column - 1); buffer[C(current_line, COLS-1)] = 0; } } break; case 'd': { if (line_include_eof()) { int ptr = 0; initialize_array(buffer + C(current_line, 0), C(ROWS - current_line, 0), 0); current_line -= 1; while (ptr < COLS) { if (buffer[C(current_line, ptr)] == EOL) { buffer[C(current_line, ptr)] = EOF; break; } ptr += 1; } } else { move_memory(buffer + C(current_line, 0), - COLS, C(ROWS - current_line - 1, 0)); initialize_array(buffer + C(ROWS-1, 0), COLS, 0); } } break; } return 0; }
/** * To reset the noise profile and set every value to default one. */ static void reset_noise_profile(Nrepel *self) { initialize_array(self->noise_thresholds_p2, 0.f, self->fft_size_2 + 1); initialize_array(self->noise_thresholds_scaled, 0.f, self->fft_size_2 + 1); self->noise_window_count = 0.f; self->noise_thresholds_availables = false; initialize_array(self->Gk, 1.f, self->fft_size); initialize_array(self->residual_max_spectrum, 0.f, self->fft_size); self->whitening_window_count = 0.f; initialize_array(self->prev_noise_thresholds, 0.f, self->fft_size_2 + 1); initialize_array(self->s_pow_spec, 0.f, self->fft_size_2 + 1); initialize_array(self->prev_s_pow_spec, 0.f, self->fft_size_2 + 1); initialize_array(self->p_min, 0.f, self->fft_size_2 + 1); initialize_array(self->prev_p_min, 0.f, self->fft_size_2 + 1); initialize_array(self->speech_p_p, 0.f, self->fft_size_2 + 1); initialize_array(self->prev_speech_p_p, 0.f, self->fft_size_2 + 1); initialize_array(self->alpha_masking, 1.f, self->fft_size_2 + 1); initialize_array(self->beta_masking, 0.f, self->fft_size_2 + 1); self->tp_window_count = 0.f; self->tp_r_mean = 0.f; self->transient_present = false; }
int main(int argc, char** argv) { size_t _AmountOfElements, _Count; size_t* _FirstArray, *_SecondArray, *_ThirdArray, *_FirstCopiedArray, *_SecondCopiedArray, *_LastArray; array* _FirstStructArray, *_SecondStructArray; struct timespec _Start, _End; int _Verbose = 0; if (argc < 2) { _AmountOfElements = 10; } else { _AmountOfElements = atoi(argv[1]); if (argc > 2) _Verbose = strcmp(argv[2], "-v") == 0 ? 1 : 0; } srand(time(NULL)); /* seed srand to be random */ _FirstStructArray = (array*)malloc(sizeof(array)); _SecondStructArray = (array*)malloc(sizeof(array)); _FirstArray = (size_t*)malloc(sizeof(size_t) * _AmountOfElements); _SecondArray = (size_t*)malloc(sizeof(size_t) * _AmountOfElements); _ThirdArray = (size_t*)malloc(sizeof(size_t) * (_AmountOfElements * 2) ); _FirstCopiedArray = (size_t*)malloc(sizeof(size_t) * _AmountOfElements); _SecondCopiedArray = (size_t*)malloc(sizeof(size_t) * _AmountOfElements); _LastArray = (size_t*)malloc(sizeof(size_t) * (_AmountOfElements * 2)); initialize_array(_FirstArray, _AmountOfElements); initialize_array(_SecondArray, _AmountOfElements); memcpy(_FirstCopiedArray, _FirstArray, _AmountOfElements); memcpy(_SecondCopiedArray, _SecondArray, _AmountOfElements); memcpy(_LastArray, _FirstArray, _AmountOfElements); memcpy(_LastArray + _AmountOfElements, _SecondArray, _AmountOfElements); _FirstStructArray->m_array = _FirstArray; _FirstStructArray->m_size = _AmountOfElements; _SecondStructArray->m_array = _SecondArray; _SecondStructArray->m_size = _AmountOfElements; hr_timer_start(&_Start); sort_and_merge_with_threads(_FirstStructArray, _SecondStructArray, _ThirdArray); hr_timer_stop(&_End); _FirstStructArray->m_array = _FirstCopiedArray; _SecondStructArray->m_array = _SecondCopiedArray; if (_Verbose) for (_Count = 0; _Count < _AmountOfElements; ++_Count) printf("_FirstArray[%d] = %d, _SecondArray[%d] = %d\n", (int)_Count, (int)_FirstArray[_Count], (int)_Count, (int)_SecondArray[_Count]); printf("Total time to sort and merge with threads = %f.2 milliseconds\n", duration_as_microseconds(&_Start, &_End)); hr_timer_start(&_Start); sort_and_merge(_FirstStructArray, _SecondStructArray, _ThirdArray); hr_timer_stop(&_End); if (_Verbose) for (_Count = 0; _Count < _AmountOfElements; ++_Count) printf("_FirstArray[%d] = %d, _SecondArray[%d] = %d\n", (int)_Count, (int)_FirstArray[_Count], (int)_Count, (int)_SecondArray[_Count]); printf("Total time to sort and merge without threads = %f.2 milliseconds\n", duration_as_microseconds(&_Start, &_End)); _FirstStructArray->m_array = _LastArray; hr_timer_start(&_Start); sort_without_merge(_FirstStructArray); hr_timer_stop(&_End); if (_Verbose) for (_Count = 0; _Count < _AmountOfElements; ++_Count) printf("_FirstArray[%d] = %d, _SecondArray[%d] = %d\n", (int)_Count, (int)_FirstArray[_Count], (int)_Count, (int)_SecondArray[_Count]); printf("Total time to sort without merging = %f.2 milliseconds\n", duration_as_microseconds(&_Start, &_End)); free(_FirstStructArray); free(_SecondStructArray); free(_FirstArray); free(_SecondArray); free(_ThirdArray); free(_FirstCopiedArray); free(_SecondCopiedArray); free(_LastArray); }