2014-02-07 13:08:32 -06:00
|
|
|
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
|
2012-12-10 19:32:48 -06:00
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2014-02-07 13:08:32 -06:00
|
|
|
// ignore-android: FIXME(#10393)
|
2013-11-09 21:02:23 -06:00
|
|
|
|
2014-02-07 13:08:32 -06:00
|
|
|
// ignore-pretty the `let to_child` line gets an extra newline
|
2012-07-06 17:15:52 -05:00
|
|
|
// multi tasking k-nucleotide
|
|
|
|
|
2014-02-19 21:29:58 -06:00
|
|
|
extern crate collections;
|
2013-05-24 21:35:29 -05:00
|
|
|
|
2014-02-19 21:29:58 -06:00
|
|
|
use collections::HashMap;
|
2014-01-31 14:35:36 -06:00
|
|
|
use std::mem::replace;
|
2013-05-24 21:35:29 -05:00
|
|
|
use std::option;
|
|
|
|
use std::os;
|
2014-04-02 18:54:22 -05:00
|
|
|
use std::strbuf::StrBuf;
|
2012-07-06 17:15:52 -05:00
|
|
|
|
2013-12-19 21:42:00 -06:00
|
|
|
fn f64_cmp(x: f64, y: f64) -> Ordering {
|
|
|
|
// arbitrarily decide that NaNs are larger than everything.
|
|
|
|
if y.is_nan() {
|
|
|
|
Less
|
|
|
|
} else if x.is_nan() {
|
|
|
|
Greater
|
|
|
|
} else if x < y {
|
|
|
|
Less
|
|
|
|
} else if x == y {
|
|
|
|
Equal
|
|
|
|
} else {
|
|
|
|
Greater
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-06 17:15:52 -05:00
|
|
|
// given a map, print a sorted version of it
|
2014-03-05 16:02:44 -06:00
|
|
|
fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> ~str {
|
2013-09-26 01:26:09 -05:00
|
|
|
fn pct(xx: uint, yy: uint) -> f64 {
|
|
|
|
return (xx as f64) * 100.0 / (yy as f64);
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// sort by key, then by value
|
2014-03-05 16:02:44 -06:00
|
|
|
fn sortKV(mut orig: Vec<(Vec<u8> ,f64)> ) -> Vec<(Vec<u8> ,f64)> {
|
2013-12-19 21:42:00 -06:00
|
|
|
orig.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
|
|
|
|
orig.sort_by(|&(_, a), &(_, b)| f64_cmp(b, a));
|
|
|
|
orig
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
|
2014-03-05 16:02:44 -06:00
|
|
|
let mut pairs = Vec::new();
|
2012-07-06 17:15:52 -05:00
|
|
|
|
|
|
|
// map -> [(k,%)]
|
2013-08-03 11:45:23 -05:00
|
|
|
for (key, &val) in mm.iter() {
|
2013-07-17 01:49:42 -05:00
|
|
|
pairs.push(((*key).clone(), pct(val, total)));
|
2013-02-02 13:47:41 -06:00
|
|
|
}
|
2012-07-06 17:15:52 -05:00
|
|
|
|
|
|
|
let pairs_sorted = sortKV(pairs);
|
2012-09-19 18:55:01 -05:00
|
|
|
|
2014-04-02 18:54:22 -05:00
|
|
|
let mut buffer = StrBuf::new();
|
2013-11-28 06:52:11 -06:00
|
|
|
for &(ref k, v) in pairs_sorted.iter() {
|
2014-04-10 05:55:34 -05:00
|
|
|
buffer.push_str(format!("{} {:0.3f}\n",
|
|
|
|
k.as_slice()
|
|
|
|
.to_ascii()
|
|
|
|
.to_upper()
|
|
|
|
.into_str(), v));
|
2012-09-19 18:55:01 -05:00
|
|
|
}
|
2012-07-06 17:15:52 -05:00
|
|
|
|
2014-04-10 05:55:34 -05:00
|
|
|
return buffer.into_owned();
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// given a map, search for the frequency of a pattern
|
2014-03-05 16:02:44 -06:00
|
|
|
fn find(mm: &HashMap<Vec<u8> , uint>, key: ~str) -> uint {
|
2013-11-07 01:59:40 -06:00
|
|
|
let key = key.into_ascii().to_lower().into_str();
|
2013-06-10 22:10:37 -05:00
|
|
|
match mm.find_equiv(&key.as_bytes()) {
|
2012-08-20 14:23:37 -05:00
|
|
|
option::None => { return 0u; }
|
2013-03-23 20:22:00 -05:00
|
|
|
option::Some(&num) => { return num; }
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// given a map, increment the counter for a key
|
2014-03-05 16:02:44 -06:00
|
|
|
fn update_freq(mm: &mut HashMap<Vec<u8> , uint>, key: &[u8]) {
|
2014-03-05 17:28:08 -06:00
|
|
|
let key = Vec::from_slice(key);
|
2013-03-23 20:22:00 -05:00
|
|
|
let newval = match mm.pop(&key) {
|
|
|
|
Some(v) => v + 1,
|
|
|
|
None => 1
|
|
|
|
};
|
|
|
|
mm.insert(key, newval);
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
|
2014-03-05 17:28:08 -06:00
|
|
|
// given a Vec<u8>, for each window call a function
|
2012-07-06 17:15:52 -05:00
|
|
|
// i.e., for "hello" and windows of size four,
|
|
|
|
// run it("hell") and it("ello"), then return "llo"
|
2014-03-05 16:02:44 -06:00
|
|
|
fn windows_with_carry(bb: &[u8], nn: uint, it: |window: &[u8]|) -> Vec<u8> {
|
2012-07-06 17:15:52 -05:00
|
|
|
let mut ii = 0u;
|
|
|
|
|
2013-05-14 04:52:12 -05:00
|
|
|
let len = bb.len();
|
2012-07-06 17:15:52 -05:00
|
|
|
while ii < len - (nn - 1u) {
|
2013-06-27 04:48:50 -05:00
|
|
|
it(bb.slice(ii, ii+nn));
|
2012-07-06 17:15:52 -05:00
|
|
|
ii += 1u;
|
|
|
|
}
|
|
|
|
|
2014-03-05 17:28:08 -06:00
|
|
|
return Vec::from_slice(bb.slice(len - (nn - 1u), len));
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
|
2013-04-22 23:19:58 -05:00
|
|
|
fn make_sequence_processor(sz: uint,
|
2014-03-05 16:02:44 -06:00
|
|
|
from_parent: &Receiver<Vec<u8>>,
|
2014-03-09 16:58:32 -05:00
|
|
|
to_parent: &Sender<~str>) {
|
2014-03-05 16:02:44 -06:00
|
|
|
let mut freqs: HashMap<Vec<u8>, uint> = HashMap::new();
|
|
|
|
let mut carry = Vec::new();
|
2012-07-06 17:15:52 -05:00
|
|
|
let mut total: uint = 0u;
|
|
|
|
|
2014-03-05 17:28:08 -06:00
|
|
|
let mut line: Vec<u8>;
|
2012-07-06 17:15:52 -05:00
|
|
|
|
|
|
|
loop {
|
|
|
|
|
|
|
|
line = from_parent.recv();
|
2014-03-05 16:02:44 -06:00
|
|
|
if line == Vec::new() { break; }
|
2012-07-06 17:15:52 -05:00
|
|
|
|
2014-03-30 22:53:26 -05:00
|
|
|
carry = windows_with_carry(carry.append(line.as_slice()).as_slice(),
|
2014-03-05 17:28:08 -06:00
|
|
|
sz,
|
|
|
|
|window| {
|
2013-03-23 20:22:00 -05:00
|
|
|
update_freq(&mut freqs, window);
|
2012-07-06 17:15:52 -05:00
|
|
|
total += 1u;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2013-02-01 01:13:36 -06:00
|
|
|
let buffer = match sz {
|
2013-03-23 20:22:00 -05:00
|
|
|
1u => { sort_and_fmt(&freqs, total) }
|
|
|
|
2u => { sort_and_fmt(&freqs, total) }
|
2013-09-30 01:13:47 -05:00
|
|
|
3u => { format!("{}\t{}", find(&freqs, ~"GGT"), "GGT") }
|
|
|
|
4u => { format!("{}\t{}", find(&freqs, ~"GGTA"), "GGTA") }
|
|
|
|
6u => { format!("{}\t{}", find(&freqs, ~"GGTATT"), "GGTATT") }
|
|
|
|
12u => { format!("{}\t{}", find(&freqs, ~"GGTATTTTAATT"), "GGTATTTTAATT") }
|
|
|
|
18u => { format!("{}\t{}", find(&freqs, ~"GGTATTTTAATTTATAGT"), "GGTATTTTAATTTATAGT") }
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => { ~"" }
|
2012-07-06 17:15:52 -05:00
|
|
|
};
|
|
|
|
|
2013-02-15 04:44:18 -06:00
|
|
|
to_parent.send(buffer);
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// given a FASTA file on stdin, process sequence THREE
|
2012-10-03 21:16:27 -05:00
|
|
|
fn main() {
|
2014-01-15 15:25:09 -06:00
|
|
|
use std::io::{stdio, MemReader, BufferedReader};
|
2012-07-06 17:15:52 -05:00
|
|
|
|
2013-10-06 18:08:56 -05:00
|
|
|
let rdr = if os::getenv("RUST_BENCH").is_some() {
|
2013-10-14 10:24:17 -05:00
|
|
|
let foo = include_bin!("shootout-k-nucleotide.data");
|
2014-03-27 00:46:25 -05:00
|
|
|
~MemReader::new(Vec::from_slice(foo)) as ~Reader
|
2013-10-06 18:08:56 -05:00
|
|
|
} else {
|
|
|
|
~stdio::stdin() as ~Reader
|
|
|
|
};
|
|
|
|
let mut rdr = BufferedReader::new(rdr);
|
2012-07-06 17:15:52 -05:00
|
|
|
|
2013-06-29 00:05:50 -05:00
|
|
|
// initialize each sequence sorter
|
2014-03-05 16:02:44 -06:00
|
|
|
let sizes = vec!(1u,2,3,4,6,12,18);
|
|
|
|
let mut streams = Vec::from_fn(sizes.len(), |_| Some(channel::<~str>()));
|
|
|
|
let mut from_child = Vec::new();
|
2014-03-09 16:58:32 -05:00
|
|
|
let to_child = sizes.iter().zip(streams.mut_iter()).map(|(sz, stream_ref)| {
|
2012-09-21 20:43:30 -05:00
|
|
|
let sz = *sz;
|
2014-01-31 14:35:36 -06:00
|
|
|
let stream = replace(stream_ref, None);
|
2014-03-09 16:58:32 -05:00
|
|
|
let (to_parent_, from_child_) = stream.unwrap();
|
2012-07-06 17:15:52 -05:00
|
|
|
|
2013-02-15 04:44:18 -06:00
|
|
|
from_child.push(from_child_);
|
2012-07-06 17:15:52 -05:00
|
|
|
|
2014-03-09 16:58:32 -05:00
|
|
|
let (to_child, from_parent) = channel();
|
2012-07-06 17:15:52 -05:00
|
|
|
|
2014-01-27 17:29:50 -06:00
|
|
|
spawn(proc() {
|
2013-04-26 16:04:39 -05:00
|
|
|
make_sequence_processor(sz, &from_parent, &to_parent_);
|
2014-01-27 17:29:50 -06:00
|
|
|
});
|
2013-02-01 01:13:36 -06:00
|
|
|
|
2013-02-15 04:44:18 -06:00
|
|
|
to_child
|
2014-03-05 16:02:44 -06:00
|
|
|
}).collect::<Vec<Sender<Vec<u8> >> >();
|
2013-02-01 01:13:36 -06:00
|
|
|
|
|
|
|
|
2012-07-06 17:15:52 -05:00
|
|
|
// latch stores true after we've started
|
|
|
|
// reading the sequence of interest
|
|
|
|
let mut proc_mode = false;
|
|
|
|
|
2013-12-08 01:12:07 -06:00
|
|
|
for line in rdr.lines() {
|
2014-02-19 20:53:46 -06:00
|
|
|
let line = line.unwrap().trim().to_owned();
|
2013-10-17 23:08:48 -05:00
|
|
|
|
|
|
|
if line.len() == 0u { continue; }
|
|
|
|
|
|
|
|
match (line[0] as char, proc_mode) {
|
|
|
|
|
|
|
|
// start processing if this is the one
|
|
|
|
('>', false) => {
|
|
|
|
match line.slice_from(1).find_str("THREE") {
|
|
|
|
option::Some(_) => { proc_mode = true; }
|
|
|
|
option::None => { }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// break our processing
|
|
|
|
('>', true) => { break; }
|
|
|
|
|
|
|
|
// process the sequence for k-mers
|
|
|
|
(_, true) => {
|
|
|
|
let line_bytes = line.as_bytes();
|
|
|
|
|
|
|
|
for (ii, _sz) in sizes.iter().enumerate() {
|
2014-03-05 17:28:08 -06:00
|
|
|
let lb = Vec::from_slice(line_bytes);
|
|
|
|
to_child.get(ii).send(lb);
|
2013-10-17 23:08:48 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// whatever
|
|
|
|
_ => { }
|
|
|
|
}
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// finish...
|
2013-10-17 23:08:48 -05:00
|
|
|
for (ii, _sz) in sizes.iter().enumerate() {
|
2014-03-05 17:28:08 -06:00
|
|
|
to_child.get(ii).send(Vec::new());
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// now fetch and print result messages
|
2013-10-17 23:08:48 -05:00
|
|
|
for (ii, _sz) in sizes.iter().enumerate() {
|
2014-03-05 17:28:08 -06:00
|
|
|
println!("{}", from_child.get(ii).recv());
|
2012-07-06 17:15:52 -05:00
|
|
|
}
|
|
|
|
}
|