int main(int argc, char **argv)
{
char **eglist ;
int numeg ;
int i, j, k, pos;
int *vv ;
SNP *cupt, *cupt2 ;
Indiv *indx ;
double y1, y2, y ;
int n0, n1, nkill ;
int nindiv = 0 ;
int nignore, numrisks = 1 ;
SNP **xsnplist ;
Indiv **xindlist ;
int *xindex ;
int nrows, ncols, m ;
double *XTX, *cc, *evecs, *ww ;
double *lambda ;
double *tvecs ;
int weightmode = NO ;
int t ;
double *xmean, *xfancy ;
double *ldmat = NULL, *ldmat2 = NULL;
double *ldvv = NULL, *ldvv2 = NULL, *vv2 = NULL ;
int chrom, numclear ;
double gdis ;
int outliter, numoutiter, *badlist, nbad ;
int a, b, n ;
FILE *outlfile ;
int xblock, blocksize=10000 ;
double *tblock ;
OUTLINFO *outpt ;
int *idperm, *vecind ; // for sort
readcommands(argc, argv) ;
printf("## smartrel version: %s\n", WVERSION) ;
packmode = YES ;
setomode(&outputmode, omode) ;
if (parname == NULL) return 0 ;
if (xchrom == (numchrom+1)) noxdata = NO ;
if (fstonly) {
printf("fstonly\n") ;
numeigs = 0 ;
numoutliter = 0 ;
numoutiter = 0 ;
outputname = NULL ;
snpeigname = NULL ;
}
if (fancynorm) printf("norm used\n\n") ;
else printf("no norm used\n\n") ;
nostatslim = MAX(nostatslim, 3) ;
outlfile = ofile = stdout;
if (outputname != NULL) openit(outputname, &ofile, "w") ;
if (outliername != NULL) openit(outliername, &outlfile, "w") ;
if (fstdetailsname != NULL) openit(fstdetailsname, &fstdetails, "w") ;
numsnps =
getsnps(snpname, &snpmarkers, 0.0, badsnpname, &nignore, numrisks) ;
numindivs = getindivs(indivname, &indivmarkers) ;
k = getgenos(genotypename, snpmarkers, indivmarkers,
numsnps, numindivs, nignore) ;
if (poplistname != NULL)
{
ZALLOC(eglist, numindivs, char *) ;
numeg = loadlist(eglist, poplistname) ;
seteglist(indivmarkers, numindivs, poplistname);
}
else
{
setstatus(indivmarkers, numindivs, NULL) ;
ZALLOC(eglist, MAXPOPS, char *) ;
numeg = makeeglist(eglist, MAXPOPS, indivmarkers, numindivs) ;
}
for (i=0; i<numeg; i++)
{
/* printf("%3d %s\n",i, eglist[i]) ; */
}
nindiv=0 ;
for (i=0; i<numindivs; i++)
{
indx = indivmarkers[i] ;
if(indx -> affstatus == YES) ++nindiv ;
}
for (i=0; i<numsnps; i++)
{
cupt = snpmarkers[i] ;
chrom = cupt -> chrom ;
if ((noxdata) && (chrom == (numchrom+1))) cupt-> ignore = YES ;
if (chrom == 0) cupt -> ignore = YES ;
if (chrom > (numchrom+1)) cupt -> ignore = YES ;
}
for (i=0; i<numsnps; i++)
{
cupt = snpmarkers[i] ;
pos = nnint(cupt -> physpos) ;
if ((xchrom>0) && (cupt -> chrom != xchrom)) cupt -> ignore = YES ;
if ((xchrom > 0) && (pos < lopos)) cupt -> ignore = YES ;
if ((xchrom > 0) && (pos > hipos)) cupt -> ignore = YES ;
if (cupt -> ignore) continue ;
if (numvalidgtx(indivmarkers, cupt, YES) <= 1)
{
printf("nodata: %20s\n", cupt -> ID) ;
cupt -> ignore = YES ;
}
}
if (killr2) {
nkill = killhir2(snpmarkers, numsnps, numindivs, r2physlim, r2genlim, r2thresh) ;
if (nkill>0) printf("killhir2. number of snps killed: %d\n", nkill) ;
}
ZALLOC(vv, numindivs, int) ;
numvalidgtallind(vv, snpmarkers, numsnps, numindivs) ;
for (i=0; i<numindivs; ++i) {
if (vv[i] == 0) {
indx = indivmarkers[i] ;
indx -> ignore = YES ;
}
}
free(vv) ;
numsnps = rmsnps(snpmarkers, numsnps, NULL) ; // rid ignorable snps
if (missingmode)
{
setmiss(snpmarkers, numsnps) ;
fancynorm = NO ;
}
if (weightname != NULL)
{
weightmode = YES ;
getweights(weightname, snpmarkers, numsnps) ;
}
if (ldregress>0)
{
ZALLOC(ldvv, ldregress*numindivs, double) ;
ZALLOC(ldvv2, ldregress*numindivs, double) ;
ZALLOC(vv2, numindivs, double) ;
ZALLOC(ldmat, ldregress*ldregress, double) ;
ZALLOC(ldmat2, ldregress*ldregress, double) ;
setidmat(ldmat, ldregress) ;
vst(ldmat, ldmat, 1.0e-6, ldregress*ldregress) ;
}
ZALLOC(xindex, numindivs, int) ;
ZALLOC(xindlist, numindivs, Indiv *) ;
ZALLOC(xsnplist, numsnps, SNP *) ;
if (popsizelimit > 0)
{
setplimit(indivmarkers, numindivs, eglist, numeg, popsizelimit) ;
}
nrows = loadindx(xindlist, xindex, indivmarkers, numindivs) ;
ncols = loadsnpx(xsnplist, snpmarkers, numsnps, indivmarkers) ;
printf("number of samples used: %d number of snps used: %d\n", nrows, ncols) ;
/**
cupt = xsnplist[0] ;
for (j=0; j<nrows; ++j) {
k = xindex[j] ;
g = getgtypes(cupt, k) ;
indx = indivmarkers[k] ;
t = indxindex(eglist, numeg, indx -> egroup) ;
printf("yy1 %20s %20s %20s %d %d %d\n", cupt ->ID, indx -> ID, indx -> egroup, j, k, g) ;
}
printf("yya: ") ; printimat(xindex, 1, nrows) ;
printf("zzindxa: %s\n", indivmarkers[230] -> egroup) ;
*/
/* printf("## nrows: %d ncols %d\n", nrows, ncols) ; */
ZALLOC(xmean, ncols, double) ;
ZALLOC(xfancy, ncols, double) ;
ZALLOC(XTX, nrows*nrows, double) ;
ZALLOC(evecs, nrows*nrows, double) ;
ZALLOC(tvecs, nrows*nrows, double) ;
ZALLOC(lambda, nrows, double) ;
ZALLOC(cc, nrows, double) ;
ZALLOC(ww, nrows, double) ;
ZALLOC(badlist, nrows, int) ;
blocksize = MIN(blocksize, ncols) ;
ZALLOC(tblock, nrows*blocksize, double) ;
// xfancy is multiplier for column xmean is mean to take off
// badlist is list of rows to delete (outlier removal)
numoutiter = 1 ;
if (numoutliter>=1)
{
numoutiter = numoutliter+1 ;
ZALLOC(outinfo, nrows, OUTLINFO *) ;
for (k=0; k<nrows; k++)
{
ZALLOC(outinfo[k], 1, OUTLINFO) ;
}
/* fprintf(outlfile, "##%18s %4s %6s %9s\n", "ID", "iter","eigvec", "score") ; */
}
for (outliter = 1; outliter <= numoutiter ; ++outliter) {
if (fstonly) {
setidmat(XTX, nrows) ;
vclear(lambda, 1.0, nrows) ;
break ;
}
if (outliter>1) {
ncols = loadsnpx(xsnplist, snpmarkers, numsnps, indivmarkers) ;
}
vzero(XTX, nrows*nrows) ;
vzero(tblock, nrows*blocksize) ;
xblock = 0 ;
vzero(xmean, ncols) ;
vclear(xfancy, 1.0, ncols) ;
for (i=0; i<ncols; i++)
{
cupt = xsnplist[i] ;
chrom = cupt -> chrom ;
getcolxz(cc, cupt, xindex, nrows, i, xmean, xfancy, &n0, &n1) ;
t = MIN(n0, n1) ;
if (t <= minallelecnt) {
cupt -> ignore = YES ;
vzero(cc, nrows) ;
}
if (weightmode)
{
vst(cc, cc, xsnplist[i] -> weight, nrows) ;
}
if (ldregress>0)
{
numclear = 0 ;
for (k=1; k<= ldregress; ++k)
{
j = i-k ;
if (j<0)
{
numclear = ldregress-k+1 ;
break ;
}
cupt2 = xsnplist[j] ;
if (cupt2 -> chrom != chrom) gdis = ldlimit + 1.0 ;
else gdis = cupt -> genpos - cupt2 -> genpos ;
if (gdis>=ldlimit)
{
numclear = ldregress-k+1 ;
break ;
}
}
if (numclear>0) clearld(ldmat, ldvv, ldregress, nrows, numclear) ;
ldreg(ldmat, ldmat2, cc, vv2, ldvv, ldvv2, ldregress, nrows) ;
copyarr(ldmat2, ldmat, ldregress*ldregress) ;
copyarr(vv2, cc, nrows) ;
copyarr(ldvv2, ldvv, ldregress*nrows) ;
}
copyarr(cc, tblock+xblock*nrows, nrows) ;
++xblock ;
/** this is the key code to parallelize */
if (xblock==blocksize)
{
domult(tvecs, tblock, xblock, nrows) ;
vvp(XTX, XTX, tvecs, nrows*nrows) ;
xblock = 0 ;
vzero(tblock, nrows*blocksize) ;
}
}
if (xblock>0)
{
domult(tvecs, tblock, xblock, nrows) ;
vvp(XTX, XTX, tvecs, nrows*nrows) ;
}
symit(XTX, nrows) ;
/**
a = 0; b=0 ;
printf("zz1 %12.6f ", XTX[a*nrows+b]) ;
a = nrows-1; b=nrows-1 ;
printf(" %12.6f %15.9g\n", XTX[a*nrows+b], asum(XTX, nrows*nrows)) ;
*/
if (verbose)
{
printdiag(XTX, nrows) ;
}
y = trace(XTX, nrows) / (double) (nrows-1) ;
if (isnan(y)) fatalx("bad XTX matrix\n") ;
/* printf("trace: %9.3f\n", y) ; */
if (y<=0.0) fatalx("XTX has zero trace (perhaps no data)\n") ;
vst(XTX, XTX, 1.0/y, nrows * nrows) ;
/// mean eigenvalue is 1
eigvecs(XTX, lambda, evecs, nrows) ;
// eigenvalues are in decreasing order
if (outliter > numoutliter) break ;
// last pass skips outliers
numoutleigs = MIN(numoutleigs, nrows-1) ;
nbad = ridoutlier(evecs, nrows, numoutleigs, outlthresh, badlist, outinfo) ;
if (nbad == 0) break ;
for (i=0; i<nbad; i++)
{
j = badlist[i] ;
indx = xindlist[j] ;
outpt = outinfo[j] ;
fprintf(outlfile, "REMOVED outlier %s iter %d evec %d sigmage %.3f\n", indx -> ID, outliter, outpt -> vecno, outpt -> score) ;
indx -> ignore = YES ;
}
nrows = loadindx(xindlist, xindex, indivmarkers, numindivs) ;
printf("number of samples after outlier removal: %d\n", nrows) ;
}
if (outliername != NULL) fclose(outlfile) ;
m = numgtz(lambda, nrows) ;
/* printf("matrix rank: %d\n", m) ; */
if (m==0) fatalx("no data\n") ;
/** smartrel code */
for (i=0; i<numeigs; i++) {
y = sqrt(lambda[i]) ;
vst(ww, evecs+i*nrows, y, nrows) ;
subouter(XTX, ww, nrows) ;
}
free(tvecs) ;
n = 0 ;
ZALLOC(vecind, nrows*nrows/2, int) ;
for (i=0; i<nrows; i++) {
for (j=i+1; j<nrows; j++) {
k = i*nrows + j ;
y1 = XTX[i*nrows+i] ;
y2 = XTX[j*nrows+j] ;
y = XTX[k]/sqrt(y1*y2) ;
y += 1/(double)(nrows-1);
if (y<relthresh) continue ;
vecind[n] = k ;
evecs[n] = -y ;
++n ;
}
}
free(XTX) ;
if (n==0) {
printf("## nothing above relthresh!\n") ;
printf("##end of smartrel run\n") ;
return 0 ;
}
ZALLOC(idperm, n, int) ;
sortit(evecs, idperm, n) ;
for (i=0; i<n; i++) {
j = idperm[i] ;
k = vecind[j] ;
a = k/nrows ;
b = k%nrows ;
printf("rel: %20s ", xindlist[a] ->ID) ;
printf("%20s ", xindlist[b] ->ID) ;
printf(" %9.3f", -evecs[i]) ;
printnl() ;
}
printf("##end of smartrel run\n") ;
return 0 ;
}
int main(int argc, char **argv)
{
char sss[MAXSTR] ;
int **snppos ;
int *snpindx ;
char **snpnamelist, **indnamelist ;
char **eglist ;
int *nsamppops ;
int *ztypes ;
int lsnplist, lindlist, numeg ;
int i, j, k, k1, k2, k3, k4, kk;
SNP *cupt, *cupt1, *cupt2, *cupt3 ;
Indiv *indx ;
double y1, y2, y, sig, tail, yy1, yy2 ;
char ss[11] ;
int *blstart, *blsize, nblocks ;
int xnblocks ; /* for xsnplist */
int *bcols ;
double maxgendis ;
int xind[4] ;
int ch1, ch2 ;
int fmnum , lmnum ;
int num, n1, n2 ;
int nindiv = 0, e, f, lag=1 ;
double xc[9], xd[4], xc2[9] ;
int nignore, numrisks = 1 ;
double *xrow, *xpt ;
SNP **xsnplist ;
int *tagnums ;
Indiv **xindlist ;
int *xindex, *xtypes ;
int nrows, ncols, m, nc ;
double zn, zvar ;
int weightmode = NO ;
double chisq, ynrows ;
int *numhits, t ;
double *xmean, *xfancy ;
double *divans, *divsd ;
double *hettop, *hetbot ;
int chrom, numclear ;
double gdis ;
int outliter, *badlist, nbad ;
double **zdata, *z1, *z2 ;
int maxtag = -1 ;
double **zz ;
double *pmean, *pnum, rscore[3], dstat[3], hscore[3], rrr[3], ww[3], serr[3] ;
int ssize[3][3], *sz ;
int tpat[3][4] , rpat[3][4], *rrtmp, *rp ;
int *rawcol ; ;
int a, b, c, d, col ;
int aa, bb, cc, dd ;
double *qpscores ;
double *hest, *hsig ;
double mingenpos, maxgenpos ;
int *qhit ; /* number of times pair is clade in quartet */
int *qmiss ; /* number of times pair migration event implied */
int **qplist, numqp = 0, maxqp=10000 ;
double *qpscore ;
char ***qlist, *sx ;
int nqlist = 0 ;
int bbest[3] ;
double absscore[3] ;
double ascore[4], astat[4] ;
double **dsctop, **dscbot ;
double **abx, **bax, **f2 ;
int popx[4] ;
double tn[4*5], td[4*4] ;
double zzsig[5], zzest[5], zsc[5] ;
double ymin ;
double *f3, *f4, *f3sig, *f4sig ;
int t1, t2, tt ;
int ***counts, **ccc ;
double tlenz[5], tlen[5] ;
int lenz[5] ;
readcommands(argc, argv) ;
printf("## qpDstat version: %s\n", WVERSION) ;
if (parname == NULL) return 0 ;
if ((poplistname == NULL) && (popfilename == NULL)) fatalx("poplistname, popfilename both null\n") ;
if (!bankermode) forceclade = NO ;
//if (fancynorm) printf("fancynorm used\n") ;
//else printf("no fancynorm used\n") ;
setjquart(NO, jackweight, jackquart) ;
nostatslim = MAX(nostatslim, 3) ;
setinbreed(inbreed) ;
if (outputname != NULL) openit(outputname, &ofile, "w") ;
numsnps =
getsnps(snpname, &snpmarkers, 0.0, badsnpname, &nignore, numrisks) ;
numindivs = getindivs(indivname, &indivmarkers) ;
if (id2pops != NULL) {
setid2pops(id2pops, indivmarkers, numindivs) ;
}
setindm(indivmarkers) ;
k = getgenos(genotypename, snpmarkers, indivmarkers,
numsnps, numindivs, nignore) ;
for (i=0; i<numsnps; i++) {
cupt = snpmarkers[i] ;
if (cupt -> chrom >= 23) cupt -> ignore = YES ;
if (cupt -> chrom == zchrom) cupt -> ignore = YES ;
}
ZALLOC(eglist, numindivs, char *) ;
ZALLOC(ztypes, numindivs, int) ;
if (popfilename == NULL) {
if (bankermode == NO)
numeg = loadlist(eglist, poplistname) ;
else {
numeg = loadlist_type(eglist, poplistname, ztypes, 0) ;
numbanker = 0 ;
for (k=0; k<numeg; ++k) {
if (ztypes[k] == 2) ++numbanker ;
}
printf("bankermode: ") ;
printimat(ztypes, 1, numeg) ;
}
}
if (popfilename != NULL) {
bbestmode = NO ;
nqlist = numlines(popfilename) ;
ZALLOC(qlist, 4, char **) ;
for (k=0; k<4; ++k) {
ZALLOC(qlist[k], nqlist, char *) ;
}
nqlist = getnamesstripcolon(&qlist, nqlist, 4, popfilename, locount, hicount) ;
numeg = 0 ;
printf("number of quadruples %d\n", nqlist) ;
fflush(stdout) ;
for (k=0; k<4; ++k) {
for (j=0; j<nqlist; ++j) {
sx = qlist[k][j] ;
t1 = indxstring(eglist, numeg, sx) ;
if (t1 >=0) continue ;
eglist[numeg] = strdup(sx) ;
++numeg ;
setstatus(indivmarkers, numindivs, sx) ;
}
}
}
int main(int argc, char **argv)
{
gargc = argc; gargv = argv;
progname = basename(*argv), progfull = *argv;
FILE *out = stdout;
int i;
int idx = 0;
int c = 0;
setenv("LC_ALL", "C", 1);
setenv("LANG", "C", 1);
opterr = 0;
while ((c = getopt(argc, argv, "UiINCzqo:b:e:B:E:p:P:l:ua")) != -1) {
switch (c) {
case 'o':
fclose(out);
out = fopen(optarg, "wb");
if (!out) xerror(optarg);
break;
case 'U': matchdata = 1; break;
case 'N':
concat = 0;
/* "falsify"... */
bins = falsetext;
exts = falsetext;
wbin = falsetext;
wext = falsetext;
pairs = falsetext;
pext = falsetext;
break;
case 'C':
concat = 1;
bins = _bins;
exts = _exts;
wbin = _wbin;
wext = _wext;
pairs = _pairs;
pext = _pext;
break;
case 'i':
icase = 1;
break;
case 'I':
icase = 2;
break;
case 'q':
quiet = 1;
break;
case 'b':
loadlist(optarg, &bins, concat, 0);
break;
case 'e':
loadlist(optarg, &exts, concat, 0);
break;
case 'B':
loadlist(optarg, &wbin, concat, 0);
break;
case 'E':
loadlist(optarg, &wext, concat, 0);
break;
case 'p':
loadlist(optarg, &pairs, concat, 1);
break;
case 'P':
loadlist(optarg, &pext, concat, 1);
break;
case 'l':
mgcdb = optarg;
break;
case 'z':
mgcflags ^= MAGIC_COMPRESS;
break;
case 'a':
lookarchives = 1;
break;
case 'u':
removethem = 1;
break;
default: usage(); break;
}
}
if (!quiet) names = malloc(sizeof(char *));
mgc = magic_open(mgcflags);
gidx = idx = optind;
if (!getcwd(cwd, sizeof(cwd)))
xerror("getcwd");
if (argv[idx]) {
for (i = idx; i < argc; i++) {
if (access(argv[i], F_OK) != 0) { progret = 2; perror(argv[i]); continue; }
nftw(argv[i], filematch, MAXDIRDEPTH, FTW_PHYS);
}
}
else
nftw(".", filematch, MAXDIRDEPTH, FTW_PHYS);
sort(names, nindex);
unique(names, nindex);
/* print out names here, or output names to file, optionally removing them */
for (i = 0; i < nindex; i++) {
if (names[i]) {
if (!quiet) fprintf(out, "%s\n", names[i]);
if (removethem) {
if (unlink(names[i]) == -1) {
perror(names[i]);
}
}
free(names[i]);
names[i] = NULL;
}
}
if (names) { free(names); names = NULL; }
magic_close(mgc);
fclose(out);
if (bins != _bins && bins != falsetext) {
for (i = 0; bins[i]; i++) { free(bins[i]); bins[i] = NULL; }
free(bins); bins = NULL;
}
if (exts != _exts && exts != falsetext) {
for (i = 0; exts[i]; i++) { free(exts[i]); exts[i] = NULL; }
free(exts); exts = NULL;
}
if (wbin != _wbin && wbin != falsetext) {
for (i = 0; wbin[i]; i++) { free(wbin[i]); wbin[i] = NULL; }
free(wbin); wbin = NULL;
}
if (wext != _wext && wext != falsetext) {
for (i = 0; wext[i]; i++) { free(wext[i]); wext[i] = NULL; }
free(wext); wext = NULL;
}
if (pairs != _pairs && pairs != falsetext) {
for (i = 0; pairs[i]; i++) { free(pairs[i]); pairs[i] = NULL; }
free(pairs); pairs = NULL;
}
if (pext != _pext && pext != falsetext) {
for (i = 0; pext[i]; i++) { free(pext[i]); pext[i] = NULL; }
free(pext); pext = NULL;
}
if (nindex) progret = 1;
return progret;
}
int main(int argc, char *argv[])
{
FILE *fp_config;
/*---------Begin process cmd-line args and Redirection--------*/
switch (argc) {
case 1: // No parameters, use stdin
printf("NO argument provided\n");
fp_config = stdin;
break;
case 2: // One parameter, use .lan file supplied
errno_t err;
if ((err = fopen_s(&fp_config, argv[1], "r")) != 0) {
fprintf(stderr, "Cannot open config file %s!\n", argv[1]);
}
break;
default:
printf("Syntax: scanner [file]\n");
return(1);
}
// BEGIN check if file empty
fseek(fp_config, 0, SEEK_END);
if (ftell(fp_config) == 0) {
printf("File is empty.\n");
exit(1);
}
else {
rewind(fp_config);
}
// END check if file empty
// load tokenlist
std::vector<std::string> tokenlist;
loadlist(tokenlist, "res_tokenlist.txt");
std::vector<std::string> correstokenlist;
loadlist(correstokenlist, "res_correstokenlist.txt");
std::vector<std::string> rwordlist;
loadlist(rwordlist, "res_wordlist.txt");
std::vector<std::string> correswordlist;
loadlist(correswordlist, "res_correswordlist.txt");
std::vector<std::string> latexcommandslist;
loadlist(latexcommandslist, "res_latexcommandslist.txt");
// END load corresponding tokens list
// BEGIN filewalking
char c;
std::vector<token> stub;
std::vector<std::string> wordlist;
std::string word;
std::vector<int> hierarchytypes;
int currenthierarchy = 0;
int lasthierarchytype = 0;
while ((c = fgetc(fp_config)) != EOF) {
if ((c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c==46 || c == 44) {
word.push_back(c);
}
else {
if (word != "") {
wordlist.push_back(word);
token token_line = token(TYPWORD, currenthierarchy, lasthierarchytype, wordlist.size()-1);
stub.push_back(token_line);
word = "";
}
if (c == '\n') {
token token_line = token(TYPLINE, currenthierarchy, lasthierarchytype);
stub.push_back(token_line);
}
else if (c == '(') {
currenthierarchy++;
lasthierarchytype = RNDBR;
hierarchytypes.push_back(RNDBR);
token token_line = token(TYPBRAC, currenthierarchy, lasthierarchytype);
stub.push_back(token_line);
}
else if (c == '[') {
currenthierarchy++;
lasthierarchytype = SQUBR;
hierarchytypes.push_back(SQUBR);
token token_line = token(TYPBRAC, currenthierarchy, lasthierarchytype);
stub.push_back(token_line);
}
else if (c == '{') {
currenthierarchy++;
lasthierarchytype = SWGBR;
hierarchytypes.push_back(SWGBR);
token token_line = token(TYPBRAC, currenthierarchy, lasthierarchytype);
stub.push_back(token_line);
}
else if (c == '|') {
if (lasthierarchytype == ABSBR) {
currenthierarchy--;
hierarchytypes.pop_back();
if (currenthierarchy == 0) {
lasthierarchytype = NONBR;
}
else {
lasthierarchytype = hierarchytypes[hierarchytypes.size() - 1];
}
token token_line = token(TYPBRAC, currenthierarchy + 1, lasthierarchytype);
stub.push_back(token_line);
}
else {
currenthierarchy++;
lasthierarchytype = ABSBR;
hierarchytypes.push_back(ABSBR);
token token_line = token(TYPBRAC, currenthierarchy, lasthierarchytype);
stub.push_back(token_line);
}
}
else if (c == ')') {
currenthierarchy--;
hierarchytypes.pop_back();
if (currenthierarchy == 0) {
lasthierarchytype = NONBR;
}
else {
lasthierarchytype = hierarchytypes[hierarchytypes.size() - 1];
}
token token_line = token(TYPBRAC, currenthierarchy + 1, lasthierarchytype);
stub.push_back(token_line);
}
else if (c == ']') {
currenthierarchy--;
hierarchytypes.pop_back();
if (currenthierarchy == 0) {
lasthierarchytype = NONBR;
}
else {
lasthierarchytype = hierarchytypes[hierarchytypes.size() - 1];
}
token token_line = token(TYPBRAC, currenthierarchy + 1, lasthierarchytype);
stub.push_back(token_line);
}
else if (c == '}') {
currenthierarchy--;
hierarchytypes.pop_back();
if (currenthierarchy == 0) {
lasthierarchytype = NONBR;
}
else {
lasthierarchytype = hierarchytypes[hierarchytypes.size() - 1];
}
token token_line = token(TYPBRAC, currenthierarchy + 1, lasthierarchytype);
stub.push_back(token_line);
}
else if (c == ' ') {
}
else {
int tokenid = chkstringid(std::string(1, c), tokenlist);
if (tokenid > -1) {
token token_line = token(TYPTOKN, currenthierarchy, lasthierarchytype, tokenid);
stub.push_back(token_line);
}
}
}
}
// END filewalking
// BEGIN translation
int left = 0;
int middle = 0;
int right = 0;
// Construct to map IDs in the complex environment:
// Runner: [left] [middle] [right] ----->
// IDs: [1] [2] [4] [5] [2] [8]
for (int i = 2; i < stub.size(); i++) {
left = i - 2;
middle = i - 1;
right = i;
if (stub[left].get_type() == 1 && stub[middle].get_type() == 4 && stub[right].get_type() == 1 && stub[middle].get_wordlistid() == 1) {
int hierarchyentrypoint = 0;
for (int a = left; a > 0; a--) {
if (stub[a].get_hierarchy() < stub[left].get_hierarchy()) {
hierarchyentrypoint = a + 1;
break;
}
}
token token_LCMD = token(TYPLCMD, stub[hierarchyentrypoint].get_hierarchy() - 1, stub[hierarchyentrypoint].get_hierarchy() - 1, 0);
stub[hierarchyentrypoint].become_SWGBR_Left();
stub[left].become_SWGBR_Right();
stub[right].become_SWGBR_Left();
stub.insert(stub.begin() + hierarchyentrypoint, token_LCMD);
i++; left = i - 2; middle = i - 1; right = i;
stub.erase(stub.begin() + middle);
for (int a = right+1; a < stub.size(); a++) {
if (stub[a].get_type()==TYPBRAC) {
if (stub[a].get_hierarchy() == stub[middle].get_hierarchy()) {
if(stub[a].get_lasthierarchytype() == stub[middle].get_lasthierarchytype()-1)
i=a; left = i - 2; middle = i - 1; right = i;
stub[i].become_SWGBR_Right();
break;
}
}
}
}
}
std::string output;
for (int i = 0; i < stub.size(); i++) {
switch (stub[i].get_type()) {
case TYPBRAC: {
if (chkopenbracket(stub, i)) {
switch (stub[i].get_lasthierarchytype()) {
case RNDBR: {
output += "\\left (";
hierarchytypes.push_back(RNDBR);
break;
}
case SQUBR: {
output += "\\left [";
hierarchytypes.push_back(SQUBR);
break;
}
case SWGBR: {
output += "\\left {";
hierarchytypes.push_back(SWGBR);
break;
}
case ABSBR: {
output += "\\left |";
hierarchytypes.push_back(ABSBR);
break;
}
}
}
else {
switch (hierarchytypes[hierarchytypes.size() - 1]) {
case RNDBR: {
output += "\\right )";
hierarchytypes.pop_back();
break;
}
case SQUBR: {
output += "\\right ]";
hierarchytypes.pop_back();
break;
}
case SWGBR: {
output += "\\right }";
hierarchytypes.pop_back();
break;
}
case ABSBR: {
output += "\\right |";
hierarchytypes.pop_back();
break;
}
}
}
break;
}
case TYPWORD: {
std::string variable = "";
std::string parameters = "";
std::string prefix = "";
getwordparameters(wordlist[stub[i].get_wordlistid()], variable, parameters, prefix, rwordlist, correswordlist);
output += prefix + " " + variable + parameters;
break;
}
case TYPLINE: {
output += "\n";
break;
}
case TYPTOKN: {
output += correstokenlist[stub[i].get_wordlistid()];
break;
}
case TYPLCMD: {
output += latexcommandslist[stub[i].get_wordlistid()];
}
}
}
std::ofstream saveFile("Save.txt");
saveFile << output;
saveFile.close();
return 0;
}
int main(int argc, char **argv)
{
int **snppos ;
int *snpindx ;
char **snpnamelist, **indnamelist ;
char **eglist ;
int lsnplist, lindlist, numeg ;
int i,j;
SNP *cupt, *cupt1, *cupt2, *cupt3 ;
Indiv *indx ;
double gpos1,gpos2,cpos1,cpos2,gd, cd, gd100 ;
double rthresh, zt ;
int mpflag, ret, numvalidind, nvalid, numvalidsnps ;
int ch1, ch2 ;
int fmnum , lmnum ;
int num, n1, n2 ;
int nkill = 0 ;
int t, k, g ;
int nindiv = 0, e, f, lag=1 ;
double xc[9], xd[4], xc2[9] ;
double ychi, zscore, zthresh = 20.0 ;
double y1, y2 ;
int nignore, numrisks = 1 ;
char **genolist ;
int numgenolist ;
char c1, c2 ;
int t1, t2 ;
malexhet = YES ; // convertf default is don't change the data
tersem = YES ; // no snp counts
readcommands(argc, argv) ;
setomode(&outputmode, omode) ;
packmode = YES ;
settersemode(tersem) ;
if (r2thresh > 0.0) killr2 = YES ;
if (badpedignore) setbadpedignore() ;
numsnps =
getsnps(snpname, &snpmarkers, 0.0, badsnpname, &nignore, numrisks) ;
for (i=0; i<numsnps; i++) {
if (xchrom == -1) break ;
cupt = snpmarkers[i] ;
if (cupt -> chrom != xchrom) cupt -> ignore = YES ;
if (cupt -> ignore) continue ;
t = nnint(cupt -> physpos) ;
if ( (t< lopos) || (t >hipos)) cupt -> ignore = YES ;
}
nignore = 0 ;
for (i=0; i<numsnps; i++) {
cupt = snpmarkers[i] ;
if (cupt -> chrom > maxchrom) cupt -> ignore = YES ;
if (cupt -> chrom < minchrom) cupt -> ignore = YES ;
if (cupt -> ignore) ++nignore ;
}
if (numsnps == nignore) fatalx("no valid snps\n") ;
numindivs = getindivs(indivname, &indivmarkers) ;
if (polarid != NULL) {
polarindex = indindex(indivmarkers, numindivs, polarid) ;
if (polarindex<0) fatalx("polarid %s not found\n") ;
}
if (genotypelist!= NULL) {
getgenos_list(genotypelist, snpmarkers, indivmarkers,
numsnps, numindivs, nignore) ;
}
else {
setgenotypename(&genotypename, indivname) ;
getgenos(genotypename, snpmarkers, indivmarkers,
numsnps, numindivs, nignore) ;
}
if (newsnpname != NULL) {
nums2 =
getsnps(newsnpname, &snpm2, 0.0, NULL, &nignore, numrisks) ;
remap(snpmarkers, numsnps, snpm2, nums2) ;
snpmarkers = snpm2 ;
numsnps = nums2 ;
}
if (newindivname != NULL) {
numind2 = getindivs(newindivname, &indm2) ;
remapind(snpmarkers, numsnps, indivmarkers, indm2, numindivs, numind2) ;
indivmarkers = indm2 ;
numindivs = numind2 ;
if (polarid != NULL) {
polarindex = indindex(indivmarkers, numindivs, polarid) ;
}
}
if (mkdiploid) {
numindivs = rmindivs(snpmarkers, numsnps, indivmarkers, numindivs) ;
numind2 = mkindh2d(indivmarkers, &indm2, numindivs) ;
remaph2d(snpmarkers, numsnps, indivmarkers, indm2, numindivs, numind2) ;
indivmarkers = indm2 ;
numindivs = numind2 ;
}
if (deletedup) dedupit(snpmarkers, numsnps) ; // only one marker per position
for (i=0; i<numsnps; i++) {
cupt = snpmarkers[i] ;
if (zerodistance) cupt -> genpos = 0.0 ;
c1 = cupt -> alleles[0] ;
c2 = cupt -> alleles[1] ;
t1 = pedval(&c1) % 5 ;
t2 = pedval(&c2) % 5 ; // 0 and 5 are no good
if ((t1==0) && (t2 >0)) flip1(cupt, phasedmode, YES) ;
}
flipstrand(flipstrandname, snpmarkers, numsnps) ;
flipsnps(flipsnpname, snpmarkers, numsnps, phasedmode) ;
if (polarindex>=0) {
for (i=0; i<numsnps; i++) {
cupt = snpmarkers[i] ;
g = getgtypes(cupt, polarindex) ;
if (g==0) {
printf("polarizing %s\n", cupt -> ID) ;
flip1(cupt, NO, YES) ;
g = getgtypes(cupt, polarindex) ;
if (g!=2) fatalx("badbug\n") ;
}
if (g != 2) cupt -> ignore = YES ;
}
}
if (outputall) {
outfiles(snpoutfilename, indoutfilename, genooutfilename,
snpmarkers, indivmarkers, numsnps, numindivs, packout, ogmode) ;
printf("##end of convertf run (outputall mode)\n") ;
return 0 ;
}
if (poplistname != NULL)
{
ZALLOC(eglist, numindivs, char *) ;
numeg = loadlist(eglist, poplistname) ;
seteglist(indivmarkers, numindivs, poplistname);
for (i=0; i<numindivs; ++i) {
indx = indivmarkers[i] ;
if (indx -> affstatus == NO) indx -> ignore = YES ;
}
}
else
setstatus(indivmarkers, numindivs, "Case") ;
numsnps = rmsnps(snpmarkers, numsnps, deletesnpoutname) ;
numindivs = rmindivs(snpmarkers, numsnps, indivmarkers, numindivs) ;
if (killr2) {
nkill = killhir2(snpmarkers, numsnps, numindivs, r2physlim, r2genlim, r2thresh) ;
if (nkill>0) printf("killhir2. number of snps killed: %d\n", nkill) ;
}
if ( nhwfilter > 0 ) {
hwfilter(snpmarkers, numsnps, numindivs, nhwfilter, deletesnpoutname);
}
if ( xregionname ) {
excluderegions(xregionname, snpmarkers, numsnps, deletesnpoutname);
}
numvalidind = 0 ;
for (i=0; i<numindivs; ++i) {
indx = indivmarkers[i] ;
if (indx -> ignore) continue ;
if (numvalidgtind(snpmarkers, numsnps, i) ==0) {
indx -> ignore = YES ;
printf("no data for individual: %s\n", indx -> ID) ;
}
if (indx -> ignore == NO) ++numvalidind ;
}
if (maxmiss<0) maxmiss = (int) (maxmissfrac * (double) numvalidind+1) ;
printf("numvalidind: %5d maxmiss: %5d\n", numvalidind, maxmiss) ;
if (numvalidind == 0) fatalx("no valid samples!\n") ;
for (k=0; k<numsnps; ++k) {
if (maxmiss>numvalidind) break ;
cupt = snpmarkers[k] ;
t = numvalidind - numvalidgtypes(cupt) ;
// printf("zz %20s %4d %4d\n", cupt -> ID, t, numvalidind-t) ;
if (maxmiss < t) {
cupt -> ignore = YES ;
}
/**
if (numvalidind == t) {
printf("no data for snp: %s\n", cupt -> ID) ;
cupt -> ignore = YES ;
}
*/
}
if (fastdup) {
printf("fastdup set %d\n", fastdupnum) ;
if (fastdupnum > 0) {
setfastdupnum(fastdupnum) ;
setfastdupthresh(fastdupthresh, fastdupkill) ;
fastdupcheck(snpmarkers, indivmarkers, numsnps, numindivs) ;
}
}
if (decim>0) {
snpdecimate(snpmarkers, numsnps, decim, dmindis, dmaxdis) ;
}
outfiles(snpoutfilename, indoutfilename, genooutfilename,
snpmarkers, indivmarkers, numsnps, numindivs, packout, ogmode) ;
printf("##end of convertf run\n") ;
return 0 ;
}
int
main (int argc, char **argv)
{
int rc;
char *pt;
char *bversion;
FILE *pidfile,*conffile;
if(argc==2)
{
strmncpy(configfile,argv[1],sizeof(configfile));
} else {
strcpy(configfile,"psybnc.conf"); /* rcsid */
}
conffile=fopen(configfile,"r");
if(conffile==NULL)
{
printf("Configuration File %s not found, aborting\nRun 'make menuconfig' for creating a configuration or create the file manually.\n",configfile); /* rcsid */
exit (0x0);
}
fclose(conffile);
readconfig();
rc = getini("SYSTEM","LANGUAGE",INIFILE); /* rcsid */
if(rc!=0)
{
rc=loadlanguage("english"); /* rcsid */
} else {
rc=loadlanguage(value);
if(rc<0)
rc=loadlanguage("english"); /* rcsid */
}
if(rc<0)
{
printf("Could not load language file, aborting.\n"); /* rcsid */
exit(0x0);
}
printbanner();
printf(lngtxt(991),configfile);
printf(lngtxt(992),langname);
ap_snprintf(logfile,sizeof(logfile),lngtxt(993));
rc = getini(lngtxt(994),lngtxt(995),INIFILE);
if (rc != 0) {
printf("%s", lngtxt(996));
exit (0x0);
}
listenport = atoi(value);
rc = getini(lngtxt(997),"ME",INIFILE);
if (rc < 0) {
memset(value,0x0,sizeof(value));
}
pt=strchr(value,' '); /* shortening bouncername to no spaces */
if(pt)
*pt=0;
ap_snprintf(me,sizeof(me),"%s",value);
rc = getini(lngtxt(998),lngtxt(999),INIFILE);
if (rc < 0) {
printf("%s", lngtxt(1000));
ap_snprintf(value,sizeof(value),lngtxt(1001));
}
ap_snprintf(logfile,sizeof(logfile),"%s",value);
oldfile(logfile);
/* creating the socket-root */
socketnode=(struct socketnodes *) pmalloc(sizeof(struct usernodes));
socketnode->sock=NULL;
socketnode->next=NULL;
#ifdef IPV6
/* set the default ipv6 preference for users without a PREFERIPV6 setting */
rc = getini("SYSTEM", "DEFAULTIPV6", INIFILE);
if (rc == 0)
{
defaultipv6 = atoi(value);
}
#endif
/* creating the demon socket */
rc = createlisteners();
if (rc == 0) {
printf("%s", lngtxt(1002));
exit (0x0);
}
/* creating background */
pidfile = fopen(lngtxt(1003),"w");
if(pidfile==NULL)
{
printf("%s", lngtxt(1004));
exit(0x0);
}
if(mainlog!=NULL)
{
fclose(mainlog);
mainlog=NULL;
}
fflush(stdout);
pid = fork();
//pid = 0;
if (pid < 0) {
}
if (pid == 0) {
rc= errorhandling();
makesalt();
#ifdef HAVE_SSL
initSSL();
pcontext;
#endif
U_CREATE=0;
#ifdef PARTYCHANNEL
/* partychannel setup */
strmncpy(partytopic,lngtxt(1005),sizeof(partytopic));
partyusers=NULL;
#endif
/* creating the usernode-root */
usernode=(struct usernodes *) pmalloc(sizeof(struct usernodes));
usernode->uid=0;
usernode->user=NULL;
usernode->next=NULL;
/* creating the newpeer-root */
peernode=(struct peernodes *) pmalloc(sizeof(struct peernodes));
peernode->uid=0;
peernode->peer=NULL;
peernode->next=NULL;
/* creating the datalink-root */
linknode=(struct linknodes *) pmalloc(sizeof(struct linknodes));
linknode->uid=0;
linknode->link=NULL;
linknode->next=NULL;
/* loading the users */
loadusers();
loadlinks();
pcontext;
/* loading the hostallows */
hostallows=loadlist(lngtxt(1006),hostallows);
}
pcontext;
if (pid) {
bversion=buildversion();
printf(lngtxt(1007),bversion,pid);
p_log(LOG_INFO,-1,lngtxt(1008),bversion,pid);
fprintf( pidfile,"%d\n",pid);
fclose(pidfile);
exit (0x0);
}
pcontext;
//#ifndef BLOCKDNS
// if(init_dns_core()==0)
// {
// dns_err(0,1);
// }
//#endif
p_dns_init();
bncmain();
return 0x0;
}
