gen similarity compute

1.similar_gen.cpp

#include <string.h>
#include <iostream>
#include <string>
#include <algorithm>
#include "boost/noncopyable.hpp"
using namespace std;
class similar_gen : public boost::noncopyable {
public:
    inline static similar_gen &get() {
        static similar_gen obj;
        return obj;
    }
    int compute_similarity(const string &gen_str0, const string &gen_str1) {
        if (false == check_gen_str(gen_str0) ||  false == check_gen_str(gen_str1)) {
            cerr << "invalid gen string...!" << endl;
            return -1;
        }
        make_status_equation(gen_str0, gen_str1);
        int size0 = gen_str0.size();
        int size1 = gen_str0.size();
        for (int i = 1;i <= size0;i++) {
            for (int j = 1;j <= size1;j++) {
                status_equation_[i][j] = max(status_equation_[i][j], status_equation_[i - 1][j - 1] + get_similarity(gen_str0[i - 1], gen_str1[j - 1]));
                status_equation_[i][j] = max(status_equation_[i][j], status_equation_[i][j - 1] + get_similarity(gen_str1[j - 1], '-'));
                status_equation_[i][j] = max(status_equation_[i][j], status_equation_[i - 1][j] + get_similarity(gen_str0[i - 1], '-'));
            }
        }
        return status_equation_[size0][size1];

    }
private:
    bool check_gen_str(const string &gen_str) {
        if (gen_str.size() > max_gen_len) {
            return false;
        }
        for (auto &ch : gen_str) {
            if (ch != 'A' && ch != 'C' && ch != 'G' && ch != 'T') {
                return false;
            }
        }
        return true;
    }
    void make_similarity() {
        similarity_array_['A']['A'] = 5;
        similarity_array_['A']['C'] = -1;
        similarity_array_['A']['G'] = -2;
        similarity_array_['A']['T'] = -1;
        similarity_array_['A']['-'] = -3;

        similarity_array_['C']['A'] = -1;
        similarity_array_['C']['C'] = 5;
        similarity_array_['C']['G'] = -3;
        similarity_array_['C']['T'] = -2;
        similarity_array_['C']['-'] = -4;

        similarity_array_['G']['A'] = -2;
        similarity_array_['G']['C'] = -3;
        similarity_array_['G']['G'] = 5;
        similarity_array_['G']['T'] = -2;
        similarity_array_['G']['-'] = -2;

        similarity_array_['T']['A'] = -1;
        similarity_array_['T']['C'] = -2;
        similarity_array_['T']['G'] = -2;
        similarity_array_['T']['T'] = 5;
        similarity_array_['T']['-'] = -1;

        similarity_array_['-']['A'] = -3;
        similarity_array_['-']['C'] = -4;
        similarity_array_['-']['G'] = -2;
        similarity_array_['-']['T'] = -1;
        similarity_array_['-']['-'] = -10;
    }
    inline int get_similarity(char ch0, char ch1) {
        return similarity_array_[ch0][ch1];
    }
    void make_status_equation(const string &gen_str0, const string &gen_str1) {
        memset(status_equation_, 0, sizeof(status_equation_));
        int size = gen_str0.size();
        for (int i = 1;i <= size;i++) {
            status_equation_[i][0] = status_equation_[i - 1][0] + get_similarity(gen_str0[i - 1], '-');
        }
        size = gen_str1.size();
        for (int i = 1;i <= size;i++) {
            status_equation_[0][i] = status_equation_[0][i - 1] + get_similarity(gen_str1[i - 1], '-');
        }
    }
private:
    similar_gen() {
        make_similarity();
    }
    virtual ~similar_gen() = default;
private:
    static const int max_gen_len = 100;
private:
    int similarity_array_[256][256];
    int status_equation_[max_gen_len + 1][max_gen_len + 1];

};
int main() {
    string str0 = "AGTGATG";
    string str1 = "GTTAG";
    cout << similar_gen::get().compute_similarity(str0, str1) << endl;

    return 0;
}

2.make.sh

g++ -std=c++14 -g -o Test similar_gen.cpp -I ../boost_1_69_0/ -L ../boost_1_69_0/libs/