示例#1
0
文件: main.c 项目: Jobling/ADRC
// ----------------------------------------------- Main --------------------------------------------
int main(int argc, char **argv){
	Graph G;
	char filename[BUFFSIZE];
	int source, destination;
	double elapsed_time;
	clock_t start, end;

	// Parsing arguments
	switch(argc){
		case(4):
			if((sscanf(argv[2], "%d", &source) != 1) || (sscanf(argv[3], "%d", &destination) != 1)){
				printf("Inputs must be integers.\n");
				exit(1);
			}
		case(3):
			VERBOSE = 1;
		case(2):
			sscanf(argv[1], "%s", filename);
			break;
		default:
			printf("Wrong number of arguments.\n");
			exit(1);
	}
	

	// Reading Graph
	G = readGraph(filename);

	// Printing graphs information
	printf("-------------------------------------------------------\n");
	printf("There are %d nodes and %d edges!\n", G->V, G->E);
	printf("There are %d nodes and %d edges on the 'residual' network!\n", 2*G->V, 4*G->E + 2*G->V);
	printf("-------------------------------------------------------\n");
	
	// If there is a defined pair of nodes only compute its path
	if(argc == 4){
		if(EdmondsKarp(G, source, destination + NETSIZE))
			findNodes(G, source, destination);
	// Else, compute all of them
	}else{
		start = clock();
		for(source = 0; source < NETSIZE; source++)
			for(destination = source + 1; destination < NETSIZE; destination++)
				if(source != destination)
					if(EdmondsKarp(G, source, destination + NETSIZE))
						findNodes(G, source, destination);
				
		end = clock();
		elapsed_time = (double)(end - start)/CLOCKS_PER_SEC;
		printResult(G);
		printf("Algorithm takes %f seconds\n", elapsed_time);
		printf("-------------------------------------------------------\n");
	}
	
	// Free Memory allocated previously
	memoryCheck(G);
	exit(0);
}
示例#2
0
unsigned char * allocateCharVector(int n){

 int i;
 unsigned char *vector;
 if((vector = (unsigned char *) calloc(n,sizeof(unsigned char)))==NULL) 
  memoryCheck(); 

  for (i=0;i<n;i++)
   vector[i]=0.0;
 
 return vector;
}
示例#3
0
long int * allocateLongVector(int n){

 int i;
 long int *vector;
 if((vector = (long int *) calloc(n,sizeof(long int)))==NULL) 
  memoryCheck();

 for (i=0;i<n;i++)
   vector[i]=0.0;
 
 return vector;
}
示例#4
0
short int * allocateShortVector(int n){
 
 int i;
 short int *vector;
 if((vector = (short int *) calloc(n,sizeof(short int)))==NULL) 
  memoryCheck(); 

 for (i=0;i<n;i++)
   vector[i]=0.0;
 
 return vector;
}
示例#5
0
float * allocateFloatVector(int n){

 int i;
 float *vector;
 if((vector = (float *) calloc(n,sizeof(float)))==NULL) 
  memoryCheck();
 
 for (i=0;i<n;i++)
   vector[i]=0.0;

 return vector;
}
示例#6
0
double * allocateDoubleVector(int n){
 
 int i;
 double *vector;
 if((vector = (double *) calloc(n,sizeof(double)))==NULL) 
  memoryCheck();

 for (i=0;i<n;i++)
   vector[i]=0.0;
 
 return vector;
}
示例#7
0
int
Imginfo::memoryCheck(DDLSymbolTable *symtab, char *errmsg, int *mbytesShort)
{
    int i;

    *mbytesShort = 0;			// Amount of additional memory needed

    int rank;
    if ( ! symtab->GetValue("rank", rank) ) {
	sprintf(errmsg,"No \"rank\" FDF entry.");
	return FALSE;
    }
    int bits;
    if ( ! symtab->GetValue("bits", bits) ) {
	sprintf(errmsg,"No \"bits\" FDF entry.");
	return FALSE;
    }
    char *storage;
    if ( ! symtab->GetValue("storage", storage) ) {
	sprintf(errmsg,"No \"storage\" FDF entry.");
	return FALSE;
    }
    int side;
    double words = 1;
    for (i=0; i<rank; i++){
	if ( ! symtab->GetValue("matrix", side, i) ) {
	    sprintf(errmsg,"No \"matrix\" FDF entry for dimension %d.", i+1);
	    return FALSE;
	}
	words *= side;
    }

    /* Do we have enough memory to read this in? */
    double srcbytes = (bits / 8) * words;
    double totbytes = srcbytes;
    if (bits != 32 || (strcasecmp(storage,"float") != 0)) {
	/* Extra memory for dealing with data conversion */
	totbytes += 2 * (srcbytes * 32 / bits);
    }
    int meg = 1 << 20;
    int mbytesReq = (int)((totbytes + (meg - 1) ) / meg);
    if (!memoryCheck(mbytesReq, errmsg, mbytesShort)){
	return FALSE;
    }
    
    return TRUE;
}
示例#8
0
ex_immed()
{
	int i, *ip, j;
	struct item *p;
	struct nlist *n;
	double f;
	char fname[64];						/* Array for filename */
	char *cp, *vfname();

	i = *pcp++;
	switch(i) {

	default:
		error("immed B");

	case SCRIPT:
		if(protofile > 0) close(protofile);
		protofile = 0;
		cp = vfname(fname);
		if(equal(cp, "off")) return;
		if((protofile = open(cp, 1)) > 0){
			lseek(protofile, 0L, 2);	/* append to existing file */
			printf("[appending]\n");
		}
		else {
			/*
			 * create new file
			 */
			protofile = opn(cp, 0644);
			printf("[new file]\n");
		}
		write(protofile, "\t)script on\n", 12);
		return;

	case DEBUG:
		debug = ~debug;
		return;

	case MEMORY:
		memoryCheck();
		return;

	case DIGITS:
		i = topfix();
		if(i < 1 || i > 20) error("digits D");
		printf("was %d\n",thread.digits);
		thread.digits = i;
		return;

	case TRACE:
		funtrace = 1;
		return;

	case UNTRACE:
		funtrace = 0;
		return;

	case WRITE:
		funwrite(0);
		return;

	case DEL:
	case EDITF:
		sp[0] = sp[-1];		/*	duplicate top of stack  */
		sp++;
		funwrite(scr_file);
		funedit(scr_file, i);
		unlink(scr_file);
		return;


	case EDIT:
		funedit(0, i);
		return;

	case FUZZ:
		i = topfix();
		if(i <= 0) {
			thread.fuzz = 0.;
			return;
		}
		f = i;
		thread.fuzz = exp(-f*2.3025851);
		return;

	case ORIGIN:
		printf("was %d\n",thread.iorg);
		thread.iorg = topfix();
		return;

	case WIDTH:
		i = topfix();
		if(i < 1) error("width D");
		printf("was %d\n",thread.width);
		thread.width = i;
		return;

	case READ:
		funread(0);
		return;

	case ERASE:
		p = sp[-1];
		sp--;
		erase(p);
		return;

	case CONTIN:
		i = opn("continue", 0644);
		wssave(i, 0);
		printf(" continue");

	case OFF:
		term(0);

	case VARS:
		for(n=nlist; n->namep; n++) {
			if(n->itemp && n->use == DA && n->namep[0] != 'L') {
				if(column+8 >= thread.width) printf("\n\t");
				printf(n->namep);
				putchar('\t');
			}
		}
		putchar('\n');
		return;

	case FNS:
		for(n=nlist; n->namep; n++) {
			if(n->use == DF || n->use == MF || n->use == NF) {
				if(column+8 >= thread.width) printf("\n\t");
				printf(n->namep);
				putchar('\t');
			}
		}
		putchar('\n');
		return;

	case CODE:
		n = (struct nlist *)sp[-1];
		sp--;
		switch(n->use){
		default:
			error("not a fn");
		case NF:
		case MF:
		case DF:
			if(n->itemp == 0) funcomp(n);
			ip = (int *)n->itemp;
			for(i=0; i <= *ip; i++){
				printf(" [%d] ", i);
				dump(ip[i+1], 0);
			}
			putchar('\n');
		}
		return;

	case RESET:
		while(gsip) ex_ibr0();
		longjmp(reset_env, 0);

	case SICOM:
		tback(1);
		return;

	case CLEAR:
		clear();
		printf("clear ws\n");
		goto warp1;				/* four lines down, or so... */

	case LOAD:
	case PLOAD:
		j = opn(vfname(fname), 0);
		clear();
		if (i == LOAD) wsload(j, 0);
		if (i == PLOAD) wsload(j, 1);
		printf(" %s\n", fname);
		evLlx();				/* possible latent expr evaluation */
warp1:
		/*
		 * this garbage is necessary because clear()
		 * does a brk(&end), and the normal return & cleanup
		 * procedures are guaranteed to fail (miserably).
		 *		--jjb 1/78
		 */
		sp = stack;
		longjmp(reset_env, 0);

	case LIB:
		listdir();
		return;

	case COPY:
		if(gsip) error("si damage -- type ')reset'");
		wsload(opn(vfname(fname),0), 0);
		printf(" copy %s\n", fname);
		return;

	case DROPC:
		cp = vfname(fname);
		if(unlink(cp) == -1) printf("[can't remove %s]\n", cp);
		return;

	case SAVE:
	case PSAVE:
		j = opn(vfname(fname), 0644);
		if (i == SAVE) wssave(j, 0);
		if (i == PSAVE) wssave(j, 1);
		printf(" saved %s\n", fname);
		return;

	case VSAVE:
		i = opn(vfname(fname), 0644);
		vsave(i);
		putchar('\n');
		return;

	case SHELL:
		ex_shell();
		return;

	case LIST:
		ex_list();
		return;

	case PRWS:
		ex_prws();
		return;

	}
}
示例#9
0
Imginfo*
Imginfo::ddldata_load(char *filename, char *errmsg, DDLSymbolTable *ddlst)
{

    if (ddlst){
	st = ddlst;
    }else{
	/* Create a DDL symbol table and parse the input file */
	st = ParseDDLFile(filename);// Get header
	int mbytes;
	if (!memoryCheck(st, errmsg, &mbytes)){
	    return NULL;
	}
	if (!st->MallocData()){ // Get data
	    msgerr_print("Cannot read data from %s.", filename);
	    delete st;
	    return NULL;
	}
    }
    if (filename){
	st->SetValue("dirpath", "/");
	st->SetValue("filename", filename);
    }

    /*st->PrintSymbols();/*CMP*/

    int rank = 1;
    if ( ! st->GetValue("rank", rank) ) {
	sprintf(errmsg,"No \"rank\" FDF entry.");
	return NULL;
    }
    
    char *spatial_rank;
    if ( ! st->GetValue("spatial_rank", spatial_rank)){
	if (st->GetValue("subrank", spatial_rank)){
	    st->SetValue("spatial_rank", spatial_rank);
	}else{
	    sprintf(errmsg,"No \"spatial_rank\" entry.");
	    return NULL;
	}
    }

    int bits=0;
    st->GetValue("bits", bits);
    int pixelmax = G_Get_Sizecms2(Gframe::gdev);
    vs = 4200.0 * pixelmax / 127;	// Default vscale value

    char* storage = "";
    st->GetValue("storage", storage);
    if ((strcmp(storage, "float") == 0) && (bits == 32)) {
	type = TYPE_FLOAT;
    } else 
    {
	if (bits < 8) {
	    sprintf(errmsg,"Invalid \"bits\" field.");
	    return NULL;
	}
  	int datasize = st->DataLength() / (bits/8);  
  	float* dataptr = new float[datasize];
	if (dataptr == 0) {
	    sprintf(errmsg,"Unable to allocate memory.");
	    return NULL;
	}

  	if (strcmp(storage, "float") == 0) {
	    if (bits == 64) {
  	  	convertdata( (double *)st->GetData(), dataptr, datasize);
	    }
	    else {
		sprintf(errmsg,"Unsupported bits/storage parameters.");
		return NULL;
	    }
  	} else if (strcmp(storage, "char") == 0) {
	    if (bits == 8) {
		vs =  pixelmax / CHAR_MAX;
  	  	convertdata( (unsigned char *)st->GetData(), dataptr, datasize);
	    }
	    else {
		sprintf(errmsg,"Unsupported bits/storage parameters.");
		return NULL;
	    }
  	} else if (strcmp(storage, "short") == 0) {
	    if (bits == 16) {
		vs = pixelmax / SHORT_MAX;
  	  	convertdata((unsigned short *)st->GetData(),dataptr,datasize);
	    }
	    else {
		sprintf(errmsg,"Unsupported bits/storage parameters.");
		return NULL;
	    }
  	} else if (strcmp(storage, "int") == 0) {
	    if (bits == 8) {
		vs =  pixelmax / CHAR_MAX;
		convertdata( (unsigned char *)st->GetData(),dataptr,datasize);
	    } else if (bits == 16) {
		vs = pixelmax / SHORT_MAX;
		convertdata((unsigned short *)st->GetData(),dataptr,datasize);
	    } else if (bits == 32) {
		vs = pixelmax / INT_MAX;
		convertdata( (int *)st->GetData(), dataptr, datasize);
	    }else {
		sprintf(errmsg,"Unsupported bits/storage parameters.");
		return NULL;
	    }
  	} else if (strcmp(storage, "integer") == 0) {
	    if (bits == 8) {
		vs =  (float)pixelmax / CHAR_MAX;
		convertdata((unsigned char *)st->GetData(),dataptr,datasize);
	    } else if (bits == 16) {
		vs = (float)pixelmax / SHORT_MAX;
		convertdata((unsigned short *)st->GetData(),dataptr,datasize);
	    } else if (bits == 32) {
		vs = (float)pixelmax / INT_MAX;
		convertdata( (int *)st->GetData(), dataptr, datasize);
	    }else {
		sprintf(errmsg,"Unsupported bits/storage parameters.");
		return NULL;
	    }
  	} else {
	    sprintf(errmsg,"Unsupported bits/storage parameters.");
	    return NULL;
  	}
  	type = TYPE_FLOAT;
	st->SetData( (char *)dataptr, datasize*(sizeof(float)));
	st->SetValue("bits", 32);
	st->SetValue("storage", "float");
	delete [] dataptr;
    }

    AutoVscale();/*CMP*/
    double vscale;		// Not currently used
    st->GetValue("vs", vscale);
    //cout << "vs = " << vscale << endl;
  
    return this;
}