notpron

BasePair.d (4771B)

---

 import std.stdio;
 import std.range;
 import std.algorithm;
 
 
 static immutable AminoAcid.Desc aD[]=[
 	AminoAcid.Desc("Alanine", "Ala", 'A'),
 	AminoAcid.Desc("Cyxteine", "Cys", 'C'),
 	AminoAcid.Desc("Aspartic acid", "Asp", 'D'),
 	AminoAcid.Desc("Glutamic acid", "Glu", 'E'),
 	AminoAcid.Desc("Phenylalanine", "Phe", 'F'),
 	AminoAcid.Desc("Glycine", "Gly", 'G'),
 	AminoAcid.Desc("Histidine", "His", 'H'),
 	AminoAcid.Desc("Isoleucine", "Ile", 'I'),
 	AminoAcid.Desc("Lysine", "Lys", 'K'),
 	AminoAcid.Desc("Leucine", "Leu", 'L'),
 	AminoAcid.Desc("Methionine", "Met", 'M'),
 	AminoAcid.Desc("Asparagine", "Asn", 'N'),
 	AminoAcid.Desc("Proline", "Pro", 'P'),
 	AminoAcid.Desc("Glutamine", "Gln", 'Q'),
 	AminoAcid.Desc("Arginine", "Arg", 'R'),
 	AminoAcid.Desc("Serine", "Ser", 'S'),
 	AminoAcid.Desc("Threonine", "Thr", 'T'),
 	AminoAcid.Desc("Valine", "Val", 'V'),
 	AminoAcid.Desc("Tryptophan", "Trp", 'W'),
 	AminoAcid.Desc("Tyrosine", "Tyr", 'Y'),
 ];
 immutable(AminoAcid.Desc)* findAA(char shortcut){
 	auto res=aD.assumeSorted.find!"a.shortcut==b"(shortcut);
 	if(res.empty){
 		return null;
 	}
 	return &(res.front());
 }
 
 struct AminoAcid{
 	struct Desc{
 		string longname;
 		string shortname;
 		char shortcut;
 	}
 	immutable(AminoAcid.Desc) *desc;
 	bool start;
 	bool stop;
 	this(char sname, bool start=false, bool stop=false){
 		desc=findAA(sname);
 		this.start=start;
 		this.stop=stop;
 	}
 	string toString(bool shrt=true){
 		if(start){
 			return "START";
 		}
 		else if(stop){
 			return "STOP";
 		}
 		else if(desc==null)
 			return "*";
 		return (shrt) ? desc.shortname : desc.longname;
 	}
 	char toChar(){
 		if(desc==null)
 			return ' ';
 		return desc.shortcut;
 	}
 }
 
 struct AminoAcidTable{
 	private immutable static char[] AminoAcids	= "FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG";
 	private immutable static char[] Starts = "---M---------------M---------------M----------------------------";
 	private immutable static char[] Base1  = "TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG";
 	private immutable static char[] Base2  = "TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG";
 	private immutable static char[] Base3  = "TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG";
 
 	AminoAcid table[char[3]];
 	void initialize(){
 		char am[3];
 		AminoAcid ac;
 		for(uint i=0; i<AminoAcids.length; i++){
 			am[0]=Base1[i];
 			am[1]=Base2[i];
 			am[2]=Base3[i];
 			table[am]=AminoAcid(AminoAcids[i],(Starts[i]!='-'),(AminoAcids[i]=='*'));
 		}
 	}
 	
 	AminoAcid* opIndex(in DNS.Codon c){
 		return (c.c in table);
 	}
 	
 	AminoAcid* opIndex(in RNS.Codon c){
 		return opIndex(c.dns);
 	}
 	
 	auto opCall(Range)(Range r) if(isInputRange!Range && (is(ElementType!Range == RNS.Codon) || is(ElementType!Range == DNS.Codon))){
 		return r.map!(a=>*this[a]);
 	}
 	
 	auto opCall(in DNS d){
 		return d.seq.map!(a=>*this[a]);
 	}
 	auto opCall(in RNS d){
 		return d.seq.map!(a=>*this[a]);
 	}
 }
 template CodonSeq(){
 	struct Codon{
 		char[3]c;
 		this(char[3] c){
 			this.c=c;
 		}
 		this(Range)(Range r){
 			foreach(i; 0..3){
 				c[i]=cast(char)r.front;
 				r.popFront();
 			}
 		}
 	}
 }
 ///Swaps A with B and C with A
 void BaseSwap(ref char str[3], in char A, in char B, in char C){
 	foreach(ref c; str){
 		if(c==A){
 			c=B;
 		}
 		else if(c==C){
 			c=A;
 		}
 	}
 }
 ///Swaps A with B and vice versa
 void BaseSwap(ref char str[3], in char A, in char B){
 	foreach(ref c; str){
 		if(c==A){
 			c=B;
 		}
 		else if(c==B){
 			c=A;
 		}
 	}
 }
 
 RNS.Codon rns(in DNS.Codon d){
 	RNS.Codon c=RNS.Codon(d.c);
 	c.c.BaseSwap('A','U','T');
 	c.c.BaseSwap('G','C');
 	return c;
 }
 DNS.Codon dns(in RNS.Codon d){
 	DNS.Codon c=DNS.Codon(d.c);
 	c.c.BaseSwap('A','T','U');
 	c.c.BaseSwap('G','C');
 	return c;
 }
 
 struct DNS{
 	mixin CodonSeq;
 	Codon seq[];
 	this(Range)(Range r) if(isInputRange!Range && is(ElementType!Range==Codon)){
 		r.copy(seq.appender);
 	}
 	this(Range)(Range r) if(isInputRange!Range && isSomeChar!(ElementType!Range)){
 		foreach(s; r.chunks(3)){
 			seq~=Codon(s);
 		}
 	}
 	auto rns(){
 		return seq.map!(a=>a.rns);
 	}
 	auto aa(ref AminoAcidTable aat){
 		return aat(seq);
 	}
 }
 struct RNS{
 	mixin CodonSeq;
 	Codon seq[];
 	this(Range)(Range r) if(isInputRange!Range && isSomeChar!(ElementType!Range)){
 		foreach(s; r.chunks(3)){
 			seq~=Codon(s);
 		}
 	}
 	this(Range)(Range r) if(isInputRange!Range && is(ElementType!Range==Codon)){
 		auto app=appender(seq);
 		r.copy(app);
 		seq=app.data;
 	}
 	auto dns(){
 		return seq.map!(a=>a.dns);
 	}
 	auto aa(ref AminoAcidTable aat){
 		return aat(seq);
 	}
 }
 
 static AminoAcidTable aat;
 
 auto aaString(Range)(Range r){
 	return r.map!(a=>a.toChar());
 }
 auto aalString(Range)(Range r){
 	return r.map!(a=>a.toString()).joiner(",\t");
 }
 
 void main(string args[]){
 	aat.initialize();
 	DNS d=DNS(args[1]);
 	writeln(aat(d).aaString());
 }