static void splitter_MakeSubSeqName (AjPStr * name_ptr, const AjPSeq seq, ajuint start, ajuint end) { AjPStr value = ajStrNew(); /* create a nice name for the subsequence */ ajStrAssignS(name_ptr, ajSeqGetNameS(seq)); ajStrAppendC(name_ptr, "_"); ajStrFromUint(&value, ajSeqGetBegin(seq)+start); ajStrAppendS(name_ptr, value); ajStrAppendC(name_ptr, "-"); ajStrFromUint(&value, ajSeqGetBegin(seq)+end); ajStrAppendS(name_ptr, value); ajStrDel(&value); }
int main(int argc, char **argv) { AjPSeqall seqall; AjPSeq a; AjPSeqout outf; AjPStr substr; AjPStr back; AjPStr gctable; AjPCod codon = NULL; ajint gctablenum; ajint beg; ajint end; embInit("backtranambig", argc, argv); seqall = ajAcdGetSeqall("sequence"); outf = ajAcdGetSeqoutall("outfile"); gctable = ajAcdGetListSingle("table"); ajStrToInt(gctable, &gctablenum); codon = ajCodNewCodenum(gctablenum); while(ajSeqallNext(seqall, &a)) { substr = ajStrNew(); beg = ajSeqGetBegin(a); end = ajSeqGetEnd(a); ajStrAssignSubC(&substr,ajSeqGetSeqC(a),beg-1,end-1); back = ajStrNew(); ajCodBacktranslateAmbig(&back,substr,codon); ajSeqAssignSeqS (a, back); ajSeqSetNuc(a); ajSeqoutWriteSeq(outf,a); } ajSeqoutClose(outf); ajStrDel(&back); ajStrDel(&substr); ajSeqoutDel(&outf); ajCodDel(&codon); ajStrDel(&gctable); ajSeqallDel(&seqall); ajSeqDel(&a); embExit(); return 0; }
int main(int argc, char **argv) { ajint begin, end; AjPSeqall seqall; AjPSeq seq; EmbPShow ss; AjPFile outfile; AjPStr tablename; ajint table; AjPRange uppercase; AjPRange highlight; AjBool threeletter; AjBool numberseq; AjBool nameseq; ajint width; ajint length; ajint margin; AjBool description; ajint offset; AjBool html; AjPStr descriptionline; ajint orfminsize; AjPTrn trnTable; AjBool translation; AjBool reverse; AjBool cutlist; AjBool flat; EmbPMatMatch mm = NULL; AjPStr *framelist; AjBool frames[6]; /* frames to be translated 1 to 3, -1 to -3 */ /* stuff for tables and lists of enzymes and hits */ ajint default_mincuts = 1; ajint default_maxcuts = 2000000000; AjPTable hittable; /* enzyme hits */ /* stuff lifted from Alan's 'restrict.c' */ AjPStr enzymes = NULL; ajint mincuts; ajint maxcuts; ajint sitelen; AjBool single; AjBool blunt; AjBool sticky; AjBool ambiguity; AjBool plasmid; AjBool commercial; AjBool limit; AjBool methyl; AjPFile enzfile = NULL; AjPFile equfile = NULL; AjPFile methfile = NULL; AjPTable retable = NULL; ajint hits; AjPList restrictlist = NULL; embInit("remap", argc, argv); seqall = ajAcdGetSeqall("sequence"); outfile = ajAcdGetOutfile("outfile"); tablename = ajAcdGetListSingle("table"); uppercase = ajAcdGetRange("uppercase"); highlight = ajAcdGetRange("highlight"); threeletter = ajAcdGetBoolean("threeletter"); numberseq = ajAcdGetBoolean("number"); width = ajAcdGetInt("width"); length = ajAcdGetInt("length"); margin = ajAcdGetInt("margin"); nameseq = ajAcdGetBoolean("name"); description = ajAcdGetBoolean("description"); offset = ajAcdGetInt("offset"); html = ajAcdGetBoolean("html"); orfminsize = ajAcdGetInt("orfminsize"); translation = ajAcdGetBoolean("translation"); reverse = ajAcdGetBoolean("reverse"); cutlist = ajAcdGetBoolean("cutlist"); flat = ajAcdGetBoolean("flatreformat"); framelist = ajAcdGetList("frame"); /* restriction enzyme stuff */ mincuts = ajAcdGetInt("mincuts"); maxcuts = ajAcdGetInt("maxcuts"); sitelen = ajAcdGetInt("sitelen"); single = ajAcdGetBoolean("single"); blunt = ajAcdGetBoolean("blunt"); sticky = ajAcdGetBoolean("sticky"); ambiguity = ajAcdGetBoolean("ambiguity"); plasmid = ajAcdGetBoolean("plasmid"); commercial = ajAcdGetBoolean("commercial"); limit = ajAcdGetBoolean("limit"); enzymes = ajAcdGetString("enzymes"); methfile = ajAcdGetDatafile("mfile"); methyl = ajAcdGetBoolean("methylation"); if(!blunt && !sticky) ajFatal("Blunt/Sticky end cutters shouldn't both be disabled."); /* get the number of the genetic code used */ ajStrToInt(tablename, &table); trnTable = ajTrnNewI(table); /* read the local file of enzymes names */ remap_read_file_of_enzyme_names(&enzymes); /* get the frames to be translated */ remap_GetFrames(framelist, frames); while(ajSeqallNext(seqall, &seq)) { /* get begin and end positions */ begin = ajSeqGetBegin(seq)-1; end = ajSeqGetEnd(seq)-1; /* do the name and description */ if(nameseq) { if(html) ajFmtPrintF(outfile, "<H2>%S</H2>\n", ajSeqGetNameS(seq)); else ajFmtPrintF(outfile, "%S\n", ajSeqGetNameS(seq)); } if(description) { /* ** wrap the description line at the width of the sequence ** plus margin */ if(html) ajFmtPrintF(outfile, "<H3>%S</H3>\n", ajSeqGetDescS(seq)); else { descriptionline = ajStrNew(); ajStrAssignS(&descriptionline, ajSeqGetDescS(seq)); ajStrFmtWrap(&descriptionline, width+margin); ajFmtPrintF(outfile, "%S\n", descriptionline); ajStrDel(&descriptionline); } } /* get the restriction cut sites */ /* ** most of this is lifted from the program 'restrict.c' by Alan ** Bleasby */ if(single) maxcuts=mincuts=1; retable = ajTablestrNew(EQUGUESS); enzfile = ajDatafileNewInNameC(ENZDATA); if(!enzfile) ajFatal("Cannot locate enzyme file. Run REBASEEXTRACT"); if(limit) { equfile = ajDatafileNewInNameC(EQUDATA); if(!equfile) limit = ajFalse; else remap_read_equiv(&equfile, &retable, commercial); } ajFileSeek(enzfile, 0L, 0); restrictlist = ajListNew(); /* search for hits, but don't use mincuts and maxcuts criteria yet */ hits = embPatRestrictMatch(seq, begin+1, end+1, enzfile, methfile, enzymes, sitelen,plasmid, ambiguity, default_mincuts, default_maxcuts, blunt, sticky, commercial, methyl, restrictlist); ajDebug("Remap found %d hits\n", hits); if(hits) { /* this bit is lifted from printHits */ embPatRestrictRestrict(restrictlist, hits, !limit, ajFalse); if(limit) remap_RestrictPreferred(restrictlist,retable); } ajFileClose(&enzfile); ajFileClose(&methfile); /* ** Remove those violating the mincuts and maxcuts ** criteria, but save them in hittable for printing out later. ** Keep a count of how many hits each enzyme gets in hittable. */ hittable = ajTablestrNewCase(TABLEGUESS); remap_RemoveMinMax(restrictlist, hittable, mincuts, maxcuts); /* make the Show Object */ ss = embShowNew(seq, begin, end, width, length, margin, html, offset); if(html) ajFmtPrintF(outfile, "<PRE>"); /* create the format to display */ embShowAddBlank(ss); embShowAddRE(ss, 1, restrictlist, plasmid, flat); embShowAddSeq(ss, numberseq, threeletter, uppercase, highlight); if(!numberseq) embShowAddTicknum(ss); embShowAddTicks(ss); if(reverse) { embShowAddComp(ss, numberseq); embShowAddRE(ss, -1, restrictlist, plasmid, flat); } if(translation) { if(reverse) embShowAddBlank(ss); if(frames[0]) embShowAddTran(ss, trnTable, 1, threeletter, numberseq, NULL, orfminsize, AJFALSE, AJFALSE, AJFALSE, AJFALSE); if(frames[1]) embShowAddTran(ss, trnTable, 2, threeletter, numberseq, NULL, orfminsize, AJFALSE, AJFALSE, AJFALSE, AJFALSE); if(frames[2]) embShowAddTran(ss, trnTable, 3, threeletter, numberseq, NULL, orfminsize, AJFALSE, AJFALSE, AJFALSE, AJFALSE); if(reverse) { embShowAddTicks(ss); if(frames[5]) embShowAddTran(ss, trnTable, -3, threeletter, numberseq, NULL, orfminsize, AJFALSE, AJFALSE, AJFALSE, AJFALSE); if(frames[4]) embShowAddTran(ss, trnTable, -2, threeletter, numberseq, NULL, orfminsize, AJFALSE, AJFALSE, AJFALSE, AJFALSE); if(frames[3]) embShowAddTran(ss, trnTable, -1, threeletter, numberseq, NULL, orfminsize, AJFALSE, AJFALSE, AJFALSE, AJFALSE); } } embShowPrint(outfile, ss); /* display a list of the Enzymes that cut and don't cut */ if(cutlist) { remap_CutList(outfile, hittable, limit, html, mincuts, maxcuts); remap_NoCutList(outfile, hittable, html, enzymes, blunt, sticky, sitelen, commercial, ambiguity, limit, retable); } /* add a gratuitous newline at the end of the sequence */ ajFmtPrintF(outfile, "\n"); /* tidy up */ embShowDel(&ss); while(ajListPop(restrictlist,(void **)&mm)) embMatMatchDel(&mm); ajListFree(&restrictlist); remap_DelTable(&hittable); ajTablestrFree(&retable); } ajTrnDel(&trnTable); ajSeqallDel(&seqall); ajSeqDel(&seq); ajFileClose(&outfile); ajStrDel(&tablename); ajStrDel(&enzymes); ajStrDelarray(&framelist); ajRangeDel(&uppercase); ajRangeDel(&highlight); embExit(); return 0; }
int main(int argc, char **argv) { AjPSeq seq; AjPGraph graph = 0; AjPFile outf = NULL; AjPFile file = NULL; AjPStr buffer = NULL; float twist[4][4][4]; float roll[4][4][4]; float tilt[4][4][4]; float rbend; float rcurve; float bendscale; float curvescale; float twistsum = (float) 0.0; float pi = (float) 3.14159; float pifac = (pi/(float) 180.0); float pi2 = pi/(float) 2.0; ajint *iseq = NULL; float *x; float *y; float *xave; float *yave; float *curve; float *bend; const char *ptr; ajint i; ajint ii; ajint k; ajint j; char residue[2]; float maxbend; float minbend; float bendfactor; float maxcurve; float mincurve; float curvefactor; float fxp; float fyp; float yincr; float yy1; ajint ixlen; ajint iylen; ajint ixoff; ajint iyoff; float ystart; float defheight; float currentheight; ajint count; ajint portrait = 0; ajint title = 0; ajint numres; ajint ibeg; ajint iend; ajint ilen; AjPStr sstr = NULL; ajint ipos; float dx; float dy; float rxsum; float rysum; float yp1; float yp2; double td; embInit("banana", argc, argv); seq = ajAcdGetSeq("sequence"); file = ajAcdGetDatafile("anglesfile"); outf = ajAcdGetOutfile("outfile"); graph = ajAcdGetGraph("graph"); numres = ajAcdGetInt("residuesperline"); ibeg = ajSeqGetBegin(seq); iend = ajSeqGetEnd(seq); ajStrAssignSubS(&sstr, ajSeqGetSeqS(seq), ibeg-1, iend-1); ilen = ajStrGetLen(sstr); AJCNEW0(iseq,ilen+1); AJCNEW0(x,ilen+1); AJCNEW0(y,ilen+1); AJCNEW0(xave,ilen+1); AJCNEW0(yave,ilen+1); AJCNEW0(curve,ilen+1); AJCNEW0(bend,ilen+1); ptr= ajStrGetPtr(sstr); for(ii=0;ii<ilen;ii++) { if(*ptr=='A' || *ptr=='a') iseq[ii+1] = 0; else if(*ptr=='T' || *ptr=='t') iseq[ii+1] = 1; else if(*ptr=='G' || *ptr=='g') iseq[ii+1] = 2; else if(*ptr=='C' || *ptr=='c') iseq[ii+1] = 3; else ajErr("%c is not an ATCG hence not valid",*ptr); ptr++; } if(!file) ajErr("Banana failed to open angle file"); ajReadline(file,&buffer); /* 3 junk lines */ ajReadline(file,&buffer); ajReadline(file,&buffer); for(k=0;k<4;k++) for(ii=0;ii<4;ii++) { if(ajReadline(file,&buffer)) { sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f", &twist[ii][0][k],&twist[ii][1][k],&twist[ii][2][k], &twist[ii][3][k]); } else ajErr("Error reading angle file"); for(j=0;j<4;j++) twist[ii][j][k] *= pifac; } for(k=0;k<4;k++) for(ii=0;ii<4;ii++) if(ajReadline(file,&buffer)) { sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",&roll[ii][0][k], &roll[ii][1][k],&roll[ii][2][k],&roll[ii][3][k]); } else ajErr("Error reading angle file"); for(k=0;k<4;k++) for(ii=0;ii<4;ii++) if(ajReadline(file,&buffer)) sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",&tilt[ii][0][k], &tilt[ii][1][k],&tilt[ii][2][k],&tilt[ii][3][k]); else ajErr("Error reading angle file"); if(ajReadline(file,&buffer)) sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",&rbend,&rcurve, &bendscale,&curvescale); else ajErr("Error reading angle file"); ajFileClose(&file); ajStrDel(&buffer); for(ii=1;ii<ilen-1;ii++) { twistsum += twist[iseq[ii]][iseq[ii+1]][iseq[ii+2]]; dx = (roll[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*sinfban(twistsum)) + (tilt[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*sinfban(twistsum-pi2)); dy = roll[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*cosfban(twistsum) + tilt[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*cosfban(twistsum-pi2); x[ii+1] = x[ii]+dx; y[ii+1] = y[ii]+dy; } for(ii=6;ii<ilen-6;ii++) { rxsum = 0.0; rysum = 0.0; for(k=-4;k<=4;k++) { rxsum+=x[ii+k]; rysum+=y[ii+k]; } rxsum+=(x[ii+5]*(float)0.5); rysum+=(y[ii+5]*(float)0.5); rxsum+=(x[ii-5]*(float)0.5); rysum+=(y[ii-5]*(float)0.5); xave[ii] = rxsum*(float)0.1; yave[ii] = rysum*(float)0.1; } for(i=(ajint)rbend+1;i<=ilen-(ajint)rbend-1;i++) { td = sqrt(((x[i+(ajint)rbend]-x[i-(ajint)rbend])* (x[i+(ajint)rbend]-x[i-(ajint)rbend])) + ((y[i+(ajint)rbend]-y[i-(ajint)rbend])* (y[i+(ajint)rbend]-y[i-(ajint)rbend]))); bend[i] = (float) td; bend[i]*=bendscale; } for(i=(ajint)rcurve+6;i<=ilen-(ajint)rcurve-6;i++) { td = sqrt(((xave[i+(ajint)rcurve]- xave[i-(ajint)rcurve])*(xave[i+(ajint)rcurve]- xave[i-(ajint)rcurve]))+ ((yave[i+(ajint)rcurve]-yave[i-(ajint)rcurve])* (yave[i+(ajint)rcurve]-yave[i-(ajint)rcurve]))); curve[i] = (float) td; } if(outf) { ajFmtPrintF(outf,"Base Bend Curve\n"); ptr = ajStrGetPtr(sstr); for(ii=1;ii<=ilen;ii++) { ajFmtPrintF(outf,"%c %6.1f %6.1f\n", *ptr, bend[ii], curve[ii]); ptr++; } ajFileClose(&outf); } if(graph) { maxbend = minbend = 0.0; maxcurve = mincurve = 0.0; for(ii=1;ii<=ilen;ii++) { if(bend[ii] > maxbend) maxbend = bend[ii]; if(bend[ii] < minbend) minbend = bend[ii]; if(curve[ii] > maxcurve) maxcurve = curve[ii]; if(curve[ii] < mincurve) mincurve = curve[ii]; } ystart = 75.0; ajGraphAppendTitleS(graph, ajSeqGetUsaS(seq)); ajGraphicsSetPagesize(960, 768); ajGraphOpenWin(graph,(float)-1.0, (float)numres+(float)10.0, (float)0.0, ystart+(float)5.0); ajGraphicsGetParamsPage(&fxp,&fyp,&ixlen,&iylen,&ixoff,&iyoff); if(portrait) { ixlen = 768; iylen = 960; } else { ixlen = 960; iylen = 768; } ajGraphicsGetCharsize(&defheight,¤theight); if(!currentheight) { defheight = currentheight = (float) 4.440072; currentheight = defheight * ((float)ixlen/ ((float)(numres)*(currentheight+(float)1.0))) /currentheight; } ajGraphicsSetCharscale(((float)ixlen/((float)(numres)* (currentheight+(float)1.0)))/ currentheight); ajGraphicsGetCharsize(&defheight,¤theight); yincr = (currentheight + (float)3.0)*(float)0.3; if(!title) yy1 = ystart; else yy1 = ystart-(float)5.0; count = 1; residue[1]='\0'; bendfactor = (3*yincr)/maxbend; curvefactor = (3*yincr)/maxcurve; ptr = ajStrGetPtr(sstr); yy1 = yy1-(yincr*((float)5.0)); for(ii=1;ii<=ilen;ii++) { if(count > numres) { yy1 = yy1-(yincr*((float)5.0)); if(yy1<1.0) { if(!title) yy1=ystart; else yy1 = ystart-(float)5.0; yy1 = yy1-(yincr*((float)5.0)); ajGraphNewpage(graph,AJFALSE); } count = 1; } residue[0] = *ptr; ajGraphicsDrawposTextAtend((float)(count)+(float)2.0,yy1,residue); if(ii>1 && ii < ilen) { yp1 = yy1+yincr + (bend[ii]*bendfactor); yp2 = yy1+yincr + (bend[ii+1]*bendfactor); ajGraphicsDrawposLine((float)count+(float)1.5,yp1, (float)(count)+(float)2.5,yp2); } ipos = ilen-(ajint)rcurve-7; if(ipos < 0) ipos = 0; if(ii>rcurve+5 && ii<ipos) { yp1 = yy1+yincr + (curve[ii]*curvefactor); yp2 = yy1+yincr + (curve[ii+1]*curvefactor); ajGraphicsDrawposLine((float)count+(float)1.7,yp1, (float)(count)+(float)2.3,yp2); } ajGraphicsDrawposLine((float)count+(float)1.5,yy1+yincr, (float)(count)+(float)2.5,yy1+yincr); count++; ptr++; } ajGraphicsClose(); } AJFREE(iseq); AJFREE(x); AJFREE(y); AJFREE(xave); AJFREE(yave); AJFREE(curve); AJFREE(bend); ajStrDel(&sstr); ajSeqDel(&seq); ajFileClose(&file); ajFileClose(&outf); ajGraphxyDel(&graph); embExit(); return 0; }
int main(int argc, char **argv) { AjPList list = NULL; AjPSeq seq; AjPSeq seq2; AjPStr aa0str = 0; AjPStr aa1str = 0; const char *s1; const char *s2; char *strret = NULL; ajuint i; ajuint j; ajuint k; ajint l; ajint abovethresh; ajint total; ajint starti = 0; ajint startj = 0; ajint windowsize; float thresh; AjPGraph graph = NULL; AjPGraph xygraph = NULL; float flen1; float flen2; ajuint len1; ajuint len2; AjPTime ajtime = NULL; time_t tim; AjBool boxit=AJTRUE; /* Different ticks as they need to be different for x and y due to length of string being important on x */ ajuint acceptableticksx[]= { 1,10,50,100,500,1000,1500,10000, 500000,1000000,5000000 }; ajuint acceptableticks[]= { 1,10,50,100,200,500,1000,2000,5000,10000,15000, 500000,1000000,5000000 }; ajint numbofticks = 10; float xmargin; float ymargin; float ticklen; float tickgap; float onefifth; float k2; float max; char ptr[10]; AjPMatrix matrix = NULL; ajint** sub; AjPSeqCvt cvt; AjPStr subt = NULL; ajint b1; ajint b2; ajint e1; ajint e2; AjPStr se1; AjPStr se2; ajint ithresh; AjBool stretch; PPoint ppt = NULL; float xa[1]; float ya[1]; AjPGraphdata gdata=NULL; AjPStr tit = NULL; AjIList iter = NULL; float x1 = 0.; float x2 = 0.; float y1 = 0.; float y2 = 0.; ajuint tui; se1 = ajStrNew(); se2 = ajStrNew(); embInit("dotmatcher", argc, argv); seq = ajAcdGetSeq("asequence"); seq2 = ajAcdGetSeq("bsequence"); stretch = ajAcdGetToggle("stretch"); graph = ajAcdGetGraph("graph"); xygraph = ajAcdGetGraphxy("xygraph"); windowsize = ajAcdGetInt("windowsize"); ithresh = ajAcdGetInt("threshold"); matrix = ajAcdGetMatrix("matrixfile"); sub = ajMatrixGetMatrix(matrix); cvt = ajMatrixGetCvt(matrix); thresh = (float)ithresh; ajtime = ajTimeNew(); tim = time(0); ajTimeSetLocal(ajtime, tim); b1 = ajSeqGetBegin(seq); b2 = ajSeqGetBegin(seq2); e1 = ajSeqGetEnd(seq); e2 = ajSeqGetEnd(seq2); len1 = ajSeqGetLen(seq); len2 = ajSeqGetLen(seq2); tui = ajSeqGetLen(seq); flen1 = (float) tui; tui = ajSeqGetLen(seq2); flen2 = (float) tui; ajStrAssignSubC(&se1,ajSeqGetSeqC(seq),b1-1,e1-1); ajStrAssignSubC(&se2,ajSeqGetSeqC(seq2),b2-1,e2-1); ajSeqAssignSeqS(seq,se1); ajSeqAssignSeqS(seq2,se2); s1 = ajStrGetPtr(ajSeqGetSeqS(seq)); s2 = ajStrGetPtr(ajSeqGetSeqS(seq2)); aa0str = ajStrNewRes(1+len1); /* length plus trailing blank */ aa1str = ajStrNewRes(1+len2); list = ajListNew(); for(i=0;i<len1;i++) ajStrAppendK(&aa0str,(char)ajSeqcvtGetCodeK(cvt, *s1++)); for(i=0;i<len2;i++) ajStrAppendK(&aa1str,(char)ajSeqcvtGetCodeK(cvt, *s2++)); max = (float)len1; if(len2 > max) max = (float) len2; xmargin = ymargin = max *(float)0.15; ticklen = xmargin*(float)0.1; onefifth = xmargin*(float)0.2; subt = ajStrNewC((strret= ajFmtString("(windowsize = %d, threshold = %3.2f %D)", windowsize,thresh,ajtime))); if(!stretch) { if( ajStrGetLen(ajGraphGetSubtitleS(graph)) <=1) ajGraphSetSubtitleS(graph,subt); ajGraphOpenWin(graph, (float)0.0-ymargin,(max*(float)1.35)+ymargin, (float)0.0-xmargin,(float)max+xmargin); ajGraphicsDrawposTextAtmid(flen1*(float)0.5, (float)0.0-(xmargin/(float)2.0), ajGraphGetXlabelC(graph)); ajGraphicsDrawposTextAtlineJustify((float)0.0-(xmargin*(float)0.75), flen2*(float)0.5, (float)0.0-(xmargin*(float)0.75),flen1, ajGraphGetYlabelC(graph),0.5); ajGraphicsSetCharscale(0.5); } s1= ajStrGetPtr(aa0str); s2 = ajStrGetPtr(aa1str); for(j=0; (ajint)j < (ajint)len2-windowsize;j++) { i =0; total = 0; abovethresh =0; k = j; for(l=0;l<windowsize;l++) total = total + sub[(ajint)s1[i++]][(ajint)s2[k++]]; if(total >= thresh) { abovethresh=1; starti = i-windowsize; startj = k-windowsize; } while(i < len1 && k < len2) { total = total - sub[(ajint)s1[i-windowsize]] [(ajint)s2[k-windowsize]]; total = total + sub[(ajint)s1[i]][(ajint)s2[k]]; if(abovethresh) { if(total < thresh) { abovethresh = 0; /* draw the line */ dotmatcher_pushpoint(&list,(float)starti,(float)startj, (float)i-1,(float)k-1,stretch); } } else if(total >= thresh) { starti = i-windowsize; startj = k-windowsize; abovethresh= 1; } i++; k++; } if(abovethresh) /* draw the line */ dotmatcher_pushpoint(&list,(float)starti,(float)startj, (float)i-1,(float)k-1, stretch); } for(i=0; (ajint)i < (ajint)len1-windowsize;i++) { j = 0; total = 0; abovethresh =0; k = i; for(l=0;l<windowsize;l++) total = total + sub[(ajint)s1[k++]][(ajint)s2[j++]]; if(total >= thresh) { abovethresh=1; starti = k-windowsize; startj = j-windowsize; } while(k < len1 && j < len2) { total = total - sub[(ajint)s1[k-windowsize]] [(ajint)s2[j-windowsize]]; total = total + sub[(ajint)s1[k]][(ajint)s2[j]]; if(abovethresh) { if(total < thresh) { abovethresh = 0; /* draw the line */ dotmatcher_pushpoint(&list,(float)starti,(float)startj, (float)k-1,(float)j-1,stretch); } } else if(total >= thresh) { starti = k-windowsize; startj = j-windowsize; abovethresh= 1; } j++; k++; } if(abovethresh) /* draw the line */ dotmatcher_pushpoint(&list,(float)starti,(float)startj, (float)k-1,(float)j-1, stretch); } if(boxit && !stretch) { ajGraphicsDrawposRect(0.0,0.0,flen1, flen2); i=0; while(acceptableticksx[i]*numbofticks < len1) i++; if(i<=13) tickgap = (float)acceptableticksx[i]; else tickgap = (float)acceptableticksx[10]; ticklen = xmargin*(float)0.1; onefifth = xmargin*(float)0.2; if(len2/len1 > 10 ) { /* if a lot smaller then just label start and end */ ajGraphicsDrawposLine((float)0.0,(float)0.0,(float)0.0,(float)0.0-ticklen); sprintf(ptr,"%d",b1-1); ajGraphicsDrawposTextAtmid((float)0.0,(float)0.0-(onefifth),ptr); ajGraphicsDrawposLine(flen1,(float)0.0, flen1,(float)0.0-ticklen); sprintf(ptr,"%d",len1+b1-1); ajGraphicsDrawposTextAtmid(flen1,(float)0.0-(onefifth),ptr); } else for(k2=0.0;k2<len1;k2+=tickgap) { ajGraphicsDrawposLine(k2,(float)0.0,k2,(float)0.0-ticklen); sprintf(ptr,"%d",(ajint)k2+b1-1); ajGraphicsDrawposTextAtmid(k2,(float)0.0-(onefifth),ptr); } i = 0; while(acceptableticks[i]*numbofticks < len2) i++; tickgap = (float)acceptableticks[i]; ticklen = ymargin*(float)0.01; onefifth = ymargin*(float)0.02; if(len1/len2 > 10 ) { /* if a lot smaller then just label start and end */ ajGraphicsDrawposLine((float)0.0,(float)0.0,(float)0.0-ticklen,(float)0.0); sprintf(ptr,"%d",b2-1); ajGraphicsDrawposTextAtend((float)0.0-(onefifth),(float)0.0,ptr); ajGraphicsDrawposLine((float)0.0,flen2,(float)0.0-ticklen, flen2); sprintf(ptr,"%d",len2+b2-1); ajGraphicsDrawposTextAtend((float)0.0-(onefifth),flen2,ptr); } else for(k2=0.0;k2<len2;k2+=tickgap) { ajGraphicsDrawposLine((float)0.0,k2,(float)0.0-ticklen,k2); sprintf(ptr,"%d",(ajint)k2+b2-1); ajGraphicsDrawposTextAtend((float)0.0-(onefifth),k2,ptr); } } if(!stretch) ajGraphicsClose(); else /* the xy graph for -stretch */ { tit = ajStrNew(); ajFmtPrintS(&tit,"%S",ajGraphGetTitleS(xygraph)); gdata = ajGraphdataNewI(1); xa[0] = (float)b1; ya[0] = (float)b2; ajGraphSetTitleC(xygraph,ajStrGetPtr(tit)); ajGraphSetXlabelC(xygraph,ajSeqGetNameC(seq)); ajGraphSetYlabelC(xygraph,ajSeqGetNameC(seq2)); ajGraphdataSetTypeC(gdata,"2D Plot Float"); ajGraphdataSetTitleS(gdata,subt); ajGraphdataSetMinmax(gdata,(float)b1,(float)e1,(float)b2, (float)e2); ajGraphdataSetTruescale(gdata,(float)b1,(float)e1,(float)b2, (float)e2); ajGraphxySetXstartF(xygraph,(float)b1); ajGraphxySetXendF(xygraph,(float)e1); ajGraphxySetYstartF(xygraph,(float)b2); ajGraphxySetYendF(xygraph,(float)e2); ajGraphxySetXrangeII(xygraph,b1,e1); ajGraphxySetYrangeII(xygraph,b2,e2); if(list) { iter = ajListIterNewread(list); while((ppt = ajListIterGet(iter))) { x1 = ppt->x1+b1-1; y1 = ppt->y1+b2-1; x2 = ppt->x2+b1-1; y2 = ppt->y2+b2-1; ajGraphAddLine(xygraph,x1,y1,x2,y2,0); AJFREE(ppt); } ajListIterDel(&iter); } ajGraphdataAddXY(gdata,xa,ya); ajGraphDataReplace(xygraph,gdata); ajGraphxyDisplay(xygraph,ajFalse); ajGraphicsClose(); ajStrDel(&tit); } ajListFree(&list); ajSeqDel(&seq); ajSeqDel(&seq2); ajGraphxyDel(&graph); ajGraphxyDel(&xygraph); ajMatrixDel(&matrix); ajTimeDel(&ajtime); /* deallocate memory */ ajStrDel(&aa0str); ajStrDel(&aa1str); ajStrDel(&se1); ajStrDel(&se2); ajStrDel(&subt); AJFREE(strret); /* created withing ajFmtString */ embExit(); return 0; }
int main(int argc, char **argv) { AjPAlign align; AjPSeq a; AjPSeq b; AjPSeqout seqout; AjPStr m; AjPStr n; AjPStr merged = NULL; ajuint lena; ajuint lenb; const char *p; const char *q; ajint start1 = 0; ajint start2 = 0; float *path; ajint *compass; AjPMatrixf matrix; AjPSeqCvt cvt = 0; float **sub; float gapopen; float gapextend; ajulong maxarr = 1000; ajulong len; /* arbitrary. realloc'd if needed */ size_t stlen; float score; ajint begina; ajint beginb; embInit("merger", argc, argv); a = ajAcdGetSeq("asequence"); b = ajAcdGetSeq("bsequence"); seqout = ajAcdGetSeqout("outseq"); matrix = ajAcdGetMatrixf("datafile"); gapopen = ajAcdGetFloat("gapopen"); gapextend = ajAcdGetFloat("gapextend"); align = ajAcdGetAlign("outfile"); gapopen = ajRoundFloat(gapopen, 8); gapextend = ajRoundFloat(gapextend, 8); AJCNEW(path, maxarr); AJCNEW(compass, maxarr); /* ** make the two sequences lowercase so we can show which one we are ** using in the merge by uppercasing it */ ajSeqFmtLower(a); ajSeqFmtLower(b); m = ajStrNew(); n = ajStrNew(); sub = ajMatrixfGetMatrix(matrix); cvt = ajMatrixfGetCvt(matrix); begina = ajSeqGetBegin(a); beginb = ajSeqGetBegin(b); lena = ajSeqGetLen(a); lenb = ajSeqGetLen(b); if(lenb > (ULONG_MAX/(ajulong)(lena+1))) ajFatal("Sequences too big. Try 'supermatcher'"); len = lena*lenb; if(len>maxarr) { ajDebug("merger: resize path, len to %d (%d * $d)\n", len, lena, lenb); stlen = (size_t) len; AJCRESIZE(path,stlen); AJCRESIZE(compass,stlen); maxarr=len; } p = ajSeqGetSeqC(a); q = ajSeqGetSeqC(b); ajStrAssignC(&m,""); ajStrAssignC(&n,""); score = embAlignPathCalc(p,q,lena,lenb,gapopen,gapextend,path,sub,cvt, compass, ajFalse); /*score = embAlignScoreNWMatrix(path,compass,gapopen,gapextend, a,b,lena,lenb,sub,cvt, &start1,&start2);*/ embAlignWalkNWMatrix(path,a,b,&m,&n,lena,lenb, &start1,&start2,gapopen, gapextend,compass); /* ** now construct the merged sequence, uppercase the bits of the two ** input sequences which are used in the merger */ merger_Merge(align, &merged,p,q,m,n,start1,start2, ajSeqGetNameC(a),ajSeqGetNameC(b)); embAlignReportGlobal(align, a, b, m, n, start1, start2, gapopen, gapextend, score, matrix, begina, beginb); ajAlignWrite(align); ajAlignReset(align); /* write the merged sequence */ ajSeqAssignSeqS(a, merged); ajSeqoutWriteSeq(seqout, a); ajSeqoutClose(seqout); ajSeqoutDel(&seqout); ajSeqDel(&a); ajSeqDel(&b); ajAlignClose(align); ajAlignDel(&align); ajStrDel(&merged); AJFREE(compass); AJFREE(path); ajStrDel(&n); ajStrDel(&m); embExit(); return 0; }
int main(int argc, char **argv) { AjPSeq seq1; AjPSeq seq2; ajint wordlen; AjPTable seq1MatchTable = 0; AjPList matchlist = NULL; AjPGraph graph = NULL; AjPGraph xygraph = NULL; AjBool boxit; /* ** Different ticks as they need to be different for x and y due to ** length of string being important on x */ ajuint acceptableticksx[]= { 1,10,50,100,500,1000,1500,10000, 500000,1000000,5000000 }; ajuint acceptableticks[]= { 1,10,50,100,200,500,1000,2000,5000,10000,15000, 500000,1000000,5000000 }; ajint numbofticks = 10; float xmargin; float ymargin; float ticklen; float tickgap; float onefifth = 0.0; ajint i; float k; float max; char ptr[10]; ajint begin1; ajint begin2; ajint end1; ajint end2; ajuint len1; ajuint len2; float fbegin1; float fbegin2; float fend1; float fend2; float flen1; float flen2; AjBool stretch; embInit("dottup", argc, argv); wordlen = ajAcdGetInt("wordsize"); seq1 = ajAcdGetSeq("asequence"); seq2 = ajAcdGetSeq("bsequence"); graph = ajAcdGetGraph("graph"); boxit = ajAcdGetBoolean("boxit"); stretch = ajAcdGetToggle("stretch"); xygraph = ajAcdGetGraphxy("xygraph"); begin1 = ajSeqGetBegin(seq1); begin2 = ajSeqGetBegin(seq2); end1 = ajSeqGetEnd(seq1); end2 = ajSeqGetEnd(seq2); len1 = end1 - begin1 + 1; len2 = end2 - begin2 + 1; flen1 = (float) len1; flen2 = (float) len2; fbegin1 = (float) begin1; fbegin2 = (float) begin2; fend1 = (float) end1; fend2 = (float) end2; offset1 = fbegin1; offset2 = fbegin2; ajSeqTrim(seq1); ajSeqTrim(seq2); embWordLength(wordlen); if(embWordGetTable(&seq1MatchTable, seq1)) matchlist = embWordBuildMatchTable(seq1MatchTable, seq2, ajTrue); if(stretch) { dottup_stretchplot(xygraph,matchlist,seq1,seq2,begin1,begin2,end1, end2); if(matchlist) embWordMatchListDelete(&matchlist); /* free the match structures */ } else { /* only here if stretch is false */ max= flen1; if(flen2 > max) max = flen2; xmargin = ymargin = max * (float)0.15; ajGraphOpenWin(graph, fbegin1-ymargin,fend1+ymargin, fbegin2-xmargin,(float)fend2+xmargin); ajGraphicsSetCharscale(0.5); if(matchlist) dottup_plotMatches(matchlist); if(boxit) { ajGraphicsDrawposRect(fbegin1, fbegin2, fend1, fend2); i = 0; while(acceptableticksx[i]*numbofticks < len1) i++; if(i<=13) tickgap = (float) acceptableticksx[i]; else tickgap = (float) acceptableticksx[10]; ticklen = xmargin * (float) 0.1; onefifth = xmargin * (float)0.2; ajGraphicsDrawposTextAtmid(fbegin1+flen1*(float)0.5, fbegin1-(onefifth*(float)3.0), ajGraphGetYlabelC(graph)); if(len2/len1 > 10 ) { /* a lot smaller then just label start and end */ ajGraphicsDrawposLine(fbegin1,fbegin2,fbegin1, fbegin2-ticklen); sprintf(ptr,"%u",ajSeqGetOffset(seq1)); ajGraphicsDrawposTextAtmid(fbegin1,fbegin2-(onefifth),ptr); ajGraphicsDrawposLine(fend1,fbegin2, fend1,fbegin2-ticklen); sprintf(ptr,"%d",end1); ajGraphicsDrawposTextAtmid(fend1,fbegin2-(onefifth),ptr); } else for(k=fbegin1;k<fend1;k+=tickgap) { ajGraphicsDrawposLine(k,fbegin2,k,fbegin2-ticklen); sprintf(ptr,"%d",(ajint)k); ajGraphicsDrawposTextAtmid( k,fbegin2-(onefifth),ptr); } i = 0; while(acceptableticks[i]*numbofticks < len2) i++; tickgap = (float) acceptableticks[i]; ticklen = ymargin*(float)0.1; onefifth = ymargin*(float)0.2; ajGraphicsDrawposTextAtlineJustify(fbegin1-(onefifth*(float)4.), fbegin2+flen2*(float)0.5, fbegin2-(onefifth*(float)4.), fbegin2+flen2, ajGraphGetXlabelC(graph), 0.5); if(len1/len2 > 10 ) { /* a lot smaller then just label start and end */ ajGraphicsDrawposLine(fbegin1,fbegin2,fbegin1-ticklen, fbegin2); sprintf(ptr,"%u",ajSeqGetOffset(seq2)); ajGraphicsDrawposTextAtend(fbegin1-(onefifth),fbegin2,ptr); ajGraphicsDrawposLine(fbegin1,fend2,fbegin1-ticklen, fend2); sprintf(ptr,"%d",end2); ajGraphicsDrawposTextAtend(fbegin2-(onefifth),fend2,ptr); } else for(k=fbegin2;k<fend2;k+=tickgap) { ajGraphicsDrawposLine(fbegin1,k,fbegin1-ticklen,k); sprintf(ptr,"%d",(ajint)k); ajGraphicsDrawposTextAtend(fbegin1-(onefifth),k,ptr); } } } ajGraphicsClose(); ajSeqDel(&seq1); ajSeqDel(&seq2); ajGraphxyDel(&graph); ajGraphxyDel(&xygraph); embWordFreeTable(&seq1MatchTable); if(matchlist) embWordMatchListDelete(&matchlist); /* free the match structures */ embExit(); return 0; }
int main(int argc, char **argv) { AjPSeq seq = NULL; AjPFile angles = NULL; AjPFile energies = NULL; AjPFile result = NULL; AjPTable angletable = NULL; AjPTable energytable = NULL; AjPStr nucs = NULL; const AjPStr valstr = NULL; const char * dinuc = NULL; ajint len; ajint begin; ajint end; ajint i; float val; float anglesum = 0.0; float energysum = 0.0; float twists = 0.0; float basesperturn = 0.0; float energyperbase = 0.0; embInit ("btwisted", argc, argv); seq = ajAcdGetSeq ("sequence"); angles = ajAcdGetDatafile("angledata"); energies = ajAcdGetDatafile("energydata"); result = ajAcdGetOutfile ("outfile"); nucs = ajStrNew(); angletable = btwisted_getdinucdata(angles); energytable = btwisted_getdinucdata(energies); ajFileClose(&angles); ajFileClose(&energies); begin = ajSeqGetBegin(seq); end = ajSeqGetEnd(seq); len = end-begin+1; dinuc = ajSeqGetSeqC(seq); for(i=begin-1; i<end-1; ++i) { ajStrAssignSubC(&nucs,dinuc,i,i+1); if(!(valstr = ajTableFetchS(angletable, nucs))) ajFatal("Incomplete table"); ajStrToFloat(valstr,&val); anglesum += val; if(!(valstr = ajTableFetchS(energytable, nucs))) ajFatal("Incomplete table"); ajStrToFloat(valstr,&val); energysum += val; } twists = anglesum / (float)360.0 ; basesperturn = (float) len * (float)360.0 /anglesum; energyperbase = energysum/(float) (len-1); ajFmtPrintF(result, "# Output from BTWISTED\n"); ajFmtPrintF(result, "# Twisting calculated from %d to %d of %s\n", begin, end, ajSeqGetNameC(seq)); ajFmtPrintF(result,"Total twist (degrees): %.1f\n", anglesum); ajFmtPrintF(result,"Total turns : %.2f\n", twists); ajFmtPrintF(result,"Average bases per turn: %.2f\n", basesperturn); ajFmtPrintF(result,"Total stacking energy : %.2f\n", energysum); ajFmtPrintF(result,"Average stacking energy per dinucleotide: %.2f\n", energyperbase); ajTablestrFree(&angletable); ajTablestrFree(&energytable); ajStrDel(&nucs); ajFileClose(&result); ajSeqDel(&seq); embExit (); return 0; }
static void primersearch_scan_seq(const Primer primdata, const AjPSeq seq, AjBool reverse) { AjPStr seqstr = NULL; AjPStr revstr = NULL; AjPStr seqname = NULL; ajuint fhits = 0; ajuint rhits = 0; AjPList fhits_list = NULL; AjPList rhits_list = NULL; /* initialise variables for search */ ajStrAssignC(&seqname,ajSeqGetNameC(seq)); ajStrAssignS(&seqstr, ajSeqGetSeqS(seq)); ajStrAssignS(&revstr, ajSeqGetSeqS(seq)); ajStrFmtUpper(&seqstr); ajStrFmtUpper(&revstr); ajSeqstrReverse(&revstr); fhits_list = ajListNew(); rhits_list = ajListNew(); if(!reverse) { /* test OligoA against forward sequence, and OligoB against reverse */ embPatFuzzSearch(primdata->forward->type, ajSeqGetBegin(seq), primdata->forward->patstr, seqname, seqstr, fhits_list, primdata->forward->len, primdata->forward->mm, primdata->forward->amino, primdata->forward->carboxyl, primdata->forward->buf, primdata->forward->off, primdata->forward->sotable, primdata->forward->solimit, primdata->forward->re, primdata->forward->skipm, &fhits, primdata->forward->real_len, &(primdata->forward->tidy)); if(fhits) embPatFuzzSearch(primdata->reverse->type, ajSeqGetBegin(seq), primdata->reverse->patstr, seqname, revstr, rhits_list, primdata->reverse->len, primdata->reverse->mm, primdata->reverse->amino, primdata->reverse->carboxyl, primdata->reverse->buf, primdata->reverse->off, primdata->reverse->sotable, primdata->reverse->solimit, primdata->reverse->re, primdata->reverse->skipm, &rhits, primdata->reverse->real_len, &(primdata->reverse->tidy)); } else { /*test OligoB against forward sequence, and OligoA against reverse */ embPatFuzzSearch(primdata->reverse->type, ajSeqGetBegin(seq), primdata->reverse->patstr, seqname, seqstr, fhits_list, primdata->reverse->len, primdata->reverse->mm, primdata->reverse->amino, primdata->reverse->carboxyl, primdata->reverse->buf, primdata->reverse->off, primdata->reverse->sotable, primdata->reverse->solimit, primdata->reverse->re, primdata->reverse->skipm, &fhits, primdata->reverse->real_len, &(primdata->reverse->tidy)); if(fhits) embPatFuzzSearch(primdata->forward->type, ajSeqGetBegin(seq), primdata->forward->patstr, seqname, revstr, rhits_list, primdata->forward->len, primdata->forward->mm, primdata->forward->amino, primdata->forward->carboxyl, primdata->forward->buf, primdata->forward->off, primdata->forward->sotable, primdata->forward->solimit, primdata->forward->re, primdata->forward->skipm, &rhits, primdata->forward->real_len, &(primdata->forward->tidy)); } if(fhits && rhits) /* get amplimer length(s) and write out the hit */ primersearch_store_hits(primdata, fhits_list, rhits_list, seq, reverse); /* tidy up */ primersearch_clean_hitlist(&fhits_list); primersearch_clean_hitlist(&rhits_list); ajStrDel(&seqstr); ajStrDel(&revstr); ajStrDel(&seqname); return; }
int main(int argc, char **argv) { AjPSeq seq = NULL; AjPReport report = NULL; AjPFeattable feat=NULL; AjPStr sstr = NULL; const AjPStr sname = NULL; AjPStr revcomp = NULL; ajint RStotal; AjPStr enzymes = NULL; /* string for RE selection */ AjPList relist = NULL; ajint begin; ajint end; ajint radj; ajint start; AjBool sshow; AjBool tshow; AjBool allmut; AjPList results1 = NULL; /* for forward strand */ AjPList results2 = NULL; /* for reverse strand */ AjPList shits; AjPList nshits; AjPStr tailstr = NULL; embInit("silent", argc, argv); seq = ajAcdGetSeq("sequence"); enzymes = ajAcdGetString("enzymes"); sshow = ajAcdGetBoolean("sshow"); tshow = ajAcdGetBoolean("tshow"); allmut = ajAcdGetBoolean("allmut"); report = ajAcdGetReport ("outfile"); shits = ajListNew(); nshits = ajListNew(); /*calling function to read in RE info*/ RStotal = silent_restr_read(&relist,enzymes); begin = ajSeqGetBegin(seq); /* returns the seq start posn, or 1 if no start has been set */ end = ajSeqGetEnd(seq); /* returns the seq end posn, or seq length if no end has been set */ radj=begin+end+1; /* posn adjustment for complementary strand */ ajStrAssignSubC(&sstr,ajSeqGetSeqC(seq),--begin,--end); ajStrFmtUpper(&sstr); sname = ajSeqGetNameS(seq); ajStrAssignC(&revcomp,ajStrGetPtr(sstr)); ajSeqstrReverse(&revcomp); start = begin+1; feat = ajFeattableNewDna(ajSeqGetNameS(seq)); if(sshow) { silent_fmt_sequence("SEQUENCE", sstr,&tailstr,start,ajTrue); } results1 = silent_mismatch(sstr,relist,&tailstr,sname,RStotal,begin,radj, ajFalse,end,tshow); silent_split_hits(&results1,&shits,&nshits,allmut); ajReportSetHeaderC(report, "KEY:\n" "EnzymeName: Enzyme name\n" "RS-Pattern: Restriction enzyme recognition site " "pattern\n" "Base-Posn: Position of base to be mutated\n" "AAs: Amino acid. Original sequence(.)After mutation\n" "Silent: Yes for unchanged amino acid\n" "Mutation: The base mutation to perform\n\n" "Creating silent and non-silent mutations\n"); silent_fmt_hits(shits,feat, ajTrue, ajFalse); if(allmut) { silent_fmt_hits(nshits,feat, ajFalse, ajFalse); } if(sshow) { silent_fmt_sequence("REVERSE SEQUENCE", revcomp,&tailstr,start,ajTrue); } results2 = silent_mismatch(revcomp,relist,&tailstr, sname,RStotal,begin,radj, ajTrue,end,tshow); silent_split_hits(&results2,&shits,&nshits,allmut); silent_fmt_hits(shits,feat, ajTrue, ajTrue); if(allmut) { silent_fmt_hits(nshits,feat, ajFalse, ajTrue); } ajReportSetStatistics(report, 1, ajSeqGetLenTrimmed(seq)); ajReportSetTailS(report, tailstr); (void) ajReportWrite (report,feat,seq); ajFeattableDel(&feat); ajStrDel(&revcomp); ajStrDel(&enzymes); ajListFree(&results1); ajListFree(&results2); ajListFree(&shits); ajListFree(&nshits); ajReportClose(report); ajReportDel(&report); ajSeqDel(&seq); ajStrDel(&sstr); silent_relistdel(&relist); ajStrDel(&tailstr); embExit(); return 0; }
int main(int argc, char **argv) { AjPFile outf = NULL; AjPSeq sequence = NULL; AjPStr substr = NULL; AjPStr seqstr = NULL; AjPStr revstr = NULL; AjPStr p1; AjPStr p2; PPrimer eric = NULL; PPrimer fred = NULL; PPrimer f; PPrimer r; PPair pair; AjPList forlist = NULL; AjPList revlist = NULL; AjPList pairlist = NULL; AjBool targetrange; AjBool isDNA = ajTrue; AjBool dolist = ajFalse; ajint primerlen = 0; ajint minprimerlen = 0; ajint maxprimerlen = 0; ajint minprodlen = 0; ajint maxprodlen = 0; ajint prodlen = 0; ajint seqlen = 0; ajint stepping_value = 1; ajint targetstart = 0; ajint targetend = 0; ajint limit = 0; ajint limit2 = 0; ajint lastpos = 0; ajint startpos = 0; ajint endpos = 0; ajint begin; ajint end; ajint v1; ajint v2; ajint overlap; float minpmGCcont = 0.; float maxpmGCcont = 0.; float minprodGCcont = 0.; float maxprodGCcont = 0.; float prodTm; float prodGC; ajint i; ajint j; ajint neric=0; ajint nfred=0; ajint npair=0; float minprimerTm = 0.0; float maxprimerTm = 0.0; float saltconc = 0.0; float dnaconc = 0.0; embInit ("prima", argc, argv); substr = ajStrNew(); forlist = ajListNew(); revlist = ajListNew(); pairlist = ajListNew(); p1 = ajStrNew(); p2 = ajStrNew(); sequence = ajAcdGetSeq("sequence"); outf = ajAcdGetOutfile("outfile"); minprimerlen = ajAcdGetInt("minprimerlen"); maxprimerlen = ajAcdGetInt("maxprimerlen"); minpmGCcont = ajAcdGetFloat("minpmGCcont"); maxpmGCcont = ajAcdGetFloat("maxpmGCcont"); minprimerTm = ajAcdGetFloat("mintmprimer"); maxprimerTm = ajAcdGetFloat("maxtmprimer"); minprodlen = ajAcdGetInt("minplen"); maxprodlen = ajAcdGetInt("maxplen"); minprodGCcont = ajAcdGetFloat("minpgccont"); maxprodGCcont = ajAcdGetFloat("maxpgccont"); saltconc = ajAcdGetFloat("saltconc"); dnaconc = ajAcdGetFloat("dnaconc"); targetrange = ajAcdGetToggle("targetrange"); targetstart = ajAcdGetInt("targetstart"); targetend = ajAcdGetInt("targetend"); overlap = ajAcdGetInt("overlap"); dolist = ajAcdGetBoolean("list"); seqstr = ajSeqGetSeqCopyS(sequence); ajStrFmtUpper(&seqstr); begin = ajSeqGetBegin(sequence); end = ajSeqGetEnd(sequence); seqlen = end-begin+1; ajStrAssignSubC(&substr,ajStrGetPtr(seqstr),begin-1,end-1); revstr = ajStrNewC(ajStrGetPtr(substr)); ajSeqstrReverse(&revstr); AJCNEW0(entropy, seqlen); AJCNEW0(enthalpy, seqlen); AJCNEW0(energy, seqlen); /* Initialise Tm calculation arrays */ ajMeltTempSave(ajStrGetPtr(substr),0,seqlen,saltconc,dnaconc,1, &entropy, &enthalpy, &energy); ajFmtPrintF(outf, "\n\nINPUT SUMMARY\n"); ajFmtPrintF(outf, "*************\n\n"); if(targetrange) ajFmtPrintF (outf, "Prima of %s from positions %d to %d bps\n", ajSeqGetNameC(sequence),targetstart, targetend); else ajFmtPrintF(outf, "Prima of %s\n", ajSeqGetNameC(sequence)); ajFmtPrintF(outf, "PRIMER CONSTRAINTS:\n"); ajFmtPrintF (outf, "PRIMA DOES NOT ALLOW PRIMER SEQUENCE AMBIGUITY OR "); ajFmtPrintF(outf,"DUPLICATE PRIMER ENDPOINTS\n"); ajFmtPrintF(outf, "Primer size range is %d-%d\n",minprimerlen,maxprimerlen); ajFmtPrintF(outf, "Primer GC content range is %.2f-%.2f\n",minpmGCcont, maxpmGCcont); ajFmtPrintF(outf,"Primer melting Temp range is %.2f - %.2f C\n", minprimerTm, maxprimerTm); ajFmtPrintF (outf, "PRODUCT CONSTRAINTS:\n"); ajFmtPrintF(outf,"Product GC content range is %.2f-%.2f\n", minprodGCcont, maxprodGCcont); ajFmtPrintF(outf, "Salt concentration is %.2f (mM)\n", saltconc); ajFmtPrintF(outf, "DNA concentration is %.2f (nM)\n", dnaconc); if(targetrange) ajFmtPrintF(outf, "Targeted range to amplify is from %d to %d\n", targetstart,targetend); else { ajFmtPrintF(outf,"Considering all suitable Primer pairs with "); ajFmtPrintF(outf,"Product length ranges %d to %d\n\n\n", minprodlen, maxprodlen); } ajFmtPrintF(outf, "\n\nPRIMER/PRODUCT PAIR CALCULATIONS & OUTPUT\n"); ajFmtPrintF(outf, "*****************************************\n\n"); if(seqlen-minprimerlen < 0) ajFatal("Sequence too short"); if(targetrange) { ajStrAssignSubC(&p1,ajStrGetPtr(substr),targetstart-begin,targetend-begin); prodGC = ajMeltGC(substr,seqlen); prodTm = ajMeltTempProd(prodGC,saltconc,seqlen); if(prodGC<minprodGCcont || prodGC>maxprodGCcont) { ajFmtPrintF(outf, "Product GC content [%.2f] outside acceptable range\n", prodGC); embExitBad(); return 0; } prima_testtarget(substr, revstr, targetstart-begin, targetend-begin, minprimerlen, maxprimerlen, seqlen, minprimerTm, maxprimerTm, minpmGCcont, maxpmGCcont, minprodGCcont, maxprodGCcont, saltconc, dnaconc, pairlist, &npair); } if(!targetrange) { limit = seqlen-minprimerlen-minprodlen+1; lastpos = seqlen-minprodlen; limit2 = maxprodlen-minprodlen; /* Outer loop selects all possible product start points */ for(i=minprimerlen; i<limit; ++i) { startpos = i; ajDebug("Position in sequence %d\n",startpos); endpos = i+minprodlen-1; /* Inner loop selects all possible product lengths */ for(j=0; j<limit2; ++j, ++endpos) { if(endpos>lastpos) break; v1 = endpos-startpos+1; ajStrAssignSubC(&p1,ajStrGetPtr(substr),startpos,endpos); prodGC = ajMeltGC(p1,v1); prodTm = ajMeltTempProd(prodGC,saltconc,v1); if(prodGC<minprodGCcont || prodGC>maxprodGCcont) continue; /* Only accept primers with acceptable Tm and GC */ neric = 0; nfred = 0; prima_testproduct(substr, startpos, endpos, primerlen, minprimerlen, maxprimerlen,minpmGCcont, maxpmGCcont, minprimerTm, maxprimerTm, minprodlen, maxprodlen, prodTm, prodGC, seqlen, &eric,&fred,forlist,revlist,&neric,&nfred, stepping_value, saltconc,dnaconc, isDNA, begin); if(!neric) continue; /* Now reject those primers with self-complementarity */ prima_reject_self(forlist,revlist,&neric,&nfred); if(!neric) continue; /* Reject any primers that could bind elsewhere in the sequence */ prima_test_multi(forlist,revlist,&neric,&nfred,substr,revstr, seqlen); /* Now select the least complementary pair (if any) */ prima_best_primer(forlist, revlist, &neric, &nfred); if(!neric) continue; AJNEW(pair); ajListPop(forlist,(void **)&f); ajListPop(revlist,(void **)&r); pair->f = f; pair->r = r; ++npair; ajListPush(pairlist,(void *)pair); } } } if(!targetrange) { /* Get rid of primer pairs nearby the top scoring ones */ prima_TwoSortscorepos(&pairlist); prima_prune_nearby(pairlist, &npair, maxprimerlen-1); ajListSort(pairlist,prima_PosCompare); prima_check_overlap(pairlist,&npair,overlap); } if(npair) { if(!targetrange) ajFmtPrintF(outf,"%d pairs found\n\n",npair); else ajFmtPrintF(outf, "Closest primer pair to specified product is:\n\n"); if((maxprimerlen<26 && seqlen<999999 && !dolist)) ajFmtPrintF(outf,"\n\t\tForward\t\t\t\t\tReverse\n\n"); } for(i=0;i<npair;++i) { if(!targetrange) ajFmtPrintF(outf,"[%d]\n",i+1); ajListPop(pairlist,(void **)&pair); prodlen = pair->r->start - (pair->f->start + pair->f->primerlen); if((maxprimerlen<26 && seqlen<999999 && !dolist)) { v1 = pair->f->start; v2 = v1 + pair->f->primerlen -1; ajStrAssignSubS(&p1,substr,v1,v2); ajFmtPrintF(outf,"%6d %-25.25s %d\t", v1+begin, ajStrGetPtr(p1), v2+begin); v1 = pair->r->start; v2 = v1 + pair->r->primerlen -1; ajStrAssignSubS(&p2,substr,v1,v2); ajSeqstrReverse(&p2); ajFmtPrintF(outf, "%6d %-25.25s %d\n", v1+begin, ajStrGetPtr(p2), v2+begin); ajFmtPrintF(outf," Tm %.2f C (GC %.2f%%)\t\t ", pair->f->primerTm,pair->f->primGCcont*100.); ajFmtPrintF(outf,"Tm %.2f C (GC %.2f%%)\n", pair->r->primerTm,pair->r->primGCcont*100.); ajFmtPrintF(outf," Length: %-32dLength: %d\n", pair->f->primerlen,pair->r->primerlen); ajFmtPrintF(outf," Tma: %.2f C\t\t\t", ajAnneal(pair->f->primerTm,pair->f->prodTm)); ajFmtPrintF(outf," Tma: %.2f C\n\n\n", ajAnneal(pair->r->primerTm,pair->f->prodTm)); ajFmtPrintF(outf," Product GC: %.2f%%\n", pair->f->prodGC * 100.0); ajFmtPrintF(outf," Product Tm: %.2f C\n", pair->f->prodTm); ajFmtPrintF(outf," Length: %d\n\n\n",prodlen); } else { ajFmtPrintF(outf," Product from %d to %d\n",pair->f->start+ pair->f->primerlen+begin,pair->r->start-1+begin); ajFmtPrintF(outf," Tm: %.2f C GC: %.2f%%\n", pair->f->prodTm,pair->f->prodGC*(float)100.); ajFmtPrintF(outf," Length: %d\n\n\n",prodlen); v1 = pair->f->start; v2 = v1 + pair->f->primerlen -1; ajStrAssignSubS(&p1,substr,v1,v2); ajFmtPrintF(outf," Forward: 5' %s 3'\n",ajStrGetPtr(p1)); ajFmtPrintF(outf," Start: %d\n",v1+begin); ajFmtPrintF(outf," End: %d\n",v2+begin); ajFmtPrintF(outf," Tm: %.2f C\n", pair->f->primerTm); ajFmtPrintF(outf," GC: %.2f%%\n", pair->f->primGCcont*(float)100.); ajFmtPrintF(outf," Len: %d\n", pair->f->primerlen); ajFmtPrintF(outf," Tma: %.2f C\n\n\n", ajAnneal(pair->f->primerTm,pair->f->prodTm)); v1 = pair->r->start; v2 = v1 + pair->r->primerlen -1; ajStrAssignSubS(&p2,substr,v1,v2); ajSeqstrReverse(&p2); ajStrAssignSubS(&p1,substr,v1,v2); ajFmtPrintF(outf," Reverse: 5' %s 3'\n",ajStrGetPtr(p1)); ajFmtPrintF(outf," Start: %d\n",v1+begin); ajFmtPrintF(outf," End: %d\n",v2+begin); ajFmtPrintF(outf," Tm: %.2f C\n", pair->r->primerTm); ajFmtPrintF(outf," GC: %.2f%%\n", pair->r->primGCcont*(float)100.); ajFmtPrintF(outf," Len: %d\n", pair->r->primerlen); ajFmtPrintF(outf," Tma: %.2f C\n\n\n", ajAnneal(pair->r->primerTm,pair->f->prodTm)); } prima_PrimerDel(&pair->f); prima_PrimerDel(&pair->r); AJFREE(pair); } ajStrDel(&seqstr); ajStrDel(&revstr); ajStrDel(&substr); ajStrDel(&p1); ajStrDel(&p2); ajListFree(&forlist); ajListFree(&revlist); ajListFree(&pairlist); ajFileClose(&outf); ajSeqDel(&sequence); AJFREE(entropy); AJFREE(enthalpy); AJFREE(energy); embExit(); return 0; }
int main(int argc, char **argv) { AjPSeq seq = NULL; AjPStr strand = NULL; AjPStr substr = NULL; AjPStr squares = NULL; AjPStr diamonds = NULL; AjPStr octags = NULL; AjBool amphipathic; AjPStr txt = NULL; AjPGraph graph = NULL; ajint begin; ajint end; ajint lc; ajint i; ajint j; ajint r; ajint count; ajint pstart; ajint pstop; float xmin = 0.0; float xmax = 150.0; float ymin = 0.0; float ymax = 112.5; float xstart; float ystart; float ch = (float)1.8; float xinc; float yinc; AjPStr fstr = NULL; float x; float y; embInit("pepnet", argc, argv); seq = ajAcdGetSeq("sequence"); graph = ajAcdGetGraph("graph"); octags = ajAcdGetString("octags"); squares = ajAcdGetString("squares"); diamonds = ajAcdGetString("diamonds"); amphipathic = ajAcdGetToggle("amphipathic"); ajStrFmtUpper(&octags); ajStrFmtUpper(&squares); ajStrFmtUpper(&diamonds); if(amphipathic) { ajStrAssignC(&squares,"ACFGILMVWY"); ajStrAssignC(&diamonds,""); ajStrAssignC(&octags,""); } substr = ajStrNew(); txt = ajStrNew(); fstr = ajStrNew(); begin = ajSeqGetBegin(seq); end = ajSeqGetEnd(seq); strand = ajSeqGetSeqCopyS(seq); ajStrFmtUpper(&strand); ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1); ajGraphAppendTitleS(graph, ajSeqGetUsaS(seq)); ajGraphOpenWin(graph, xmin,xmax,ymin,ymax); for(count=begin-1,r=0;count<end;count+=231) { if (count > begin) ajGraphNewpage(graph, ajFalse); pstart=count; pstop = AJMIN(end-1, count+230); ajGraphicsSetCharscale(0.75); xstart = 145.0; ystart = 80.0; yinc = ch * (float)2.5; xinc = yinc / (float)2.5; x = xstart; for(i=pstart;i<=pstop;i+=7) { lc = i; if(x < 10.0*xinc) { x = xstart; ystart -= (float)7.5*yinc; } y=ystart; ajFmtPrintS(&txt,"%d",i+1); ajGraphicsSetFgcolour(RED); ajGraphicsDrawposTextJustify(x-xinc,y-yinc-1,ajStrGetPtr(txt),0.5); for(j=0;j<4;++j) { x -= xinc; y += yinc; if(lc <= pstop) pepnet_plotresidue(*(ajStrGetPtr(substr)+r),x,y, ajStrGetPtr(squares),ajStrGetPtr(octags), ajStrGetPtr(diamonds)); ++r; ++lc; } y=ystart+yinc/(float)2.0; for(j=4;j<7;++j) { x -= xinc; y += yinc; if(lc <= pstop) pepnet_plotresidue(*(ajStrGetPtr(substr)+r),x,y, ajStrGetPtr(squares),ajStrGetPtr(octags), ajStrGetPtr(diamonds)); ++r; ++lc; } } } ajGraphicsClose(); ajGraphxyDel(&graph); ajStrDel(&strand); ajStrDel(&fstr); ajSeqDel(&seq); ajStrDel(&substr); ajStrDel(&squares); ajStrDel(&diamonds); ajStrDel(&octags); ajStrDel(&txt); embExit(); return 0; }
int main(int argc, char **argv) { AjPSeq seq = NULL; AjPStr strand = NULL; AjPStr substr = NULL; AjPStr squares = NULL; AjPStr diamonds = NULL; AjPStr octags = NULL; AjBool wheel; AjBool amphipathic; AjPGraph graph=0; AjBool first; AjBool startloop; ajint begin; ajint end; ajint len; ajint steps; ajint turns; ajint lc; ajint i; ajint j; ajint k; float xmin = (float) -1.0; float xmax = (float) 1.0; float ymin = (float) -0.75; float ymax = (float) 0.75; float minresplot = (float) 36.0; float resgap = (float) 0.0533; float wheelgap = (float) 0.00; float nresgap = (float) 0.08; float angle; float oldangle; float ang; float radius; float wradius; float xx1; float xx2; float yy1; float yy2; embInit("pepwheel", argc, argv); seq = ajAcdGetSeq("sequence"); steps = ajAcdGetInt("steps"); turns = ajAcdGetInt("turns"); graph = ajAcdGetGraph("graph"); octags = ajAcdGetString("octags"); squares = ajAcdGetString("squares"); diamonds = ajAcdGetString("diamonds"); wheel = ajAcdGetBoolean("wheel"); amphipathic = ajAcdGetToggle("amphipathic"); ajStrFmtUpper(&octags); ajStrFmtUpper(&squares); ajStrFmtUpper(&diamonds); if(amphipathic) { ajStrAssignC(&squares,"ACFGILMVWY"); ajStrAssignC(&diamonds,""); ajStrAssignC(&octags,""); } substr = ajStrNew(); begin = ajSeqGetBegin(seq); end = ajSeqGetEnd(seq); ajDebug("begin: %d end: %d\n", begin, end); strand = ajSeqGetSeqCopyS(seq); ajStrFmtUpper(&strand); ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1); len = ajStrGetLen(substr); ajGraphAppendTitleS(graph, ajSeqGetUsaS(seq)); ajGraphOpenWin(graph,xmin,xmax,ymin,ymax); ajGraphicsSetFgcolour(AJB_BLACK); ang = ((float)360.0 / (float)steps) * (float)turns; first = ajTrue; angle = (float) 90.0 + ang; if(end-begin > (ajint)minresplot) wradius = (float) 0.2; else wradius = (float) 0.40; for(i=0,lc=0,radius=wradius+wheelgap;i<len;i+=steps) { wradius += wheelgap; startloop = ajTrue; k = AJMIN(i+steps, end); for(j=i;j<k;++j) { oldangle = angle; angle = oldangle-ang; if(first) startloop = first = ajFalse; else { if(startloop) { if(wheel) { ajCvtPolToRec(wradius-wheelgap,oldangle,&xx1,&yy1); ajCvtPolToRec(wradius,angle,&xx2,&yy2); ajGraphicsDrawposLine(xx1,yy1,xx2,yy2); } startloop=ajFalse; } else if(wheel) { ajCvtPolToRec(wradius,oldangle,&xx1,&yy1); ajCvtPolToRec(wradius,angle,&xx2,&yy2); ajGraphicsDrawposLine(xx1,yy1,xx2,yy2); } } pepwheel_plotresidue(*(ajStrGetPtr(substr)+lc),radius+resgap,angle, ajStrGetPtr(squares),ajStrGetPtr(octags), ajStrGetPtr(diamonds), xmin,xmax,ymin,ymax); ++lc; if(lc==len) break; } radius += nresgap; } ajGraphicsClose(); ajGraphxyDel(&graph); ajStrDel(&strand); ajStrDel(&substr); ajSeqDel(&seq); ajStrDel(&squares); ajStrDel(&diamonds); ajStrDel(&octags); embExit(); return 0; }
int main(int argc, char **argv) { AjPSeqall seqall; AjPSeq a; AjPStr substr; AjPStr rname; ajint be; ajint en; ajint len; AjBool unfavoured; AjBool overlap; AjBool allpartials; AjPStr menu; AjPStr rag; ajint n = 0; ajint r = 0; AjPFile outf = NULL; AjPReport report = NULL; AjPFeattable TabRpt = NULL; AjPStr tmpStr = NULL; AjPList l; AjPList pa; AjPFile mfptr = NULL; AjBool nterm = ajFalse; AjBool cterm = ajFalse; AjBool dorag = ajFalse; ajint ncomp; ajint npart; EmbPPropMolwt *mwdata = NULL; AjBool mono; embInit("digest", argc, argv); seqall = ajAcdGetSeqall("seqall"); menu = ajAcdGetListSingle("menu"); dorag = ajAcdGetBoolean("ragging"); rag = ajAcdGetListSingle("termini"); unfavoured = ajAcdGetBoolean("unfavoured"); overlap = ajAcdGetBoolean("overlap"); allpartials = ajAcdGetBoolean("allpartials"); report = ajAcdGetReport("outfile"); mfptr = ajAcdGetDatafile("mwdata"); mono = ajAcdGetBoolean("mono"); /* obsolete. Can be uncommented in acd file and here to reuse */ /* outf = ajAcdGetOutfile("originalfile"); */ ajStrToInt(menu, &n); --n; ajStrToInt(rag, &r); if(r==2 || r==4) nterm = ajTrue; if(r==3 || r==4) cterm = ajTrue; mwdata = embPropEmolwtRead(mfptr); while(ajSeqallNext(seqall, &a)) { substr = ajStrNew(); be = ajSeqGetBegin(a); en = ajSeqGetEnd(a); ajStrAssignSubC(&substr,ajSeqGetSeqC(a),be-1,en-1); ajStrFmtUpper(&substr); len = en-be+1; l = ajListNew(); pa = ajListNew(); rname = ajStrNew(); TabRpt = ajFeattableNewSeq(a); embPropCalcFragments(ajStrGetPtr(substr),n,&l,&pa, unfavoured,overlap, allpartials,&ncomp,&npart,&rname, nterm, cterm, dorag, mwdata, mono); if(outf) ajFmtPrintF(outf,"DIGEST of %s from %d to %d Molwt=%10.3f\n\n", ajSeqGetNameC(a),be,en, embPropCalcMolwt(ajSeqGetSeqC(a),0,len-1,mwdata,mono)); if(!ncomp) { if(outf) ajFmtPrintF(outf, "Is not proteolytically digested using %s\n", ajStrGetPtr(rname)); } else { if(outf) { ajFmtPrintF(outf,"Complete digestion with %s " "yields %d fragments:\n", ajStrGetPtr(rname),ncomp); digest_print_hits(l,outf,be,ajStrGetPtr(substr)); } ajFmtPrintS(&tmpStr, "Complete digestion with %S yields %d fragments", rname,ncomp); ajReportSetHeaderS(report, tmpStr); digest_report_hits(TabRpt,l,be, ajStrGetPtr(substr)); ajReportWrite(report, TabRpt, a); ajFeattableClear(TabRpt); } if(overlap && !allpartials && npart) { if(outf) { ajFmtPrintF(outf, "\n\nPartial digest with %s yields %d extras.\n", ajStrGetPtr(rname),npart); ajFmtPrintF(outf,"Only overlapping partials shown:\n"); digest_print_hits(pa,outf,be,ajStrGetPtr(substr)); } ajFmtPrintS(&tmpStr, "\n\nPartial digest with %S yields %d extras.\n", rname,npart); ajFmtPrintAppS(&tmpStr,"Only overlapping partials shown:\n"); ajReportSetHeaderS(report, tmpStr); digest_report_hits(TabRpt, pa,be,ajStrGetPtr(substr)); ajReportWrite(report, TabRpt, a); ajFeattableClear(TabRpt); } if(allpartials && npart) { if(outf) { ajFmtPrintF(outf, "\n\nPartial digest with %s yields %d extras.\n", ajStrGetPtr(rname),npart); ajFmtPrintF(outf,"All partials shown:\n"); digest_print_hits(pa,outf,be,ajStrGetPtr(substr)); } ajFmtPrintS(&tmpStr, "\n\nPartial digest with %S yields %d extras.\n", rname,npart); ajFmtPrintAppS(&tmpStr,"All partials shown:\n"); ajReportSetHeaderS(report, tmpStr); digest_report_hits(TabRpt, pa,be, ajStrGetPtr(substr)); ajReportWrite(report, TabRpt, a); ajFeattableClear(TabRpt); } } embPropMolwtDel(&mwdata); ajReportDel(&report); ajFeattableDel(&TabRpt); ajSeqDel(&a); ajSeqallDel(&seqall); ajStrDel(&rname); ajStrDel(&substr); ajListFree(&pa); ajListFree(&l); ajStrDel(&menu); ajStrDel(&rag); if(outf) ajFileClose(&outf); ajFileClose(&mfptr); ajStrDel(&tmpStr); embExit(); return 0; }