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; }