Exemple #1
0
func main() {
	saveto := util.CreateFile(util.Arg(0))
	defer saveto.Close()

	w := func(format string, v ...interface{}) {
		_, err := fmt.Fprintf(saveto, format, v...)
		util.Assert(err)
	}

	var fmats []*bufio.Reader
	for _, fmat := range util.Args()[1:] {
		fmats = append(fmats, bufio.NewReader(util.OpenFile(fmat)))
	}
LOOP:
	for {
		var columns int
		scores := make([][]float64, len(fmats)) // matrix -> fields -> sas score
		for i, fmat := range fmats {
			line, err := fmat.ReadBytes('\n')
			if len(line) == 0 && err == io.EOF {
				break LOOP
			} else if err != io.EOF {
				util.Assert(err)
			}

			fields := bytes.Fields(line)
			columns = len(fields)
			scores[i] = make([]float64, columns)
			for j, sas := range fields {
				scores[i][j], err = strconv.ParseFloat(string(sas), 64)
				util.Assert(err)
			}
		}

		before := ""
		for j := 0; j < columns; j++ {
			best := scores[0][j]
			for i := 1; i < len(scores); i++ {
				if scores[i][j] < best {
					best = scores[i][j]
				}
			}
			if best == 0 {
				w("%s0", before)
			} else {
				w("%s%f", before, best)
			}
			before = " "
		}
		w("\n")
	}
}
Exemple #2
0
func main() {
	if len(util.FlagCpuProf) > 0 {
		f := util.CreateFile(util.FlagCpuProf)
		pprof.StartCPUProfile(f)
		defer f.Close()
		defer pprof.StopCPUProfile()
	}
	vectors := readVectors(util.Arg(1))
	groups := readCathGroups(util.Args()[2:])
	out := util.CreateFile(util.Arg(0))
	defer out.Close()

	pf := func(format string, v ...interface{}) {
		// fmt.Printf(format, v...)
		fmt.Fprintf(out, format, v...)
	}

	type labeledPval struct {
		Name1, Name2 string
		Pval         float32
	}
	b := stdb(vectors, groups)
	pairs := combinations(len(groups))
	dopairs, pvals := make(chan pair), make(chan labeledPval)
	wg := new(sync.WaitGroup)
	for i := 0; i < util.FlagCpu; i++ {
		wg.Add(1)
		go func() {
			for p := range dopairs {
				g1, g2 := groups[p.i], groups[p.j]
				b1, b2 := b[p.i], b[p.j]
				bm1, bm2 := bmean(b1, b2)
				bw := delta(bm1, bm2)

				randws := make([]float32, 1000)
				for i := range randws {
					randws[i] = delta(shuffle_mean_rows(b1, b2))
				}

				bigger := 0
				for _, rw := range randws {
					if rw >= bw {
						bigger++
					}
				}
				pval := float32(bigger) / float32(len(randws))
				pvals <- labeledPval{g1.Name, g2.Name, pval}
			}
			wg.Done()
		}()
	}

	done := make(chan struct{})
	go func() {
		sig, cutoff := 0, 0.05/float32(len(pairs))
		for pval := range pvals {
			if pval.Pval < cutoff {
				sig++
			}
			pf("%s\t%s\t%f\n", pval.Name1, pval.Name2, pval.Pval)
		}
		pf("significant\t%d/%d\t(cutoff: %f)\n", sig, len(pairs), cutoff)
		done <- struct{}{}
	}()
	for _, p := range pairs {
		dopairs <- p
	}
	close(dopairs)
	wg.Wait()
	close(pvals)
	<-done
}
Exemple #3
-1
func main() {
	outDir := util.Arg(0)
	fasInps := util.Args()[1:]

	util.Assert(os.MkdirAll(outDir, 0777))

	fastaChan := make(chan string)
	wg := new(sync.WaitGroup)
	for i := 0; i < max(1, runtime.GOMAXPROCS(0)); i++ {
		go func() {
			wg.Add(1)
			for fasta := range fastaChan {
				util.Verbosef("Computing map for '%s'...", fasta)
				fmap := util.GetFmap(fasta)
				outF := path.Join(outDir, fmt.Sprintf("%s.fmap", fmap.Name))
				util.FmapWrite(util.CreateFile(outF), fmap)
			}
			wg.Done()
		}()
	}

	for _, fasta := range fasInps {
		fastaChan <- fasta
	}

	close(fastaChan)
	wg.Wait()
}