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);
}
