void
ComputeLocalCostForNeurons(VG_RAM_WNN *vg_ram_wnn, int *query, int query_size, int *neuron_cost)
{
int *data = vg_ram_wnn->memories;
int data_size = vg_ram_wnn->memory_size;
int number_of_neurons = vg_ram_wnn->number_of_neurons;
int memory_bit_group_size = vg_ram_wnn->memory_bit_group_size;
#pragma omp parallel default(none) \
shared(data,query,data_size,query_size,memory_bit_group_size,number_of_neurons,neuron_cost)
{
for (int neuron = 0; neuron < number_of_neurons; neuron++)
{
//percorrer memoria do neuronio
int *seqData = GetNeuronMemoryByNeuron(data, data_size, memory_bit_group_size, neuron);
//percorrer amostras de testes e extrair features para memoria temporaria
int *seqQuery = GetNeuronMemoryByNeuron(query, query_size, memory_bit_group_size, neuron);
//calcular matriz de custo local para cada neuronio
#pragma omp for
for (int i = 0; i < query_size; i++)
{
for (int j = 0; j < data_size; j++)
{
int distance = HammingDistance(
(unsigned int *)GetNeuronMemoryBySample(seqData, memory_bit_group_size, j),
(unsigned int *)GetNeuronMemoryBySample(seqQuery, memory_bit_group_size, i),
memory_bit_group_size);
neuron_cost[index3D(neuron, i, j, query_size, data_size)] = distance;
}
}
}
}
}
set<string> Neighbors(string pattern, int d)
{
set<string> neighborhood;
if (d == 0)
{
neighborhood.insert(pattern);
} else if (pattern.size() == 1)
{
string result[4] = { "A", "C", "G", "T" };
neighborhood.insert(result, result+4);
} else
{
string suf_pattern = suffix(pattern);
set<string> suf_neighbors = Neighbors(suf_pattern, d);
for (auto it=suf_neighbors.begin(); it!=suf_neighbors.end(); it++)
{
if (HammingDistance(suf_pattern, *it) < d)
{
for (int j=0; j<4; j++)
neighborhood.insert(int2nucl(j) + *it);
}
else
{
neighborhood.insert(pattern[0] + *it);
}
}
}
return neighborhood;
}
pair<size_t, size_t> FindBestOverlap(string seq1, string seq2) {
pair<size_t, size_t> best_overlap(size_t(-1), size_t(-1));
for(size_t i = 0; i < seq1.size(); i++) {
size_t overlap_size = min<size_t>(seq2.size(), seq1.size() - i);
if(overlap_size >= setting_.min_overlap) {
string subseq1 = seq1.substr(i, overlap_size);
string subseq2 = seq2.substr(0, overlap_size);
size_t dist = HammingDistance(subseq1, subseq2);
double mism_rate = double(dist) / overlap_size;
if(mism_rate <= setting_.max_mismatch_rate) {
if(best_overlap.first > dist) {
best_overlap.first = dist;
best_overlap.second = i;
}
}
}
}
return best_overlap;
}
int NumExactMatches(const Eigen::MatrixXi& M, const Eigen::MatrixXi& m, int& best_score, int& best_r, int& best_c)
{
const int border = std::min((int)std::min(m.rows(),m.cols())-2, 2);
best_score = std::numeric_limits<int>::max();
const Eigen::Vector2i rcmax( 2*border + M.rows() - m.rows(), 2*border + M.cols() - m.cols());
int num_zeros = 0;
for(int r=-border; r < rcmax(0); ++r ) {
for(int c=-border; c < rcmax(1); ++c) {
const int hd = HammingDistance(M, m, r,c );
if(hd < best_score) {
best_score = hd;
best_r = r;
best_c = c;
}
if(hd==0) {
++num_zeros;
}
}
}
return num_zeros;
}
int main(int argc,char *argv[]){
int x=atoi(argv[1]),y=atoi(argv[2]);
std::cout << HammingDistance(x,y) << std::endl;
return 0;
}
