Annotation of OpenXM_contrib/PHC/C/call_phc.c, Revision 1.1
1.1 ! maekawa 1: /* This is a simple C interface to the black-box solver of phc,
! 2: ** written by Nobuki Takayama.
! 3: ** Requirements:
! 4: ** 1) executable version of phc must be on /tmp;
! 5: ** 2) user of this program has write permissions to create
! 6: ** the files "input" and "output" in the directory where
! 7: ** this program is executed.
! 8: */
! 9:
! 10: #include <stdio.h>
! 11: #include <sys/stat.h>
! 12: #include <unistd.h>
! 13:
! 14: /* Definition of class identifiers. */
! 15: #define SstringObject 5
! 16: #define Sarray 6
! 17:
! 18: /* Definition of Object */
! 19: union cell {
! 20: int ival;
! 21: char *str;
! 22: struct object *op;
! 23: };
! 24: struct object{
! 25: int tag; /* class identifier */
! 26: union cell lc; /* left cell */
! 27: union cell rc; /* right cell */
! 28: };
! 29:
! 30: /* Memory allocation function.
! 31: I recommend not to use malloc and to use gc4.14 for large applications. */
! 32: #define sGC_malloc(n) malloc(n)
! 33:
! 34: /********** macros to use Sarray **************/
! 35: /* put to Object Array */
! 36: #define phc_putoa(ob,i,cc) {\
! 37: if ((ob).tag != Sarray) {fprintf(stderr,"Warning: PUTOA is for an array of objects\n");} else \
! 38: {if ((0 <= (i)) && ((i) < (ob).lc.ival)) {\
! 39: (ob.rc.op)[i] = cc;\
! 40: }else{\
! 41: fprintf(stderr,"Warning: PUTOA, the size is %d.\n",(ob).lc.ival);\
! 42: }}}
! 43: #define phc_getoa(ob,i) ((ob.rc.op)[i])
! 44: #define phc_getoaSize(ob) ((ob).lc.ival)
! 45:
! 46:
! 47: /* prototypes */
! 48: struct object phc_newObjectArray(int size);
! 49: void phc_printObject(FILE *fp,struct object ob);
! 50: char *phc_generateUniqueFileName(char *s);
! 51: struct object phc_complexTo(long double r, long double i);
! 52: struct object phc_longdoubleToStringObject(long double r);
! 53:
! 54: int phc_scan_for_string(FILE *fp, char str[], int lenstr);
! 55: struct object phc_scan_solutions(FILE *fp, int npaths, int dim );
! 56: struct object phc_scan_output_of_phc(char *fname);
! 57: struct object phc_call_phc(char *sys);
! 58:
! 59: main() {
! 60: struct object ob;
! 61: ob = phc_call_phc("2\n x**2 + y**2 - 1;\n x**2 + y**2 - 8*x - 3;\n");
! 62: printf("-----------------------------------------------------------\n");
! 63: phc_printObject(stdout,ob);
! 64: printf("\n");
! 65: }
! 66:
! 67: int phc_scan_for_string(FILE *fp, char str[], int lenstr)
! 68: /*
! 69: ** Scans the file fp for a certain string str of length lenstr+1.
! 70: ** Reading stops when the string has been found, then the variable
! 71: ** on return equals 1, otherwise 0 is returned.
! 72: */
! 73: {
! 74: char buf[lenstr+1];
! 75: char ch;
! 76: int index,i,compare,npaths,dim,found;
! 77: index = -1;
! 78: found = 0;
! 79: while ((fscanf(fp,"%c",&ch)!=EOF) && found == 0)
! 80: {
! 81: if (index == -1 && ch == str[0])
! 82: {
! 83: index = 0;
! 84: buf[index] = ch;
! 85: }
! 86: else
! 87: {
! 88: if (index == lenstr)
! 89: {
! 90: compare = 0;
! 91: for (i=0; i<lenstr+1; i++)
! 92: {
! 93: if (buf[i]!=str[i])
! 94: {
! 95: compare = compare+1;
! 96: }
! 97: }
! 98: if (compare == 0)
! 99: {
! 100: found = 1;
! 101: }
! 102: index = -1;
! 103: }
! 104: else
! 105: if (index > -1 && index < lenstr)
! 106: {
! 107: index = index+1;
! 108: buf[index] = ch;
! 109: }
! 110: }
! 111: if (found == 1) break;
! 112: }
! 113: return found;
! 114: }
! 115: struct object phc_scan_solutions(FILE *fp, int npaths, int dim )
! 116: /*
! 117: ** Scans the file for the solutions, from a list of length npaths,
! 118: ** of complex vectors with dim entries.
! 119: ** The tolerance for the residual to a solution is set to 1.0E-12.
! 120: ** Returns the number of solutions.
! 121: */
! 122: {
! 123: struct object rob,sob;
! 124: char ch;
! 125: int fnd,i,j,nsols;
! 126: float res;
! 127: long double realpart;
! 128: long double imagpart;
! 129: long double realparts[npaths][dim];
! 130: long double imagparts[npaths][dim];
! 131: nsols = 0;
! 132: while (fscanf(fp,"%c",&ch)!=EOF)
! 133: {
! 134: fnd = phc_scan_for_string(fp,"start residual :",15);
! 135: if (fnd==1)
! 136: {
! 137: fscanf(fp,"%E",&res);
! 138: /* printf(" residual = "); printf("%E\n",res); */
! 139: if (res < 1.0E-12) nsols = nsols+1;
! 140: fnd = phc_scan_for_string(fp,"the solution for t :",19);
! 141: for (i=0;i<dim;i++)
! 142: {
! 143: fnd = phc_scan_for_string(fp,":",0);
! 144: fscanf(fp,"%LE",&realpart);
! 145: fscanf(fp,"%LE",&imagpart);
! 146: if (res < 1.0E-12)
! 147: {
! 148: realparts[nsols-1][i] = realpart;
! 149: imagparts[nsols-1][i] = imagpart;
! 150: }
! 151: }
! 152: }
! 153: }
! 154: /* fprintf(stderr," number of solutions = %i\n",nsols); */
! 155: rob = phc_newObjectArray(nsols);
! 156: for (i=0;i<nsols;i++)
! 157: {
! 158: /* fprintf(stderr,"Solution %i :\n",i+1); */
! 159: sob = phc_newObjectArray(dim);
! 160: for (j=0;j<dim;j++)
! 161: {
! 162: /*
! 163: printf("%20.14LE",realparts[i][j]); printf(" ");
! 164: printf("%20.14LE",imagparts[i][j]); printf("\n");
! 165: */
! 166: phc_putoa(sob,j,phc_complexTo(realparts[i][j],imagparts[i][j]));
! 167: }
! 168: phc_putoa(rob,i,sob);
! 169: }
! 170: return(rob);
! 171: }
! 172: struct object phc_scan_output_of_phc(char *fname)
! 173: /*
! 174: ** Scans the file "output" of phc in two stages to get
! 175: ** 1) the number of paths and the dimension;
! 176: ** 2) the solutions, vectors with residuals < 1.0E-12.
! 177: */
! 178: {
! 179: FILE *otp;
! 180: char ch;
! 181: int fnd,npaths,dim,i,nsols;
! 182: otp = fopen(fname,"r");
! 183: fprintf(stderr,"Scanning the %s of phc.\n",fname);
! 184: fnd = phc_scan_for_string(otp,"THE SOLUTIONS :",14);
! 185: fscanf(otp,"%i",&npaths);
! 186: fprintf(stderr," number of paths traced = %i\n",npaths);
! 187: fscanf(otp,"%i",&dim);
! 188: fprintf(stderr," dimension of solutions = %i\n",dim);
! 189: return(phc_scan_solutions(otp,npaths,dim));
! 190: }
! 191: struct object phc_call_phc(char *sys) /* call phc, system as string */
! 192: {
! 193: FILE *inp;
! 194: char *f,*outf;
! 195: char cmd[1024];
! 196: f = phc_generateUniqueFileName("tmp.input");
! 197: outf = phc_generateUniqueFileName("tmp.output");
! 198: fprintf(stderr,"Creating file with name %s.\n",f);
! 199: inp = fopen(f,"w");
! 200: fprintf(inp,sys);
! 201: fclose(inp);
! 202: sprintf(cmd,"/tmp/phc -b %s %s",f,outf);
! 203: fprintf(stderr,"Calling %s, black-box solver of phc.\n",cmd);
! 204: system(cmd);
! 205: fprintf(stderr,"See the file %s for results.\n",outf);
! 206: return(phc_scan_output_of_phc(outf));
! 207: }
! 208:
! 209:
! 210: struct object phc_newObjectArray(size)
! 211: int size;
! 212: {
! 213: struct object rob;
! 214: struct object *op;
! 215: if (size > 0) {
! 216: op = (struct object *)sGC_malloc(size*sizeof(struct object));
! 217: if (op == (struct object *)NULL) {fprintf(stderr,"No memory\n");exit(1);}
! 218: }else{
! 219: op = (struct object *)NULL;
! 220: }
! 221: rob.tag = Sarray;
! 222: rob.lc.ival = size;
! 223: rob.rc.op = op;
! 224: return(rob);
! 225: }
! 226:
! 227: void phc_printObject(FILE *fp,struct object ob)
! 228: {
! 229: int n,i;
! 230: if (ob.tag == SstringObject) {
! 231: fprintf(fp,"%s",ob.lc.str);
! 232: }else if (ob.tag == Sarray) {
! 233: n = phc_getoaSize(ob);
! 234: fprintf(fp,"[");
! 235: for (i=0; i<n; i++) {
! 236: phc_printObject(fp,phc_getoa(ob,i));
! 237: if (i <n-1) fprintf(fp,", ");
! 238: }
! 239: fprintf(fp,"]");
! 240: }else{
! 241: fprintf(stderr,"Unknown object tag %d",ob.tag);
! 242: }
! 243: }
! 244:
! 245:
! 246: char *phc_generateUniqueFileName(char *s)
! 247: {
! 248: char *t;
! 249: int i;
! 250: struct stat statbuf;
! 251: t = (char *)sGC_malloc(sizeof(char)*strlen(s)+4+2);
! 252: for (i=0; i<1000; i++) {
! 253: /* Give up if we failed for 1000 names. */
! 254: sprintf(t,"%s.%d",s,i);
! 255: if (stat(t,&statbuf) < 0) {
! 256: return(t);
! 257: }
! 258: }
! 259: fprintf(stderr,"Could not generate a unique file name.");
! 260: return(NULL);
! 261: }
! 262:
! 263: struct object phc_longdoubleToStringObject(long double r)
! 264: {
! 265: struct object rob;
! 266: rob.tag = SstringObject;
! 267: rob.lc.str = (char *) sGC_malloc(sizeof(char)*50); /*??*/
! 268: sprintf(rob.lc.str,"%20.14LE",r);
! 269: return(rob);
! 270: }
! 271:
! 272: struct object phc_complexTo(long double r, long double i)
! 273: {
! 274: struct object rob;
! 275: rob = phc_newObjectArray(2);
! 276: phc_putoa(rob,0,phc_longdoubleToStringObject(r));
! 277: phc_putoa(rob,1,phc_longdoubleToStringObject(i));
! 278: return(rob);
! 279: }
! 280:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to call_phc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / PHC / C