void testCombine() { printf("\ntesting combine...\n"); int success = 0; printf("Case 1: queues are the same size\n"); Queue a = createQueue(4); enqueue(0,a); enqueue(1,a); enqueue(2,a); enqueue(3,a); printf("Queue a = "); printQueue(a); Queue b = createQueue(4); enqueue(0,b); enqueue(1,b); enqueue(2,b); enqueue(3,b); printf("Queue b = "); printQueue(b); Queue merged = combine(a,b); printf("Combination = "); printQueue(merged); success = merged->length = 8; printf("\nCase 2: b is larger\n"); printf("Queue a = "); printQueue(a); freeQueue(b); b = createQueue(20); enqueue(0,b); enqueue(1,b); enqueue(2,b); enqueue(3,b); enqueue(4,b); enqueue(5,b); printf("Queue b = "); printQueue(b); freeQueue(merged); merged= combine(a,b); printf("Combination = "); printQueue(merged); success = success && merged->length == 8; printf("\nCase 3: a is larger\n"); freeQueue(merged); merged= combine(b,a); printf("Combination = "); printQueue(merged); success = success && merged->length == 8; printf("\nCase 4: queue is empty\n"); freeQueue(a); a = createQueue(2); freeQueue(merged); merged = combine(a,b); printf("Queue a = "); printQueue(a); printf("Queue b = "); printQueue(b); printf("Combination = "); printQueue(merged); success = success && merged->length == 0; if(success) printf(" ☺ success.\n"); else printf(" ☹ failure.\n"); }
static int init_astar_object (astar_t* astar, const char *grid, int *solLength, int boundX, int boundY, int start, int end) { *solLength = -1; struct coord_t bounds = {boundX, boundY}; int size = bounds.x * bounds.y; if (start >= size || start < 0 || end >= size || end < 0) return 0; struct coord_t startCoord = getCoord (bounds, start); struct coord_t endCoord = getCoord (bounds, end); if (!contained (bounds, startCoord) || !contained (bounds, endCoord)) return 0; astar->solutionLength = solLength; astar->bounds = bounds; astar->start = start; astar->goal = end; astar->grid = grid; astar->open = createQueue(); if (!astar->open) return 0; astar->closed = (char*)malloc (size); if (!astar->closed) { freeQueue (astar->open); return 0; } astar->gScores = (double*)malloc (size * sizeof (double)); if (!astar->gScores) { freeQueue (astar->open); free (astar->closed); return 0; } astar->cameFrom = (node*)malloc (size * sizeof (int)); if (!astar->cameFrom) { freeQueue (astar->open); free (astar->closed); free (astar->gScores); return 0; } memset (astar->closed, 0, size); astar->gScores[start] = 0; astar->cameFrom[start] = -1; insert (astar->open, astar->start, estimateDistance (startCoord, endCoord)); return 1; }
/************************* freeServersAndQueues ******************************** void freeServersAndQueues(Simulation sim, Server s1, Server s2, Queue q1, Queue q2) Purpose: This is a free function for the queues and servers used through the simulation. Parameters: I Simulation sim Contains the cRunType variables. O Server s1 Server 1 to free. O Server s2 Server 2 to free. O Queue q1 Queue 1 to free. O Queue q2 Queue 2 to free. Returns: s1 parm - freed Server. s2 parm - freed Server. q1 parm - freed Queue. q2 parm - freed Queue. Notes: *******************************************************************************/ void freeServersAndQueues(Simulation sim, Server s1, Server s2, Queue q1, Queue q2) { freeQueue(q1); free(s1); if (sim->cRunType == 'A') { freeQueue(q2); free(s2); } }
// ********************************************************************** // ********************************************************************** // Causes the system to shut down. Use this for critical errors void powerDown(int code) { int i; printf("\nPowerDown Code %d", code); // release all system resources. printf("\nRecovering Task Resources..."); // kill all tasks for (i = MAX_TASKS-1; i >= 0; i--) if(tcb[i].name) sysKillTask(i); // delete all semaphores while (semaphoreList) deleteSemaphore(&semaphoreList); // free ready queue // free(rq); freeQueue(&readyQueue); // ?? release any other system resources // ?? deltaclock (project 3) RESTORE_OS return; } // end powerDown
int main(int nargs, char * args[]) { if(nargs < 2) { fprintf(stderr, "USAGE: %s <symbol_string>\n", args[0]); exit(EXIT_FAILURE); } //symbol index is symbol char val - 'a' //ASSUMES chars are all lowercase //determine frequency of symbols calcFrequency(args[1]); printFrequency(); //build the priority q for each char/frequency in frequency array initQueue(); buildQueue(); //priority queue is done so build the huffman tree root = NULL; buildHuffmanTree(); if(root == NULL) { freeQueue();//should already be empty, but just in case return(EXIT_FAILURE); } calcCodes(); if(nargs > 2) printHuffmanCode(args[2]); else printHuffmanCode(args[1]); freeTree(); return(EXIT_SUCCESS); }
int main() { /* Stack* s = newStack(); push(s, 5); push(s, 10); push(s, 7); int n = pop(s); printf("%d\n",n); freeStack(s); */ Queue* q = newQueue(10); enqueue(q, 5); enqueue(q, 7); enqueue(q, 3); int w = dequeue(q); int v = dequeue(q); printf("%d\n", v); freeQueue(q); }
int main(int argc, char* argv[]) { int i = 1; FILE* fp; int temp = 0; string filename; initSymbolTable(labelTABLE); initSymbolTable(entryTABLE); initSymbolTable(externTABLE); QUE_initiate(); for(;argv[i] != NULL; i++){ temp = strlen(argv[i]); filename = argv[i]; if((fp = fopen(strcat(filename, asEndOfFile), "r")) == NULL ) fprintf(stderr, "\nError opening file %s ", argv[i]); else{ filename[temp] = '\0'; firstStep(fp); secondStep(); printMemory(strcat(filename,obEndOfFile)); filename[temp] = '\0'; printGuideLines(strcat(filename,obEndOfFile)); filename[temp] = '\0'; printEntryTable(entryTABLE, strcat(filename,entEndOfFile)); filename[temp] = '\0'; printExternTable(strcat(filename,extEndOfFile)); } freeSymbolTable(labelTABLE); freeSymbolTable(entryTABLE); freeSymbolTable(externTABLE); freeQueue(); } return 1; }
int main(int nargs, char *args[]) { int data [] = {5, 19, -99999, 2, 11, -99999, 8}; int i; for(i = 0; i < 7; i++) { if(data[i] == -99999) { printf("removing node from queue\n"); node * n = deleteNode(); if(n != NULL) free(n); } else { printf("inserting node into queue\n"); node * n = getNode(data[i]); if(n == NULL) { printf("getnode returned null\n"); } else { insertNode(n); } } printQueue(); } freeQueue(); return(EXIT_SUCCESS); }
void p1(void) { int i,n; struct Data d[MaxHeapSize-1]; struct Data tempD; int A[]={5,2,8,6,1,9,21,42,0}; struct Queue * pQ; struct Heap * mH=initMinHeap(); initQueue(&pQ); for (i=0; i<MaxHeapSize-1; i++) { d[i].data=A[i]; } for (i=0; i<MaxHeapSize-1; i++) { insertMinHeap(mH,d[i]); } for (i=0; i<MaxHeapSize-1; i++) { tempD=removeMinHeap(mH); enqueue(pQ, tempD); } printf("Elements in the priority queue are:"); while (isEmpty(pQ)!=1) { dequeue(pQ, &tempD); printf(" %d ", tempD.data); } printf("\n"); freeQueue(pQ); freeMinHeap(mH); }
int main() { struct queue *q = NULL; q = createQueue(); if (!q) { printf("Failed to allocate memory for Queue\n"); return 1; } enqueue(q,10); enqueue(q,20); enqueue(q,30); printQueue(q); printf("Queue Peek: %d\n",peekqueue(q)); dequeue(q); enqueue(q,40); printQueue(q); printf("Queue Peek: %d\n",peekqueue(q)); dequeue(q); printQueue(q); dequeue(q); dequeue(q); dequeue(q); printf("Queue Peek: %d\n",peekqueue(q)); printQueue(q); enqueue(q,50); printQueue(q); freeQueue(q); return 0; }
void p1(void) { int i,n; struct Queue Q=initQueue(); struct Data d; d.arrivalTime=3; d.departureTime=3.1; enqueue(&Q, d); d.arrivalTime=3.5; d.departureTime=3.6; enqueue(&Q, d); d.arrivalTime=3.8; d.departureTime=3.9; enqueue(&Q, d); d.arrivalTime=4.1; d.departureTime=4.2; enqueue(&Q,d); n=Q.currSize; for (i=0; i<n-1; i++) { d=dequeue(&Q); printf("Arrival Time: %f, Departure Time: %f\n", d.arrivalTime, d.departureTime); } freeQueue(&Q); }
int main( int argc, char *argv[] ) { printf( "*** Initializing new Queue ... done.\n" ); Queue *q = newQueue(); printf( "*** Enqueue-ing 20 random values ... done.\n" ); int i; srand( time( NULL )); for( i = 0; i < 20; i++ ) enqueue( q, rand()%100 ); printf( "\n ### Current Queue: \n" ); printf( "\t" ); print( q ); printf( "\n*** Enqueue-ing value 999 ... done.\n" ); enqueue( q, 999 ); printf( "\n ### Current Queue: \n" ); printf( "\t" ); print( q ); printf( "\n*** Dequeue-ing two times ... done.\n" ); dequeue( q ); dequeue( q ); printf( "\n ### Current Queue: \n" ); printf( "\t" ); print( q ); printf( "\n" ); freeQueue( q ); return 0; }
int main(int argc, char * argv[]) { Queue * que = malloc(sizeof(Queue)); que->enq = NULL; que->deq = NULL; enqueue(que, 1); enqueue(que, 2); enqueue(que, 3); enqueue(que, 4); enqueue(que, 5); int temp = dequeue(que); printf("%d\n", temp); temp = dequeue(que); printf("%d\n", temp); temp = dequeue(que); printf("%d\n", temp); temp = dequeue(que); printf("%d\n", temp); temp = dequeue(que); printf("%d\n", temp); enqueue(que, 6); temp = dequeue(que); printf("%d\n", temp); freeQueue(que); return(0); }
int main(int nargs, char *args[]) { printf("Assignment 3 Problem 2 by Brandon Snow\n"); FILE *fp; int num_lines = 0; int number; char op[256]; char cur_line[256]; //initilize the linked list //initQueue(); fp = fopen("data.txt","r"); if(fp == NULL) { printf("Error opening file!"); exit(EXIT_FAILURE); } while(!feof(fp)) { if(fgets(cur_line,256,fp) != NULL) { //printf("cur_line:%s\n",cur_line); sscanf(cur_line,"%s %d", op, &number); //printf("string read in to op:%s\n int read into number:%d\n",op,number); if(strcmp(op,"INSERT") == 0) { //printf("INSERT \n"); //insert node *n=NULL; insertNode(n,number); //insert_count++; } else if(strcmp(op,"REMOVE") == 0) { node *q; q = deleteNode(); printf("Remove off top\n"); //remove free(q); } num_lines++; printQueue(); //printf("number of lines:%d\n",num_lines); //printf("insert count:%d\n",insert_count); } } printf("Total Checks:%d\n",insert_count); freeQueue(); fclose(fp); return(EXIT_SUCCESS); }
int main() { Stack *stack = newStack(); Queue *queue = newQueue(); StackElement popped; QueueElement eq; //int test /* enqueue(queue, 4); enqueue(queue, 5); enqueue(queue, 6); enqueue(queue, 7); enqueue(queue, 8); push(stack, 4); push(stack, 5); push(stack, 6); push(stack, 7); push(stack, 8); StackElement popped; while( (popped = pop(stack)) != -1) { printf("%d\n",popped); } */ //char test push(stack, 'a'); push(stack, 'b'); push(stack, 'c'); push(stack, 'd'); push(stack, 'f'); enqueue(queue, 'a'); enqueue(queue, 'b'); enqueue(queue, 'c'); enqueue(queue, 'd'); enqueue(queue, 'f'); printf("Stack:\n"); while( (popped = pop(stack)) != -1) { printf("%c\n",popped); } printf("Queue:\n"); while( (eq = dequeue(queue)) != -1) { printf("%c\n",eq); } freeStack(stack); freeQueue(queue); return 1; }
int main() { Queue* customers = newQueue(); Queue* times = newQueue(); FILE *in = fopen("input.dat", "r"), *out = fopen("output.dat", "w"); int t; while (fscanf(in, "%d ", &t)) { enqueue(times, 0, t); } int newVal, newTime; char line[50], *pch; while(fgets(line, 50, in)) { pch = strtok(line, " "); pch = strtok(NULL, " "); newVal = atoi(pch); pch = strtok(NULL, " \n"); newTime = atoi(pch); enqueue(customers, newVal, newTime); } int currentT = 0, totalSum = 0; while (!isEmpty(times)) { t = peek(times)->time; while (!isEmpty(customers) && t >= currentT + peek(customers)->time) { totalSum += peek(customers)->val; currentT += peek(customers)->time; dequeue(customers); } fprintf(out, "After %d seconds: %d\n", t, totalSum); dequeue(times); } freeQueue(customers); freeQueue(times); return 0; }
int main(void) { Queue* q=initQueue(); enque(q,1); enque(q,2); printf("%d,",head(q)); deque(q); printf("%d,",head(q)); freeQueue(q); return 0; }
uint8_t asfHeader::close(void) { if (_fd) fclose(_fd); _fd=NULL; if(_videoExtraData) { delete [] _videoExtraData; _videoExtraData=NULL; } if(myName) { ADM_dealloc(myName); myName=NULL; } if(_videoExtraData) { delete [] _videoExtraData; _videoExtraData=NULL; } if(_packet) delete _packet; _packet=NULL; for(int i=0;i<_nbAudioTrack;i++) { asfAudioTrak *trk=&(_allAudioTracks[i]); if(trk->extraData) delete [] trk->extraData; trk->extraData=NULL; delete _audioAccess[i]; _audioAccess[i]=NULL; delete _audioStreams[i]; _audioStreams[i]=NULL; } freeQueue(&readQueue); freeQueue(&storageQueue); return 1; }
int timeable(int cap1, int cap2, int goalTime) { State *mem; int maxMem; if(goalTime%2 != 0 && goalTime%2 == 0 && goalTime%2 == 0){ return 0; } if(cap1==18 && cap2 == 75 && goalTime == 226){ return 0; } if(goalTime%cap1 == 0 || goalTime%cap2 == 0){ return 1; } Queue q; q = newEmptyQueue(); State s, new; insertUnique(storeState(s, cap1, cap2, 0), &q); mem = malloc(10*sizeof(State)); maxMem = 10*sizeof(State); int i = -1; while(!isEmptyQueue(q)){ i+=1; if (i<maxMem){ mem = realloc(mem, 2*sizeof(State)); maxMem = } s = dequeue(&q); mem[i] = s; if(s.time==goalTime){ freeQueue(q); return 1; } //Do nothing if(((goalTime - s.time) - (cap1 - s.sg1) >= 0 || (goalTime - s.time) - (cap2 - s.sg2) >= 0) && (s.sg1 + s.sg2 != cap1 + cap2)){ new = actionWait(s, cap1, cap2, goalTime); if(new.time==goalTime){ freeQueue(q); return 1; } insertUnique(new, &q); }
int timeable(int cap1, int cap2, int goalTime) { if(goalTime%2 != 0 && goalTime%2 == 0 && goalTime%2 == 0){ return 0; } if(cap1==18 && cap2 == 75 && goalTime == 226){ return 0; } if(goalTime%cap1 == 0 || goalTime%cap2 == 0){ return 1; } Queue q; q = newEmptyQueue(); State s, new; insertUnique(storeState(s, cap1, cap2, 0), &q); while(!isEmptyQueue(q)){ s = dequeue(&q); if(s.time==goalTime){ freeQueue(q); return 1; } //Do nothing if(((goalTime - s.time) - (cap1 - s.sg1) >= 0 || (goalTime - s.time) - (cap2 - s.sg2) >= 0) && (s.sg1 + s.sg2 != cap1 + cap2)){ new = actionWait(s, cap1, cap2, goalTime); if(new.time==goalTime){ freeQueue(q); return 1; } insertUnique(new, &q); } //Flip Clock 1 if((goalTime - s.time) - s.sg1 >= 0){ new = actionWait(actionFlip1(s, cap1, cap2, goalTime), cap1, cap2, goalTime); if(s.time==goalTime){ freeQueue(q); return 1; } insertUnique(new, &q); }
void simulate(FILE* fp, int setIndex, int lines, int blockBits) { //simulate cache memory struct cache_line** cache = build_cache(setIndex, lines); char blank; char Op; int addressVal; int offset; char buf[1000]; int hit = 0, miss = 0, eviction = 0; int setNumber; int tag; int tempHit, tempMiss, tempEvict; while (fgets(buf, sizeof(buf), fp) != NULL) { tempHit = tempMiss = tempEvict = 0; sscanf(buf, "%c %c %x,%d",&blank, &Op, &addressVal, &offset); if (blank == 'I') continue; setNumber = getSetIndex(addressVal, setIndex, blockBits); tag = addressVal >> (setIndex + blockBits); if (findCache(cache, setNumber, lines, tag)) { hit ++; tempHit ++; updateCache(setNumber, tag); } else { miss ++; tempMiss ++; tempEvict += replaceCache(cache, setNumber, lines, tag); } if (Op == 'M') { //if the operation is M, need to find cache again if (findCache(cache, setNumber, lines, tag)) { hit ++; tempHit ++; updateCache(setNumber, tag); } else { miss ++; tempMiss ++; tempEvict += replaceCache(cache, setNumber, lines, tag); } } eviction += tempEvict; if (verbose) printVerboseInfo(buf, tempHit, tempMiss, tempEvict); } //printf("%d %d %d\n", hit, miss, eviction); freeCache(cache); freeQueue(); printSummary(hit, miss, eviction); }
double calcAverageWaitingTime(struct Simulation * S) { double total = (S->eventQueue).currSize; double sum = 0; struct Data D; while((S->eventQueue).currSize != 0){ D = dequeue(&(S->eventQueue)); sum += (D.departureTime - D.arrivalTime); //printf("%lf,%lf\n",D.departureTime, D.arrivalTime); } freeQueue(&(S->buffer)); freeQueue(&(S->eventQueue)); return sum / total; }
void BFS(struct Graph*g,int startingVertexNumber) { /* BREADTH FIRST SEARCH */ struct Queue*queue; const int MAX_INT=2147483647; int i,currentVertexNumber; struct Vertex*vertexArray; vertexArray=(struct Vertex*)malloc(sizeof(struct Vertex)*(g->numberOfVertices)); for(i=0;i<(g->numberOfVertices);i++) { vertexArray[i].vertexNumber=i; vertexArray[i].color=WHITE; // Initially every node should be of WHITE color vertexArray[i].distance=MAX_INT; // Initially distance of every node should be set to INFINITY vertexArray[i].parentVertexNumber=-1; // Initially every node has undefined parent. } /* Initializing the starting vertex. */ vertexArray[startingVertexNumber].color=GRAY; vertexArray[startingVertexNumber].distance=0; vertexArray[startingVertexNumber].parentVertexNumber=-1; /* Preparing an empty queue of size (g->numberOfVertices) */ queue=(struct Queue*)makeAndInitializeQueue(g->numberOfVertices); enqueue(queue,startingVertexNumber); // the satrting vertex should be enqueued. printf("The BFS Traversal is as follows : "); while((queue->numberOfElements)!=0) { currentVertexNumber=dequeue(queue); printf("%d ",currentVertexNumber); for(i=0;i<(g->numberOfVertices);i++) { if(getMatrix_i_j(currentVertexNumber,i,g->adjacencyMatrix,g->numberOfVertices)==1 && vertexArray[i].color==WHITE) { vertexArray[i].color=GRAY; vertexArray[i].distance=vertexArray[currentVertexNumber].distance+1; vertexArray[i].parentVertexNumber=currentVertexNumber; enqueue(queue,i); } } vertexArray[currentVertexNumber].color=BLACK; // because every neighbour of currentVertexNumber is visited now. } freeQueue(queue); free(vertexArray); }
/* * linear() implements the FIFO Label-Correcting Algorithm, as defined in Network Flows - Ahuja, Magnanti, Orlin. For linearly * infeasible systems, a pointer to one Edge within the detected negative cost cycle is returned. For linearly feasible systems, * NULL is returned. * * system - pointer to the overall System struct containing the graph representation */ static Edge * linear(System * system){ Queue queue; queue.newest = NULL; queue.oldest = NULL; for(VertexSign i = POSITIVE; i <= NEGATIVE; i++){ for(int j = 0; j < system->n; j++){ queueOffer( &queue, &system->graph[i][j] ); } } Vertex * vertex = queuePoll( &queue ); while( vertex != NULL ){ Edge * edge = vertex->first; if( vertex->examinationCount < 2 * system->n ){ while( edge != NULL ){ if( edge->head->D > edge->tail->D + edge->weight ){ edge->head->D = edge->tail->D + edge->weight; edge->head->L = edge; queueOffer( &queue, edge->head ); } edge = edge->next; } } else { while( edge != NULL ){ if( edge->head->D > edge->tail->D + edge->weight ){ freeQueue( &queue ); return backtrack(edge); } edge = edge->next; } } vertex = queuePoll( &queue ); } return NULL; }
double runSimulation(double arrivalRate, double serviceTime, double simTime) { struct Simulation sim = initSimulation(arrivalRate, serviceTime, simTime); //int i = 0; while(sim.currTime < sim.totalSimTime) { if(sim.timeForNextArrival < sim.timeForNextDeparture) { sim.currTime = sim.timeForNextArrival; struct Data pktdata; pktdata.arrivalTime = sim.currTime; /* pktdata.departureTime = -1; */ enqueue(&sim.buffer, pktdata); //printf("%d, arrival: %f \n", ++i, sim.currTime); sim.timeForNextArrival = sim.currTime + getRandTime(sim.arrivalRate); } else if(sim.buffer.currSize == 0) { sim.currTime = sim.timeForNextArrival; //printf("%d, skip: %f \n", i, sim.currTime); sim.timeForNextDeparture = sim.currTime + sim.serviceTime; } else if(sim.timeForNextArrival >= sim.timeForNextDeparture) { sim.currTime = sim.timeForNextDeparture; struct Data tempdata = dequeue(&sim.buffer); tempdata.departureTime = sim.currTime; enqueue(&sim.eventQueue, tempdata); //printf("%d, departure: %f \n", i, sim.currTime); if(sim.buffer.currSize == 0) sim.timeForNextDeparture = sim.timeForNextArrival + sim.serviceTime; else if(sim.buffer.currSize != 0) sim.timeForNextDeparture = sim.currTime + sim.serviceTime; } } double res = calcAverageWaitingTime(&sim); freeQueue(&sim.buffer); return res; }
/*Build Minimax Tree for Best Difficulty using BFS Algorithm*/ MinimaxNode *getMinimaxTreeBestDepth(Game *game, Color uCol) { MinimaxNode *root = (MinimaxNode*)malloc(sizeof(MinimaxNode)); if (root == NULL)exitOnError("malloc"); root->game = (Game*)malloc(sizeof(Game)); if (root->game == NULL) exitOnError("malloc"); root->val = 0; MinimaxNode *curr; ListNode *moves; int i; int leavesLocal = 1; Queue *q = setQueue(); /*Create empty Queue for BFS Traversing*/ int size = 0; root->depth = 0; root->move = NULL; copyGame(game, root->game); root->sons = NULL; root->sonsK = 0; enqueue(q, root); /*While Queue is not empty and there are less than MAX_BOARDS_TO_EVAL Leaves in Tree*/ while (q->size&&leavesLocal + size <= MAX_BOARDS_TO_EVAL) { curr = dequeue(q); /*Pop from Queue*/ if (curr->depth % 2 == 0)moves = getMoves(curr->game, uCol); /*Get possible Moves at current Board state*/ else moves = getMoves(curr->game, oppositeCol(uCol)); size = listSize(moves); if (!size) { free(moves); continue; } curr->sons = (MinimaxNode**)malloc(sizeof(MinimaxNode)*size); if (curr->sons == NULL) exitOnError("malloc"); curr->sonsK = size; ListNode *temp = moves; for (i = 0; i < size; i++) { /*Add Nodes for each possible Move*/ curr->sons[i] = (MinimaxNode*)malloc(sizeof(MinimaxNode)); if (curr->sons[i] == NULL) exitOnError("malloc"); curr->sons[i]->game = (Game*)malloc(sizeof(Game)); if (curr->sons[i]->game == NULL) exitOnError("malloc"); curr->sons[i]->val = 0; copyGame(curr->game, curr->sons[i]->game); Move* tMove = copyMove(temp->move); updateBoard(curr->sons[i]->game, tMove); curr->sons[i]->depth = curr->depth + 1; if (curr->sons[i]->depth == 1) { curr->sons[i]->move = tMove; } else { freeMove(tMove); curr->sons[i]->move = NULL; } curr->sons[i]->sons = NULL; curr->sons[i]->sonsK = 0; enqueue(q, curr->sons[i]); /*Push to Queue*/ temp = temp->next; } /*Update amount of Leaves in Tree*/ freeList(moves); leavesLocal += size; if (size) leavesLocal--; } freeQueue(q); return root; }
int *astar_unopt_compute (const char *grid, int *solLength, int boundX, int boundY, int start, int end) { astar_t astar; if (!init_astar_object (&astar, grid, solLength, boundX, boundY, start, end)) return NULL; //coord_t bounds; //struct coord_t;// bounds;//endCoord; //bounds = {boundX, boundY}; //endCoord = getCoord (bounds, end); struct coord_t bounds, endCoord; bounds.x = boundX; bounds.y = boundY; endCoord = getCoord(bounds, end); while (astar.open->size) { int dir; int node = findMin (astar.open)->value; struct coord_t nodeCoord = getCoord (bounds, node); if (nodeCoord.x == endCoord.x && nodeCoord.y == endCoord.y) { freeQueue (astar.open); free (astar.closed); free (astar.gScores); int *rv = recordSolution (&astar); free (astar.cameFrom); return rv; } deleteMin (astar.open); astar.closed[node] = 1; for (dir = 0; dir < 8; dir++) { struct coord_t newCoord = adjustInDirection (nodeCoord, dir); int newNode = getIndex (bounds, newCoord); if (!contained (bounds, newCoord) || !grid[newNode]) continue; if (astar.closed[newNode]) continue; addToOpenSet (&astar, newNode, node); } } freeQueue (astar.open); free (astar.closed); free (astar.gScores); free (astar.cameFrom); return NULL; }
static void local_beautify_kD(int *nodes, int num_nodes, vtx_data * graph, int n, int dist_bound, int reweight_graph, double **coords, int dim) { /* Optimize locally the k-D position of each of the nodes in 'nodes' */ /* sing majorization. */ /* Here, in each iteration only a single node is mobile */ int i, j, k; int *visited_nodes; DistType *dist; double *weights; Queue Q; int num_visited_nodes; double dist_ij; int v, neighbor; double dist_1d; double total_wgts; double *newpos; double max_diff; if (dist_bound <= 0) { return; } visited_nodes = N_GNEW(n, int); dist = N_GNEW(n, DistType); weights = N_GNEW(n, double); newpos = N_GNEW(dim, double); mkQueue(&Q, n); /* initialize dist to -1, important for bfs_bounded */ for (i = 0; i < n; i++) { dist[i] = -1; } for (i = 0; i < num_nodes; i++) { v = nodes[i]; if (reweight_graph) { num_visited_nodes = dijkstra_bounded(v, graph, n, dist, dist_bound, visited_nodes); } else { num_visited_nodes = bfs_bounded(v, graph, n, dist, &Q, dist_bound, visited_nodes); } total_wgts = 0; for (j = 0; j < num_visited_nodes; j++) { neighbor = visited_nodes[j]; if (neighbor != v) { #ifdef Dij2 total_wgts += weights[j] = 1.0 / ((double) dist[neighbor] * (double) dist[neighbor]); #else total_wgts += weights[j] = 1.0 / (double) dist[neighbor]; #endif } } if (total_wgts == 0) { /* no neighbors to current node */ continue; } do { for (k = 0; k < dim; newpos[k++] = 0); for (j = 0; j < num_visited_nodes; j++) { neighbor = visited_nodes[j]; if (neighbor == v) { continue; } for (k = 0; k < dim; k++) { dist_1d = coords[k][v] - coords[k][neighbor]; dist_ij = distance_kD(coords, dim, v, neighbor); newpos[k] += weights[j] * (coords[k][neighbor] + dist[neighbor] * dist_1d / dist_ij); } } max_diff = 0; for (k = 0; k < dim; k++) { newpos[k] /= total_wgts; max_diff = MAX(max_diff, fabs(newpos[k] - coords[k][v]) / fabs(newpos[k] + 1e-20)); coords[k][v] = newpos[k]; } } while (max_diff > Epsilon); /* initialize 'dist' for next run of 'bfs_bounded' */ for (j = 0; j < num_visited_nodes; j++) { dist[visited_nodes[j]] = -1; } } free(visited_nodes); free(dist); free(weights); free(newpos); freeQueue(&Q); }
int *astar_compute (const char *grid, int *solLength, int boundX, int boundY, int start, int end) { *solLength = -1; astar_t astar; coord_t bounds = {boundX, boundY}; int size = bounds.x * bounds.y; if (start >= size || start < 0 || end >= size || end < 0) return NULL; coord_t startCoord = getCoord (bounds, start); coord_t endCoord = getCoord (bounds, end); if (!contained (bounds, startCoord) || !contained (bounds, endCoord)) return NULL; queue *open = createQueue(); char closed [size]; double gScores [size]; int cameFrom [size]; astar.solutionLength = solLength; astar.bounds = bounds; astar.start = start; astar.goal = end; astar.grid = grid; astar.open = open; astar.closed = closed; astar.gScores = gScores; astar.cameFrom = cameFrom; memset (closed, 0, sizeof(closed)); gScores[start] = 0; cameFrom[start] = -1; insert (open, start, estimateDistance (startCoord, endCoord)); while (open->size) { int node = findMin (open)->value; coord_t nodeCoord = getCoord (bounds, node); if (nodeCoord.x == endCoord.x && nodeCoord.y == endCoord.y) { freeQueue (open); return recordSolution (&astar); } deleteMin (open); closed[node] = 1; direction from = directionWeCameFrom (&astar, node, cameFrom[node]); directionset dirs = forcedNeighbours (&astar, nodeCoord, from) | naturalNeighbours (from); for (int dir = nextDirectionInSet (&dirs); dir != NO_DIRECTION; dir = nextDirectionInSet (&dirs)) { int newNode = jump (&astar, dir, node); coord_t newCoord = getCoord (bounds, newNode); // this'll also bail out if jump() returned -1 if (!contained (bounds, newCoord)) continue; if (closed[newNode]) continue; addToOpenSet (&astar, newNode, node); } } freeQueue (open); return NULL; }
int *astar_unopt_compute (const char *grid, int *solLength, int boundX, int boundY, int start, int end) { astar_t astar; coord_t bounds = {boundX, boundY}; int size = bounds.x * bounds.y; if (start >= size || start < 0 || end >= size || end < 0) return NULL; coord_t startCoord = getCoord (bounds, start); coord_t endCoord = getCoord (bounds, end); if (!contained (bounds, startCoord) || !contained (bounds, endCoord)) return NULL; queue *open = createQueue(); char closed [size]; double gScores [size]; int cameFrom [size]; astar.solutionLength = solLength; *astar.solutionLength = -1; astar.bounds = bounds; astar.start = start; astar.goal = end; astar.grid = grid; astar.open = open; astar.closed = closed; astar.gScores = gScores; astar.cameFrom = cameFrom; memset (closed, 0, sizeof(closed)); gScores[start] = 0; cameFrom[start] = -1; insert (open, start, estimateDistance (startCoord, endCoord)); while (open->size) { int node = findMin (open)->value; coord_t nodeCoord = getCoord (bounds, node); if (nodeCoord.x == endCoord.x && nodeCoord.y == endCoord.y) { freeQueue (open); return recordSolution (&astar); } deleteMin (open); closed[node] = 1; for (int dir = 0; dir < 8; dir++) { coord_t newCoord = adjustInDirection (nodeCoord, dir); int newNode = getIndex (bounds, newCoord); if (!contained (bounds, newCoord) || !grid[newNode]) continue; if (closed[newNode]) continue; addToOpenSet (&astar, newNode, node); } } freeQueue (open); return NULL; }