/* Send data through socket
* @param socket: file descriptor of client
* @param filename: name of the file
* @param fdout: file descriptor to write
*
* @return: 0 on success. Error code otherwise
*/
int send_data(int socket, char filename[], int fdout) {
struct stat file_stat;
char type = END;
if (stat(filename, &file_stat) < 0)
return -1;
if (file_stat.st_mode & S_IFDIR) {
send_dir(socket, filename, search_root(filename), fdout);
write(socket, &type, sizeof(char));
} else if (file_stat.st_mode & S_IFREG || file_stat.st_mode & S_IFLNK) {
send_file(socket, filename, search_root(filename), fdout);
write(socket, &type, sizeof(char));
} else {
dprintf(fdout, "It can't be sended that kind of file\n");
dprintf(fdout, "Quitting...\n");
return -1;
}
dprintf(fdout, "\nSe han enviado: - %d directorios\n", DIR_S);
dprintf(fdout, " - %d archivos\n", FILES_S);
dprintf(fdout, "\nTransferencia realizada con éxito.\n");
write_to(socket, &DIR_S, sizeof(int));
write_to(socket, &FILES_S, sizeof(int));
return 0;
}
static delete_node_return delete_node(compare_t compare, node root, FatPointer<int> item)
{
delete_node_return __return__;
/// int search;
int search = true;
/// search = search_root(compare, FALSE, root, item, out);
{
search_root_return __result__;
__result__ = search_root(compare, FALSE, root, item);
__return__.out = __result__.out;
search = __result__.value;
}
/// if(!search)
if(!search)
{
/// return FALSE;
__return__.value = FALSE;
return __return__;
}
/// search_root(find_min, FALSE, out->children_[RIGHT], NULL, out->children_[RIGHT]);
{
search_root_return __result__;
__result__ = search_root(find_min, FALSE, __return__.out->children_[RIGHT], FatPointer<int>());
__return__.out->children_[RIGHT] = __result__.out;
}
/// out->children_[RIGHT]->children_[LEFT] = out->children_[LEFT];
__return__.out->children_[RIGHT]->children_[LEFT] = __return__.out->children_[LEFT];
/// out = out->children_[RIGHT];
__return__.out = __return__.out->children_[RIGHT];
/// return TRUE;
__return__.value = TRUE;
return __return__;
}
tree* search_root(tree** root,tree** p)
{
if((*root)==NULL)return NULL;
if((*root)->left==*p||(*root)->right==(*p))return *root;
if((*p)->data<(*root)->data){
return search_root(&((*root)->left),p);
}
if((*p)->data>(*root)->data){
return search_root(&((*root)->right),p);
}
}
static void full_gc(lgc_state_t* gc, int gen)
{
lgc_list_head_t* head = gc->gen0;
switch (gen) {
case 2: lgc_list_combine(head, gc->gen2); //pass to 1
case 1: lgc_list_combine(head, gc->gen1); //pass to 0
case 0: break;
default:
assert(0);
}
search_root(head, gc->gc_root);
collect_reachable(gc->gc_root, head);
free_unreachable(gc, head);
switch(gen) {
case 2:
{
lgc_list_combine(gc->gen2, gc->gc_root);
gc->state = LGC_GEN2;
}; break;
case 1:
{
lgc_list_combine(gc->gen2, gc->gc_root);
gc->state = LGC_GEN1;
}; break;
case 0:
{
lgc_list_combine(gc->gen1, gc->gc_root);
gc->state = LGC_GEN0;
}; break;
default:;
}
}
/*
adiciona a matriz em forma de array na priority queue
checa se ja nao existe a mesma matriz na mesma
*/
void add_priority_queue(heap_node **leaf, int key, int *array, int size) {
if(leaf == NULL || array == NULL || size < 1) return;
int i = search_data(search_root(*leaf), array, key, size);
if(i == 0) return; // array exist in priority queue
*leaf = (heap_node*) insert_node(leaf, key, array);
}
int main() {
double val,root;
printf("enter number to take square root of: ");
scanf("%lf", &val);
root = search_root(val);
printf("The square root is: %lf\n", root);
return 0;
}
find_return find(tree _this,FatPointer<int> item)
{
find_return __return__;
/// out = this;
__return__.out = _this;
/// return search_root(out.compare_, FALSE, out.root_, item, out.root_);
{
search_root_return __result__ = search_root(__return__.out.compare_, FALSE, __return__.out.root_, item);
__return__.out.root_ = __result__.out;
}
return __return__;
}
insert_return insert(tree _this, FatPointer<int> item)
{
insert_return __return__;
/// out = this;
__return__.out = _this;
/// search_root(out.compare_, TRUE, out.root_, item, out.root_);
{
search_root_return __result__ = search_root(__return__.out.compare_, TRUE, __return__.out.root_, item);
__return__.out.root_ = __result__.out;
}
///
return __return__;
}
/*
TODO tentar diminuir o numero de passos
*/
int main(void) {
int dimension=3;
int **initial = mount_board("./initial_state.txt");
if(initial == NULL) return -1;
int **final = mount_board("./final_state.txt");
if(final == NULL) return -1;
heap_node *node = NULL;
node_queue *queue = NULL;
solve_puzzle(initial, final, &node, &queue, dimension);
free_matrix(initial, dimension);
free_matrix(final, dimension);
free_priority_queue(search_root(node));
free_queue(&queue);
printf("ok\n");
return 0;
}
int main()
{
tree* root=NULL;
tree* a1=(tree*)malloc(sizeof(tree));
memset(a1,0,sizeof(tree));
a1->data=1;
tree* a2=(tree*)malloc(sizeof(tree));
memset(a2,0,sizeof(tree));
a2->data=2;
tree* a3=(tree*)malloc(sizeof(tree));
memset(a3,0,sizeof(tree));
a3->data=3;
tree* a4=(tree*)malloc(sizeof(tree));
memset(a4,0,sizeof(tree));
a4->data=4;
tree* a5=(tree*)malloc(sizeof(tree));
memset(a5,0,sizeof(tree));
a5->data=5;
insert(&root,&a3);
insert(&root,&a1);
insert(&root,&a2);
insert(&root,&a4);
insert(&root,&a5);
tree* ptr=NULL;
ptr=search(&root,1);
printf("ptr:%p\n",ptr);
printf("ptr:%d\n",ptr->data);
tree* p=search_root(&root,&ptr);
printf("p:%p\n",p);
printf("p:%d\n",p->data);
del(&root,2);
travel(&root);
return 0;
}
void del(tree** root,int a)
{
tree* p=NULL;
tree* p_root=NULL;
p=search(&(*root),a);
printf("del p:%p\n",p);
p_root=search_root(&(*root),&p);
printf("del proot:%p\n",p_root);
if(p==p_root->left)
{
p_root->left=NULL;
if(p->left!=NULL)
{
insert(&p_root,&(p->left));
}
if(p->right!=NULL)
{
insert(&p_root,&(p->right));
}
}
if(p==p_root->right)
{
p_root->right=NULL;
if(p->right!=NULL)
{
insert(&p_root,&(p->right));
}
if(p->left!=NULL)
{
insert(&p_root,&(p->left));
}
}
free(p);
p=NULL;
}
static void search_start( int dice )
{
int iret;
history_dice( dice );
iret = search_root( dice );
if( iret == -3 )
{
out( " This game was already concluded.\n");
return;
}
else if( iret == -2 )
{
out( " This game was already concluded.\n");
return;
}
else if( iret == -1 )
{
out( " Search() failed.\n" );
return;
}
out_position();
return;
}
/*Inizializza la ricerca e gestisce l'iterative deeping*/
unsigned int find_best_move(const int output_mode,const int search_mode) {
int depth, score, i,c,d,start_depth;
int alpha, beta;
MOVE m = {0};
/*inizializzazioni varie*/
tree.start_time = time_elapsed();
tree.stop_time = tree.start_time + tree.delta_time;
Ply = 0;
Nodes = 0;
tree.abort_search = 0;
start_depth=tree.ponder_start_depth-1;
alpha = -INF;
beta = +INF;
do {
if (search_mode==CONTINUE_SEARCH) break;
start_depth=1;
tree.ponder_start_depth=1;
for (i=0;i<MAX_PLY;i++) {
tree.old_pv[i].mi=0;
tree.k_heuristic[i].m1.mi=0;
tree.k_heuristic[i].m2.mi=0;
tree.k_heuristic[i].score1=0;
tree.k_heuristic[i].score2=0;
for (c=0;c<MAX_PLY;c++) tree.pv[i][c].mi=0;
}
for (i=0;i<256;i++) {
for (c=0;c<256;c++) {
tree.h_heuristic[i][c]=0;
}
}
for (i=0;i<64;i++) {
for (c=0;c<64;c++) {
for (d=0;d<256;d++)tree.c_heuristic[i][c][d].mi=0;
}
}
if (mizar.o.use_hash) reset_tt();
}while (0);
/*Precalcoliamo*/
Phase(WHITE) = eval_phase(WHITE);
Phase(BLACK) = eval_phase(BLACK);
/*Prepariamo il nodo radice*/
root();
Nodes=0;
if (output_mode == IO_CONSOLE)
printf("ply score time nodes pv\n");
/*iterative deeping*/
for (depth = start_depth;depth <= tree.max_depth;depth++) {
tree.ponder_start_depth=depth;
tree.follow_pv = 1;
score = search_root( alpha, beta, depth);
if (tree.abort_search)
break;
if (score<=alpha || score >=beta) {
alpha = -INF;
beta = +INF;
tree.follow_pv = 1;
score = search_root( alpha, beta, depth);
if (tree.abort_search)
break;
}
else {
alpha = score - ASPIRATION_W;
beta = score + ASPIRATION_W;
}
m.mi = tree.pv[0][0].mi;
for (i=0;i<MAX_PLY;i++)
tree.old_pv[i].mi=0;
sort_root_nodes();
for (i = 0;i < tree.pv_lenght[0];i++)
tree.old_pv[i] = tree.pv[0][i];
if (output_mode == IO_CONSOLE) {
printf("%3d %5d %8d %9d", depth, score, (time_elapsed() - tree.start_time) / 100, Nodes);
}
else if (output_mode == IO_WINBOARD) {
printf("%d %d %d %d", depth, score, (time_elapsed() - tree.start_time) / 10, Nodes);
}
if (output_mode) {
if (!mizar.o.only_pv) printf(" Phs:%d Phx:%d",Phase(Side),Phase(Xside));
for (i = 0;i < tree.pv_lenght[0];i++)
printf(" %s", move2str(tree.old_pv[i]));
printf("\n");
fflush(stdout);
}
}
return (m.mi);
}