void print(int argc,char **argv){
if(argc<1){
fprintf(stderr,"\t-> Must supply afile.saf.idx files \n");
fprintf(stderr,"\t-> Examples \n");
fprintf(stderr,"\t-> ./ngsPSMC print pop1.saf.idx \n");
fprintf(stderr,"\t-> ./ngsPSMC print pop1.saf.idx -r chr1:10000000-12000000\n");
return;
}
args *pars = getArgs(argc,argv);
writepsmc_header(stderr,pars->perc);
for(myMap::iterator it=pars->perc->mm.begin();it!=pars->perc->mm.end();++it){
if(pars->chooseChr!=NULL)
it = iter_init(pars->perc,pars->chooseChr,pars->start,pars->stop);
else
it = iter_init(pars->perc,it->first,pars->start,pars->stop);
for(size_t s=pars->perc->first;s<pars->perc->last;s++)
fprintf(stdout,"%s\t%d\t%e\t%e\n",it->first,pars->perc->pos[s]+1,pars->perc->gls[2*s],pars->perc->gls[2*s+1]);
if(pars->chooseChr!=NULL)
break;
}
destroy_args(pars);
}
void _set_track_val_list(track_ctx_t *trackctx,
list_t *bindings,
byte_t *val_list,
size_t *list_sz)
{
list_iterator_t iter_binding, iter_track;
uint_t idx;
track_ctx_t *trackctx_ptr = NULL;
binding_t *binding = NULL;
memset(val_list, 0, 256);
for (iter_init(&iter_binding, bindings), idx = 0;
iter_node(&iter_binding);
iter_next(&iter_binding))
{
binding = iter_node_ptr(&iter_binding);
for (iter_init(&iter_track, &(binding->tracks));
iter_node(&iter_track);
iter_next(&iter_track))
{
trackctx_ptr = iter_node_ptr(&iter_track);
if (trackctx == trackctx_ptr)
{
val_list[idx] = binding->val;
idx++;
break;
}
}
}
*list_sz = idx;
}
int makeold(int argc,char **argv){
if(argc<1){
fprintf(stderr,"\t-> output is a vcf2fq style file \n");
return 0;
}
args *pars = getArgs(argc,argv);
writepsmc_header(stderr,pars->perc);
double *gls = new double[2*pars->perc->nSites];
size_t at=0;
//first pull all the data
for(myMap::iterator it=pars->perc->mm.begin();it!=pars->perc->mm.end();++it){
if(pars->chooseChr!=NULL)
it = iter_init(pars->perc,pars->chooseChr,pars->start,pars->stop);
else
it = iter_init(pars->perc,it->first,pars->start,pars->stop);
// fprintf(stderr,"it->first:%s\tlast:%lu\n",it->first,pars->perc->last);
memcpy(gls+at,pars->perc->gls,sizeof(double)*2*pars->perc->last);
at += pars->perc->last;
if(pars->chooseChr!=NULL)
break;
}
double opt = 0.01;
double llh = em(opt,gls,at,1e-8);
fprintf(stderr,"estimated het:%f with llh:%f\n",opt,llh);
delete [] gls;
kstring_t kstr;kstr.l=kstr.m=0;kstr.s=NULL;
for(myMap::iterator it=pars->perc->mm.begin();it!=pars->perc->mm.end();++it){
if(pars->chooseChr!=NULL)
it = iter_init(pars->perc,pars->chooseChr,pars->start,pars->stop);
else
it = iter_init(pars->perc,it->first,pars->start,pars->stop);
ksprintf(&kstr,">%s\n",it->first);
double *pp = new double[pars->perc->last];
calcpost(opt,pars->perc->gls,pars->perc->last,pp);
writefa(&kstr,pp,pars->perc->last,100,50,0.9);
if(kstr.l>0&&kstr.s[kstr.l-1]!='\n')
ksprintf(&kstr,"\n");
fwrite(kstr.s,sizeof(char),kstr.l,stdout);
kstr.l=0;
delete [] pp;
if(pars->chooseChr!=NULL)
break;
}
free(kstr.s);
/*
break;
*/
return 0;
}
void print(int argc,char **argv){
if(argc<1){
fprintf(stderr,"\t-> Must supply afile.saf.idx files \n");
fprintf(stderr,"\t-> Examples \n");
fprintf(stderr,"\t-> ./realSFS print pop1.saf.idx \n");
fprintf(stderr,"\t-> ./realSFS print pop1.saf.idx -r chr1:10000000-12000000\n");
fprintf(stderr,"\t-> ./realSFS print pop1.saf.idx pop2.saf.idx -r chr2:10000000-12000000\n");
fprintf(stderr,"\t-> You can generate the oldformat by appending the -oldout 1 to the print command like\n");
fprintf(stderr,"\t-> ./realSFS print pop1.saf.idx pop2.saf.idx -oldout 1\n");
return;
}
args *pars = getArgs(argc,argv);
for(int i=0;i<pars->saf.size();i++)
pars->saf[0]->kind = 2;
if(1||pars->saf.size()!=1){
fprintf(stderr,"\t-> Will jump to multisaf printer and will only print intersecting sites between populations\n");
printMulti<T>(pars);
return;
}
writesaf_header(stderr,pars->saf[0]);
float *flt = new float[pars->saf[0]->nChr+1];
for(myMap::iterator it=pars->saf[0]->mm.begin();it!=pars->saf[0]->mm.end();++it){
if(pars->chooseChr!=NULL)
it = iter_init(pars->saf[0],pars->chooseChr,pars->start,pars->stop);
else
it = iter_init(pars->saf[0],it->first,pars->start,pars->stop);
size_t ret;
int pos;
while((ret=iter_read(pars->saf[0],flt,sizeof(float)*(pars->saf[0]->nChr+1),&pos))){
fprintf(stdout,"%s\t%d",it->first,pos+1);
for(int is=0;is<pars->saf[0]->nChr+1;is++)
fprintf(stdout,"\t%f",flt[is]);
fprintf(stdout,"\n");
}
if(pars->chooseChr!=NULL)
break;
}
delete [] flt;
destroy_args(pars);
}
void write_midifile_track_engine_ctx(int fd, engine_ctx_t *ctx)
{
list_iterator_t iter;
output_t *output;
buf_node_t head = {NULL, 0, NULL};
buf_node_t *node;
uint_t idx = 0;
for (iter_init(&iter, &(ctx->output_list)),
node = &head,
idx = 0;
iter_node(&iter);
iter_next(&iter),
idx++)
{
output = iter_node_ptr(&iter);
node = _append_sysex_port(node, output, idx);
}
node = _append_metaev_set_tempo(node, ctx->tempo);
/* node = _append_metaev_eot(node); */
_append_metaev_eot(node);
node = get_midifile_trackhdr(get_buf_list_size(head.next));
node->next = head.next;
write_buf_list(fd, node);
free_buf_list(node);
}
void dump_track(track_t *track)
{
list_iterator_t tickit;
output("track \"%s\" got %d tick event(s)\n", track->name, track->tickev_list.len);
for (iter_init(&tickit, &(track->tickev_list));
iter_node(&tickit) != NULL;
iter_next(&tickit))
dump_tickev((tickev_t *) iter_node_ptr(&tickit));
}
void dump_tickev(tickev_t *tickev)
{
list_iterator_t seqevit;
output("At tick %d %s got %d event(s)\n",
tickev->tick,
tickev->deleted == TRUE ? "(\033[31mdeleted\033[0m)" : "(not deleted)",
tickev->seqev_list.len);
for (iter_init(&seqevit, &(tickev->seqev_list));
iter_node(&seqevit) != NULL;
iter_next(&seqevit))
dump_seqev((seqev_t *) iter_node_ptr(&(seqevit)));
}
uint_t _seqev_len(tickev_t *tickev)
{
list_iterator_t seqevit;
seqev_t *ev = NULL;
uint_t len = 0;
for (iter_init(&seqevit, &(tickev->seqev_list));
iter_node(&seqevit) != NULL;
iter_next(&seqevit))
{
ev = (seqev_t *) iter_node_ptr(&seqevit);
if (ev->deleted == FALSE)
len++;
}
return len;
}
int_t get_outputid(list_t *output_list, output_t *output)
{
list_iterator_t iter;
output_t *tmp;
int_t idx;
for (iter_init(&iter, output_list),
idx = 0;
iter_node(&iter);
iter_next(&iter),
idx++)
{
tmp = iter_node_ptr(&iter);
if (tmp == output)
return idx;
}
return -1;
}
void engine_save_project(engine_ctx_t *ctx, char *file_path)
{
int fd;
list_iterator_t iter;
track_ctx_t *trackctx = NULL;
midifile_track_t mtrack;
if (ctx->track_list.len > 0)
{
if (0 == access(file_path, F_OK))
unlink(file_path);
debug("start of write");
fd = open(file_path, O_WRONLY|O_CREAT, (S_IRUSR|S_IWUSR
| S_IRGRP|S_IWGRP
| S_IROTH|S_IWOTH));
if (fd == -1)
{
output_error("problem while open file to save (%s)\n",
strerror(errno));
return;
}
write_midifile_header(fd, ctx->track_list.len + 1, ctx->ppq);
write_midifile_track_engine_ctx(fd, ctx);
for (iter_init(&iter, &(ctx->track_list));
iter_node(&iter);
iter_next(&iter))
{
trackctx = iter_node_ptr(&iter);
set_midifile_track(trackctx, &mtrack);
write_midifile_track(fd, &mtrack);
}
close(fd);
}
debug("End of write\n\n\n");
}
void
_cairo_contour_simplify (cairo_contour_t *contour, double tolerance)
{
cairo_contour_chain_t *chain;
cairo_point_t *last = NULL;
cairo_contour_iter_t iter, furthest;
cairo_bool_t simplified;
uint64_t max = 0;
int i;
if (contour->chain.num_points <= 2)
return;
tolerance = tolerance * CAIRO_FIXED_ONE;
tolerance *= tolerance;
/* stage 1: vertex reduction */
for (chain = &contour->chain; chain; chain = chain->next) {
for (i = 0; i < chain->num_points; i++) {
if (last == NULL ||
point_distance_sq (last, &chain->points[i]) > tolerance) {
last = &chain->points[i];
} else {
MARK_DELETED (&chain->points[i]);
}
}
}
/* stage2: polygon simplification using Douglas-Peucker */
simplified = FALSE;
do {
last = &contour->chain.points[0];
iter_init (&furthest, contour);
max = 0;
for (chain = &contour->chain; chain; chain = chain->next) {
for (i = 0; i < chain->num_points; i++) {
uint64_t d;
if (DELETED (&chain->points[i]))
continue;
d = point_distance_sq (last, &chain->points[i]);
if (d > max) {
furthest.chain = chain;
furthest.point = &chain->points[i];
max = d;
}
}
}
assert (max);
simplified = FALSE;
iter_init (&iter, contour);
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
&iter, &furthest);
iter_init_last (&iter, contour);
if (! iter_equal (&furthest, &iter))
simplified |= _cairo_contour_simplify_chain (contour, tolerance,
&furthest, &iter);
} while (simplified);
iter_init (&iter, contour);
for (chain = &contour->chain; chain; chain = chain->next) {
int num_points = chain->num_points;
chain->num_points = 0;
for (i = 0; i < num_points; i++) {
if (! DELETED(&chain->points[i])) {
if (iter.point != &chain->points[i])
*iter.point = chain->points[i];
iter.chain->num_points++;
iter_next (&iter);
}
}
}
if (iter.chain) {
cairo_contour_chain_t *next;
for (chain = iter.chain->next; chain; chain = next) {
next = chain->next;
free (chain);
}
iter.chain->next = NULL;
contour->tail = iter.chain;
}
}
int
check_cg_pc (int n,
int it_max, double it_eps,
int verbose, double tiny)
{
if (verbose != 0)
{
fprintf (stdout,
"==================================================\n"
"check_cg_pc(n=%d): start\n", n);
}
int check = 0;
double max = 0.0;
double *a = (double *)malloc (sizeof (double) * n * n);
double *b = (double *)malloc (sizeof (double) * n);
double *x = (double *)malloc (sizeof (double) * n);
double *x_ = (double *)malloc (sizeof (double) * n);
double *lu = (double *)malloc (sizeof (double) * n * n);
CHECK_MALLOC (a, "check_cg_pc");
CHECK_MALLOC (b, "check_cg_pc");
CHECK_MALLOC (x, "check_cg_pc");
CHECK_MALLOC (x_, "check_cg_pc");
CHECK_MALLOC (lu, "check_cg_pc");
// symmetric matrix
int i, j;
for (i = 0; i < n; i ++)
{
a[i * n + i] = (double)(i+1);
for (j = i+1; j < n; j ++)
{
a[i * n + j] = 1.0/(double)(i+j);
a[j * n + i] = 1.0/(double)(i+j);
}
}
srand48(0);
for (i = 0; i < n; i ++)
{
b[i] = drand48();
}
struct iter *it
= iter_init ("cg", it_max, 0, it_eps, // solver param
n, NULL, 0, // guess
0, NULL); // debug info
CHECK_MALLOC (it, "check_cg_pc");
char label[80];
// cg_
for (i = 0; i < n; i ++)
{
x[i] = 0.0;
}
double t0 = ptime_ms_d ();
cg_ (n, b, x,
local_atimes, (void *)a,
it);
double t1 = ptime_ms_d ();
if (verbose != 0)
{
fprintf (stdout, "cg_ "
"iter = %d, res = %e, CPU time = %f\n",
it->niter, sqrt(it->res2), t1 - t0);
}
// cg_pc with inv_diag()
for (i = 0; i < n; i ++)
{
x_[i] = 0.0;
}
t0 = ptime_ms_d ();
cg_pc (n, b, x_,
local_atimes, (void *)a,
inv_diag, (void *)a,
it);
t1 = ptime_ms_d ();
if (verbose != 0)
{
fprintf (stdout, "cg_pc(diag) "
"iter = %d, res = %e, CPU time = %f\n",
it->niter, sqrt(it->res2), t1 - t0);
}
for (i = 0; i < n; i ++)
{
sprintf (label, "x[%d]", i);
check += compare_max (x[i], x_[i], label, verbose, tiny, &max);
}
// cg_pc with inv_ILU()
for (i = 0; i < n; i ++)
{
x_[i] = 0.0;
}
LU_Gauss (n, a, lu);
t0 = ptime_ms_d ();
cg_pc (n, b, x_,
local_atimes, (void *)a,
inv_ILU, (void *)lu,
it);
t1 = ptime_ms_d ();
if (verbose != 0)
{
fprintf (stdout, "cg_pc(LU) "
"iter = %d, res = %e, CPU time = %f\n",
it->niter, sqrt(it->res2), t1 - t0);
}
for (i = 0; i < n; i ++)
{
sprintf (label, "x[%d]", i);
check += compare_max (x[i], x_[i], label, verbose, tiny, &max);
}
iter_free (it);
free (a);
free (b);
free (x);
free (x_);
free (lu);
if (verbose != 0)
{
fprintf (stdout, " max error = %e vs tiny = %e\n", max, tiny);
if (check == 0) fprintf (stdout, " => PASSED\n\n");
else fprintf (stdout, " => FAILED\n\n");
}
return (check);
}
/*@null@*/ iter_t list_head(list_t l) {
return iter_init(l->head);
}
int
main(int argc, const char *argv[])
{
iter_t iter;
const char *fname = NULL;
hid_t fid;
struct handler_t *hand;
H5F_info_t finfo;
/* Disable error reporting */
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
hand = parse_command_line (argc, argv);
if(!hand) {
error_msg(progname, "unable to parse command line arguments \n");
leave(EXIT_FAILURE);
} /* end if */
fname = argv[opt_ind];
printf("Filename: %s\n", fname);
fid = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
if(fid < 0) {
error_msg(progname, "unable to open file \"%s\"\n", fname);
leave(EXIT_FAILURE);
} /* end if */
/* Initialize iter structure */
iter_init(&iter, fid);
/* Get storge info for SOHM's btree/list/heap and superblock extension */
if(H5Fget_info(fid, &finfo) < 0)
warn_msg(progname, "Unable to retrieve SOHM info\n");
else {
iter.super_ext_size = finfo.super_ext_size;
iter.SM_hdr_storage_size = finfo.sohm.hdr_size;
iter.SM_index_storage_size = finfo.sohm.msgs_info.index_size;
iter.SM_heap_storage_size = finfo.sohm.msgs_info.heap_size;
} /* end else */
/* Walk the objects or all file */
if(display_object) {
unsigned u;
u = 0;
while(hand[u].obj) {
if (h5trav_visit(fid, hand[u].obj, TRUE, TRUE, obj_stats, lnk_stats, &iter) < 0)
warn_msg(progname, "Unable to traverse object \"%s\"\n", hand[u].obj);
else
print_statistics(hand[u].obj, &iter);
u++;
} /* end while */
} /* end if */
else {
if (h5trav_visit(fid, "/", TRUE, TRUE, obj_stats, lnk_stats, &iter) < 0)
warn_msg(progname, "Unable to traverse objects/links in file \"%s\"\n", fname);
else
print_statistics("/", &iter);
} /* end else */
if (hand) free(hand);
if(H5Fclose(fid) < 0) {
error_msg(progname, "unable to close file \"%s\"\n", fname);
leave(EXIT_FAILURE);
}
leave(EXIT_SUCCESS);
}
