BOOL readEntryFromFile(FILE *f, BOOK_ENTRY *entry)
{
BOOL rc;
UINT64 r;
rc = readNumberFromFile(f, 8, &r);
if(rc != TRUE)
return FALSE;
entry->key=r;
rc = readNumberFromFile(f, 2, &r);
if(rc != TRUE )
return FALSE;
entry->move=r;
rc= readNumberFromFile(f, 2, &r);
if(rc != TRUE)
return FALSE;
entry->weight=r;
rc= readNumberFromFile(f, 4, &r);
if(rc != TRUE)
return FALSE;
entry->learn=r;
return TRUE;
}
int main(int argc, char * * argv)
{
//Verify that the correct number of arguments is given
if(argc != 2)
FATAL("Invalid number of command line arguments!");
//Open the map file for reading
FILE * map = fopen(argv[1], "r");
//Read the number of vertices in the file
int numVertices = readNumberFromFile(map);
//Read the number of edges in the file
int numEdges = readNumberFromFile(map);
//Read vertice data and assign it to nodal linked list "vertex"
int nodenum = readNumberFromFile(map);
int nodexcoord = readNumberFromFile(map);
int nodeycoord = readNumberFromFile(map);
Node * vertex = nodeConstructor(nodenum, nodexcoord, nodeycoord);
int i;
Node * tmpitr = vertex;
for(i = 1; i < numVertices; ++i) {
nodenum = readNumberFromFile(map);
nodexcoord = readNumberFromFile(map);
nodeycoord = readNumberFromFile(map);
tmpitr->next = nodeConstructor(nodenum, nodexcoord, nodeycoord);
tmpitr = tmpitr->next;
}
//Read edge data from the file and assign it to respective lists
for(i = 0; i < numEdges; ++i) {
int firstnode = readNumberFromFile(map);
int secondnode = readNumberFromFile(map);
insertConnection(vertex, firstnode, secondnode);
}
//Print adjacency relationships
tmpitr = vertex;
EdgeList * itrEdge = NULL;
while(tmpitr != NULL) {
printf("%d: ", tmpitr->value);
itrEdge = tmpitr->edges;
while(itrEdge != NULL) {
printf("%d ", itrEdge->connectedto);
itrEdge = itrEdge->next;
}
printf("\n");
tmpitr = tmpitr->next;
}
return EXIT_SUCCESS;
}
int * readQueries(FILE * query, int numQueries)
{
int i;
int * retArr = malloc(sizeof(int) * 2 * numQueries);
for(i = 0; i < (2 * numQueries); ++i) {
retArr[i] = readNumberFromFile(query);
}
return retArr;
}
void cGame::InitQuestions()
{
const char *kFileName = "database.txt";
const Uint32 kDataPieces = 6;
for(int questionNum = 0; questionNum < kAmountOfQuestions; ++questionNum)
{
cQuestion *pQuestion = new cQuestion();
pQuestion->mQuestion = readStringFromFile(kFileName, questionNum, kDataPieces, 0);
pQuestion->mAnswer1 = readStringFromFile(kFileName, questionNum, kDataPieces, 1);
pQuestion->mAnswer2 = readStringFromFile(kFileName, questionNum, kDataPieces, 2);
pQuestion->mAnswer3 = readStringFromFile(kFileName, questionNum, kDataPieces, 3);
pQuestion->mAnswer4 = readStringFromFile(kFileName, questionNum, kDataPieces, 4);
pQuestion->mCorrectAnswer = readNumberFromFile(kFileName, questionNum, kDataPieces, 5);
mList.push_back( pQuestion );
}
}
void txGeneAccession(char *oldBedFile, char *lastIdFile, char *newBedFile, char *txToAccFile,
char *oldToNewFile)
/* txGeneAccession - Assign permanent accession number to genes. */
{
/* Read in all input. */
struct bed *oldList = bedLoadNAll(oldBedFile, 12);
verbose(2, "Read %d from %s\n", slCount(oldList), oldBedFile);
struct bed *newList = bedLoadNAll(newBedFile, 12);
verbose(2, "Read %d from %s\n", slCount(newList), newBedFile);
int txId = readNumberFromFile(lastIdFile);
verbose(2, "Last txId used was %d (from %s)\n", txId, lastIdFile);
/* Make a random-access data structure for old list. */
struct hash *oldHash = bedsIntoKeeperHash(oldList);
/* Make a little hash to help prevent us from reusing an
* old accession twice (which might happen if we extend it
* in two incompatible ways). */
struct hash *usedHash = hashNew(16);
/* Record our decisions in hash as well as file. */
struct hash *idToAccHash = hashNew(16);
/* Loop through new list first looking for exact matches. Record
* exact matches in hash so we don't look for them again during
* the next, "compatable" match phase. */
struct hash *oldExactHash = hashNew(16), *newExactHash = hashNew(16);
struct bed *oldBed, *newBed;
FILE *f = mustOpen(txToAccFile, "w");
FILE *fOld = mustOpen(oldToNewFile, "w");
for (newBed = newList; newBed != NULL; newBed = newBed->next)
{
oldBed = findExact(newBed, oldHash, usedHash);
if (oldBed != NULL)
{
hashAdd(oldExactHash, oldBed->name, oldBed);
hashAdd(newExactHash, newBed->name, newBed);
hashAdd(usedHash, oldBed->name, NULL);
fprintf(f, "%s\t%s\n", newBed->name, oldBed->name);
hashAdd(idToAccHash, newBed->name, oldBed->name);
fprintf(fOld, "%s:%d-%d\t%s\t%s\t%s\n", oldBed->chrom, oldBed->chromStart, oldBed->chromEnd,
oldBed->name, oldBed->name, "exact");
}
}
/* Loop through new bed looking for compatible things. If
* we can't find anything compatable, make up a new accession. */
for (newBed = newList; newBed != NULL; newBed = newBed->next)
{
if (!hashLookup(newExactHash, newBed->name))
{
oldBed = findCompatible(newBed, oldHash, usedHash);
if (oldBed == NULL)
{
char newAcc[16];
txGeneAccFromId(++txId, newAcc);
strcat(newAcc, ".1");
fprintf(f, "%s\t%s\n", newBed->name, newAcc);
hashAdd(idToAccHash, newBed->name, cloneString(newAcc));
oldBed = findMostOverlapping(newBed, oldHash);
char *oldAcc = (oldBed == NULL ? "" : oldBed->name);
fprintf(fOld, "%s:%d-%d\t%s\t%s\t%s\n", newBed->chrom, newBed->chromStart, newBed->chromEnd,
oldAcc, newAcc, "new");
}
else
{
char *acc = cloneString(oldBed->name);
char *ver = strchr(acc, '.');
if (ver == NULL)
errAbort("No version found in %s", oldBed->name);
*ver++ = 0;
int version = sqlUnsigned(ver);
char newAcc[16];
safef(newAcc, sizeof(newAcc), "%s.%d", acc, version+1);
hashAdd(usedHash, oldBed->name, NULL);
fprintf(f, "%s\t%s\n", newBed->name, newAcc);
hashAdd(idToAccHash, newBed->name, newAcc);
fprintf(fOld, "%s:%d-%d\t%s\t%s\t%s\n", newBed->chrom, newBed->chromStart, newBed->chromEnd,
oldBed->name, newAcc, "compatible");
}
}
}
carefulClose(&f);
/* Make a random-access data structure for old list. */
struct hash *newHash = bedsIntoKeeperHash(newList);
/* Write record of ones that don't map. */
for (oldBed = oldList; oldBed != NULL; oldBed = oldBed->next)
{
if (!hashLookup(usedHash, oldBed->name))
{
char *newAcc = "";
struct bed *newBed = findMostOverlapping(oldBed, newHash);
if (newBed != NULL)
newAcc = hashMustFindVal(idToAccHash, newBed->name);
fprintf(fOld, "%s:%d-%d\t%s\t%s\t%s\n", oldBed->chrom, oldBed->chromStart, oldBed->chromEnd,
oldBed->name, newAcc, "lost");
}
}
carefulClose(&fOld);
if (!optionExists("test"))
{
FILE *fId = mustOpen(lastIdFile, "w");
fprintf(fId, "%d\n", txId);
carefulClose(&fId);
}
}
int main(int argc, char * * argv)
{
//Verify that the correct number of arguments is given
if(argc != 3)
FATAL("Invalid number of command line arguments!");
//Open the map file for reading
FILE * map = fopen(argv[1], "r");
//Read the number of vertices in the file
int numVertices = readNumberFromFile(map);
//Read the number of edges in the file
int numEdges = readNumberFromFile(map);
//Read vertice data and assign it to nodal linked list "vertex"
int nodenum = readNumberFromFile(map);
int nodexcoord = readNumberFromFile(map);
int nodeycoord = readNumberFromFile(map);
Node * vertex = nodeConstructor(nodenum, nodexcoord, nodeycoord);
int i;
Node * tmpitr = vertex;
for(i = 1; i < numVertices; ++i) {
nodenum = readNumberFromFile(map);
nodexcoord = readNumberFromFile(map);
nodeycoord = readNumberFromFile(map);
tmpitr->next = nodeConstructor(nodenum, nodexcoord, nodeycoord);
tmpitr = tmpitr->next;
}
//Read edge data from the file and assign it to respective lists
for(i = 0; i < numEdges; ++i) {
int firstnode = readNumberFromFile(map);
int secondnode = readNumberFromFile(map);
insertConnection(vertex, firstnode, secondnode);
}
fclose(map);
//NOTE: At this point, the graph is complete, so begin algorithm
//Open the query file for reading
FILE * query = fopen(argv[2], "r");
//Read the number of queries
int numQueries = readNumberFromFile(query);
//Read query data and store it for reference
int * queryArr = readQueries(query, numQueries);
//Store origin node in list
Node * origin = vertex;
//Loop through the queries
for(i = 0; i < (numQueries * 2); i += 2) {
//Find the starting point of the query
int startVal = queryArr[i];
int endVal = queryArr[i+1];
//If they're the same, avoid trying to do anything else
if(startVal == endVal) {
printf("0\n");
printf("%d %d\n", startVal, endVal);
}
else {
Node * start = findVertexByValue(startVal, origin);
Node * end = findVertexByValue(endVal, origin);
start->weight = 0;
while(areAllNotRemoved(origin)) {
//Set the weight check to find minimum node
Node * itrNode = findLowestNode(origin);
//Make sure we're not done
if(itrNode->value == endVal)
break;
//Update weights for adjacent nodes
updateAdjacentWeights(itrNode, origin);
}
if(end->weight == PSEUDOINF)
FATAL("Final node weight was not updated... possibly unconnected?");
//Produce the result list
ResultList * results = reslistConstructor(end->value, end->weight);
Node * before = findVertexByValue(end->prev, origin);
while(before->value != startVal) {
ResultList * pinonfront = reslistConstructor(before->value, before->weight);
pinonfront->next = results;
results = pinonfront;
before = findVertexByValue(before->prev, origin);
}
//Make sure the first number in the list is origin
if(results->value != startVal) {
ResultList * pinonfront2 = reslistConstructor(startVal, start->weight);
pinonfront2->next = results;
results = pinonfront2;
}
//Verify weights and assign the end weight
//end->weight = verifyWeightsAndAssign(results, origin);
//Print the final results
printf("%ld\n", end->weight);
ResultList * printitr = results;
while(printitr != NULL) {
printf("%d ", printitr->value);
printitr = printitr->next;
}
printf("\n");
reslistDestroy(results);
resetGraph(origin);
}
}
//Free used memory
fclose(query);
free(queryArr);
nodeDestroy(origin);
return EXIT_SUCCESS;
}
