Code improvement for DNA reverse complement?

[Biotronic via Digitalmars-d-learn]

On Friday, 19 May 2017 at 12:21:10 UTC, biocyberman wrote:
>
> 1. Why do we need to use assumeUnique in 'revComp0' and 
> 'revComp3'?

D strings are immutable, so if I'd created the result array as a 
string, I couldn't change the individual characters. Instead, I 
create a mutable array, change the elements in it, then cast it 
to immutable when I'm done. assumeUnique does that casting while 
keeping other type information and arguably providing better 
documentation through its name. Behind the scenes, it's basically 
doing cast(string)result;

> 2. What is going on with the trick of making chars enum like 
> that in 'revComp3'?

By marking a symbol enum, we tell the compiler that its value 
should be calculated at compile-time. It's a bit of an 
optimization (but probably doesn't matter at all, and should be 
done by the compiler anyway), and a way to say it's really, 
really const. :p

Mostly, it's a habit I try to build, of declaring symbols as 
const as possible, to make maintenance easier.


Bonus! Three more variations, all faster than revComp0:

string revComp4(string bps) {
     const N = bps.length;
     char[] result = new char[N];
     for (int i = 0; i < N; ++i) {
         switch(bps[N-i-1]) {
             case 'A': result[i] = 'T'; break;
             case 'C': result[i] = 'G'; break;
             case 'G': result[i] = 'C'; break;
             case 'T': result[i] = 'A'; break;
             default: assert(false);
         }
     }
     return result.assumeUnique;
}

string revComp5(string bps) {
     const N = bps.length;
     char[] result = new char[N];
     foreach (i, ref e; result) {
         switch(bps[N-i-1]) {
             case 'A': e = 'T'; break;
             case 'C': e = 'G'; break;
             case 'G': e = 'C'; break;
             case 'T': e = 'A'; break;
             default: assert(false);
         }
     }
     return result.assumeUnique;
}

string revComp6(string bps) {
     char[] result = new char[bps.length];
     auto p1 = result.ptr;
     auto p2 = &bps[$-1];

     while (p2 > bps.ptr) {
         switch(*p2) {
             case 'A': *p1 = 'T'; break;
             case 'C': *p1 = 'G'; break;
             case 'G': *p1 = 'C'; break;
             case 'T': *p1 = 'A'; break;
             default: assert(false);
         }
         p1++; p2--;
     }
     return result.assumeUnique;
}

revComp6 seems to be the fastest, but it's probably also the 
least readable (a common trade-off).