// Performs K-means clustering vector<vector<point> > kmeans(vector<point> initcluster, int k){ vector<point> centeroids, old_centeroids; // vector maintaining k centeroids vector<vector<point> > clusterList; // for storing the list of clusters vector<double> distance; // temp vector, used for finding the min_distance int centeroids_change = 1; //Flag which helps the loop to terminate double min; int destination,num = 0; // Intial centeroids are random for(int i = 0; i < k; ++i){ centeroids.push_back(initcluster[i]); } // loop for finding the optimal clusters and centeroids //while(centeroids_change){ while(num <1500){ // will loop 2000 times, will consider it near optimal solution clusterList.clear(); // clearing the datastructure, after last loop. // initializing the clusterList vector<point> v; for (int i = 0; i < k; ++i) { clusterList.push_back(v); } for (int i = 0; i < initcluster.size()-1; ++i){ distance.clear();// will empty the distance vector for future calculations min = find_distance(initcluster[i], centeroids[0]); //assumption, will improve while running the code destination = 0; for (int j = 0; j < centeroids.size(); ++j){ distance.push_back(find_distance(initcluster[i], centeroids[j])); if (distance[j] <= min){ min = distance[j]; destination = j; } } clusterList.at(destination).push_back(initcluster[i]); } num ++; //cout << "Itr" << num << endl; old_centeroids = centeroids; centeroids = mean_of_cluster(clusterList, k); //centeroids_change = check_change(old_centeroids, centeroids); } cout<< "Number of loops iterated for finding Optimal Solution: "<< num<<"\n"; // Printing final K centeroids cout << "Final Centeroids:"<<"\n"; for(int i=0; i <centeroids.size();++i){ cout<<centeroids[i].id<<" "<<centeroids[i].x<<" "<<centeroids[i].y<<" "<<centeroids[i].z<<"\n"; } clusterList.push_back(centeroids); return clusterList; }
// returns the nodes closest to mean for each of the clusters in clusterlist vector<point> mean_of_cluster(vector<vector<point> > clusterList){ point sum, mean,candidate; float distance; float min_distance; vector<point> new_centeroids; for (int i = 0; i < clusterList.size(); ++i){ sum.x = 0; sum.y = 0; for (int j = 0; j < clusterList.at(i).size(); ++j){ sum.x = sum.x + clusterList[i][j].x; sum.y = sum.y + clusterList[i][j].y; } mean.x = sum.x / clusterList.at(i).size(); mean.y = sum.y / clusterList.at(i).size(); // have to find the closest node to this mean min_distance = find_distance(mean, clusterList[i][0]);// assumption candidate = clusterList[i][0]; for (int n = 0; n < clusterList.at(i).size(); ++n) { distance = find_distance(mean, clusterList[i][n]); if(distance <= min_distance){ min_distance = distance; candidate = clusterList[i][n]; } } new_centeroids.push_back(candidate); } return new_centeroids; }
// Merge clusters which are close to each other vector<vector<point> > unionClusters(vector<vector<point> > clusterList, vector<point> centeroids) { vector<double> radius; double centeroid_dist; for (int i = 0; i < centeroids.size()-1; ++i){ for (int j = i+1; j < centeroids.size(); ++j){ centeroid_dist = find_distance(centeroids.at(i), centeroids.at(j)); radius = updateradius(clusterList, centeroids); // finding radius of each cluster and storing in radius vector if(centeroids.size()<=5) continue; // will not merge if total num of clusters have reduced to 5 else if(centeroid_dist < (radius.at(i) + radius.at(j)/1.5)){ // merging of clusters // merging the two clusters for(int n=0; n < clusterList.at(j).size(); ++n){ clusterList.at(i).push_back(clusterList[j][n]); } // clean up clusterList.erase(clusterList.begin()+j);// erasing the extra cluster centeroids.erase(centeroids.begin()+j);// erasing the extra centroid // updating the centroids centeroids = mean_of_cluster(clusterList); break; } } } return clusterList; }
// returns the nodes closest to mean for each of the clusters in clusterlist vector<point> mean_of_cluster(vector<vector<point> > clusterList, int k){ point sum, mean,candidate; vector<double> distance; double min_distance; vector<point> new_centeroids; for (int i = 0; i < clusterList.size(); ++i) { sum.x = 0; sum.y = 0; sum.z = 0; for (int j = 0; j < clusterList[i].size(); ++j) { sum.x = sum.x + clusterList[i][j].x; sum.y = sum.y + clusterList[i][j].y; sum.z = sum.z + clusterList[i][j].z; } mean.x = sum.x / k; mean.y = sum.y / k; mean.z = sum.z / k; // have to find the closest node to this mean distance.clear(); min_distance = find_distance(mean, clusterList[i][0]);// assumption candidate = clusterList[i][0]; for (int n = 0; n < clusterList[i].size(); ++n) { distance.push_back(find_distance(mean, clusterList[i][n])); if(distance[n] < min_distance){ min_distance = distance[n]; candidate.x = clusterList[i][n].x; candidate.y = clusterList[i][n].y; candidate.z = clusterList[i][n].z; candidate.id = clusterList[i][n].id; } } new_centeroids.push_back(candidate); } return new_centeroids; }
int expand(int line_count, int vertex[][6], int m, int n, int current_x, int current_y){ int i, j; for (i=0; i<=line_count; i++){ for (j=0; j<6; j+=2){ if (i==m && j==n){ } else{ if (check_if_in_triangle(line_count, vertex, vertex[i][j], vertex[i][j+1]) == 0){ if (check_intersect(line_count, vertex, current_x, current_y, vertex[i][j], vertex[i][j+1])== 0){ if( vertex_exist(vertex[i][j], vertex[i][j+1], current_x, current_y) == 0){ valid_vertex[k][0] = current_x; valid_vertex[k][1] = current_y; valid_vertex[k][2] = vertex[i][j]; valid_vertex[k][3] = vertex[i][j+1]; valid_vertex[k][4] = find_distance(current_x, current_y, vertex[i][j], vertex[i][j+1]); valid_vertex[k][5] = -1.0; valid_vertex[k++][6] = -1.0; if (vertex_exist(current_x, current_y, vertex[i][j], vertex[i][j+1]) == 0){ valid_vertex[k][0] = vertex[i][j]; valid_vertex[k][1] = vertex[i][j+1]; valid_vertex[k][2] = current_x; valid_vertex[k][3] = current_y; valid_vertex[k][4] = find_distance(current_x, current_y, vertex[i][j], vertex[i][j+1]); valid_vertex[k][5] = -1.0; valid_vertex[k++][6] = -1.0; } } else{ } } else{ } } } } } }
//finding radius of each cluster and storing in radius vector vector<double> updateradius(vector<vector<point> > clusterList, vector<point> centeroids ){ double max, radius_dist; point p1; vector<point> chk; vector<double> radius; for ( int i = 0; i < clusterList.size(); ++i) { //cout<<"hello2.5"<<endl; max = find_distance(centeroids.at(i), clusterList[i][0]); // assumption p1 = clusterList[i][0]; for (int j = 0; j < clusterList.at(i).size(); ++j) { //cout<<"hello2.75"<<endl; radius_dist = find_distance(centeroids.at(i),clusterList[i][j]); if(radius_dist > max){ max = radius_dist; p1 = clusterList[i][j]; } } chk.push_back(p1); radius.push_back(max); } return radius; }
const char *pick_move(MazeMap *mm, int distsq) { Point dst; find_distance(mm, dist, mm->loc.r, mm->loc.c); if (mm_count_squares(mm) < WIDTH*HEIGHT) dst = explore(mm); else /* mm_count_squares(mm) == WIDTH*HEIGHT */ dst = squash(mm, distsq); if (dst.r == mm->loc.r && dst.c == mm->loc.c) return "T"; return construct_turn(mm, dist, mm->loc.r, mm->loc.c, mm->dir, dst.r, dst.c, NULL, NULL); }
void main() { lcd_init(); init_serial(); Echo = Trig = 0; TMOD |= 0x01;//Timer 0 in 16-bit mode P1=0xf0; // set port as input port P2=0x00; // set port as output port DelayMs(100); while(1) { if(P1==0xf8) { P2=0x0a; //00001010 front } else if(P1==0xf1) { P2=0x02; //00000010 } else if(P1==0xf2) { P2=0x08; //00001000 } else if(P1==0xf4) { P2=0x05; //00000101 back } else if(msg1=='*') { find_distance(); msg1=0; } else { P2=0x00; } } }
//ugal now uses modified comparison, modefied getcredit void ugal_flatfly_onchip( const Router *r, const Flit *f, int in_channel, OutputSet *outputs, bool inject ) { // ( Traffic Class , Routing Order ) -> Virtual Channel Range int vcBegin = 0, vcEnd = gNumVCs-1; if ( f->type == Flit::READ_REQUEST ) { vcBegin = gReadReqBeginVC; vcEnd = gReadReqEndVC; } else if ( f->type == Flit::WRITE_REQUEST ) { vcBegin = gWriteReqBeginVC; vcEnd = gWriteReqEndVC; } else if ( f->type == Flit::READ_REPLY ) { vcBegin = gReadReplyBeginVC; vcEnd = gReadReplyEndVC; } else if ( f->type == Flit::WRITE_REPLY ) { vcBegin = gWriteReplyBeginVC; vcEnd = gWriteReplyEndVC; } assert(((f->vc >= vcBegin) && (f->vc <= vcEnd)) || (inject && (f->vc < 0))); int out_port; if(inject) { out_port = 0; } else { int dest = flatfly_transformation(f->dest); int rID = r->GetID(); int _concentration = gC; int found; int debug = 0; int tmp_out_port, _ran_intm; int _min_hop, _nonmin_hop, _min_queucnt, _nonmin_queucnt; int threshold = 2; if ( in_channel < gC ){ if(gTrace){ cout<<"New Flit "<<f->src<<endl; } f->ph = 0; } if(gTrace){ int load = 0; cout<<"Router "<<rID<<endl; cout<<"Input Channel "<<in_channel<<endl; //need to modify router to report the buffere depth load +=r->GetBuffer(in_channel); cout<<"Rload "<<load<<endl; } if (debug){ cout << " FLIT ID: " << f->id << " Router: " << rID << " routing from src : " << f->src << " to dest : " << dest << " f->ph: " <<f->ph << " intm: " << f->intm << endl; } // f->ph == 0 ==> make initial global adaptive decision // f->ph == 1 ==> route nonminimaly to random intermediate node // f->ph == 2 ==> route minimally to destination found = 0; if (f->ph == 1){ dest = f->intm; } if (dest >= rID*_concentration && dest < (rID+1)*_concentration) { if (f->ph == 1) { f->ph = 2; dest = flatfly_transformation(f->dest); if (debug) cout << " done routing to intermediate "; } else { found = 1; out_port = dest % gC; if (debug) cout << " final routing to destination "; } } if (!found) { if (f->ph == 0) { _min_hop = find_distance(flatfly_transformation(f->src),dest); _ran_intm = find_ran_intm(flatfly_transformation(f->src), dest); tmp_out_port = flatfly_outport(dest, rID); if (f->watch){ *gWatchOut << GetSimTime() << " | " << r->FullName() << " | " << " MIN tmp_out_port: " << tmp_out_port; } _min_queucnt = r->GetCredit(tmp_out_port, -1, -1); _nonmin_hop = find_distance(flatfly_transformation(f->src),_ran_intm) + find_distance(_ran_intm, dest); tmp_out_port = flatfly_outport(_ran_intm, rID); if (f->watch){ *gWatchOut << GetSimTime() << " | " << r->FullName() << " | " << " NONMIN tmp_out_port: " << tmp_out_port << endl; } if (_ran_intm >= rID*_concentration && _ran_intm < (rID+1)*_concentration) { _nonmin_queucnt = numeric_limits<int>::max(); } else { _nonmin_queucnt = r->GetCredit(tmp_out_port, -1, -1); } if (debug){ cout << " _min_hop " << _min_hop << " _min_queucnt: " <<_min_queucnt << " _nonmin_hop: " << _nonmin_hop << " _nonmin_queucnt :" << _nonmin_queucnt << endl; } if (_min_hop * _min_queucnt <= _nonmin_hop * _nonmin_queucnt +threshold) { if (debug) cout << " Route MINIMALLY " << endl; f->ph = 2; } else { // route non-minimally f->minimal = 0; if (debug) { cout << " Route NONMINIMALLY int node: " <<_ran_intm << endl; } f->ph = 1; f->intm = _ran_intm; dest = f->intm; if (dest >= rID*_concentration && dest < (rID+1)*_concentration) { f->ph = 2; dest = flatfly_transformation(f->dest); } } } // find minimal correct dimension to route through out_port = flatfly_outport(dest, rID); // if we haven't reached our destination, restrict VCs appropriately to avoid routing deadlock if(out_port >= gC) { int const available_vcs = (vcEnd - vcBegin + 1) / 2; assert(available_vcs > 0); if(f->ph == 1) { vcEnd -= available_vcs; } else { assert(f->ph == 2); vcBegin += available_vcs; } } found = 1; } if (!found) { cout << " ERROR: output not found in routing. " << endl; cout << *f; exit (-1); } if (out_port >= gN*(gK-1) + gC) { cout << " ERROR: output port too big! " << endl; cout << " OUTPUT select: " << out_port << endl; cout << " router radix: " << gN*(gK-1) + gK << endl; exit (-1); } if (debug) cout << " through output port : " << out_port << endl; if(gTrace){cout<<"Outport "<<out_port<<endl;cout<<"Stop Mark"<<endl;} } outputs->Clear( ); outputs->AddRange( out_port , vcBegin, vcEnd ); }
bool can_psidrain(struct creature *ch, struct creature *vict, int *out_dist, bool msg) { const char *to_char = NULL; const char *to_vict = NULL; int dist; if (CHECK_SKILL(ch, SKILL_PSIDRAIN) < 30 || !IS_PSIONIC(ch)) { to_char = "You have no idea how."; goto failure; } if (ROOM_FLAGGED(ch->in_room, ROOM_NOPSIONICS) && GET_LEVEL(ch) < LVL_GOD) { to_char = "Psychic powers are useless here!"; goto failure; } if (GET_LEVEL(vict) >= LVL_AMBASSADOR && GET_LEVEL(ch) < GET_LEVEL(vict)) { to_char = "You cannot locate them."; to_vict = "$n has just tried to psidrain you."; goto failure; } if (vict == ch) { to_char = "Ha ha... Funny!"; goto failure; } if (is_fighting(ch) && vict->in_room != ch->in_room) { to_char = "You cannot focus outside the room during battle!"; goto failure; } if (ch->in_room != vict->in_room && ch->in_room->zone != vict->in_room->zone) { to_char = "$N is not in your zone."; goto failure; } if (ROOM_FLAGGED(vict->in_room, ROOM_NOPSIONICS) && GET_LEVEL(ch) < LVL_GOD) { to_char = "Psychic powers are useless where $E is!"; goto failure; } if (!ok_to_attack(ch, vict, msg)) return false; if (GET_MOVE(ch) < 20) { to_char = "You are too physically exhausted."; goto failure; } dist = find_distance(ch->in_room, vict->in_room); if (out_dist) *out_dist = dist; if (dist > ((GET_LEVEL(ch) / 6))) { to_char = "$N is out of your psychic range."; goto failure; } if (NULL_PSI(vict)) { to_char = "It is pointless to attempt this on $M."; goto failure; } return true; failure: if (msg) { if (to_char) act(to_char, false, ch, NULL, vict, TO_CHAR); if (to_vict) act(to_vict, false, ch, NULL, vict, TO_VICT); } return false; }
void start_graph(int line_count, int vertex[][6], int start_x, int start_y, int target_x, int target_y){ /* Retrieve all valid vertex that will graph all possible routes in the graph. */ int i, j; //initialize valid_vertex[][] to zero for (i=0; i<600; i++){ valid_vertex[i][0] = 0.0; valid_vertex[i][1] = 0.0; valid_vertex[i][2] = 0.0; valid_vertex[i][3] = 0.0; valid_vertex[i][4] = 0.0; valid_vertex[i][5] = 0.0; valid_vertex[i][6] = 0.0; } //store the start point in valid_vertex valid_vertex[k][0] = start_x; // from x value valid_vertex[k][1] = start_y; // from y value valid_vertex[k][2] = start_x; // to x value valid_vertex[k][3] = start_y; // to y value valid_vertex[k][4] = 0.0; // distance from point a to b valid_vertex[k][5] = 0.0; // total distance valid_vertex[k++][6] = 0.0; // -2.0 target , 1.0 has visited not included, 0.0 using, -1.0 not yet visited //handles the lines connecting from the starting point and branch out for (i=0; i<=line_count; i++){ for (j=0; j<6; j+=2){ if (check_if_in_triangle(line_count, vertex, vertex[i][j], vertex[i][j+1]) == 0){ if (check_intersect(line_count, vertex, start_x, start_y, vertex[i][j], vertex[i][j+1]) == 0){ valid_vertex[k][0] = start_x; valid_vertex[k][1] = start_y; valid_vertex[k][2] = vertex[i][j]; valid_vertex[k][3] = vertex[i][j+1]; valid_vertex[k][4] = find_distance(vertex[i][j], vertex[i][j+1], start_x, start_y); valid_vertex[k][5] = -1.0; valid_vertex[k++][6] = -1.0; valid_vertices(line_count, vertex, i, vertex[i][j], vertex[i][j+1]); } } } } //handles the lines connecting to the target point. for(i=0; i<=line_count; i++){ for(j=0; j<6; j+=2){ if(check_if_in_triangle(line_count, vertex, vertex[i][j], vertex[i][j+1])==0){ if(check_intersect(line_count, vertex, vertex[i][j], vertex[i][j+1], target_x, target_y) == 0){ if (vertex_exist(vertex[i][j], vertex[i][j+1], target_x, target_y) == 0){ valid_vertex[k][0] = vertex[i][j]; valid_vertex[k][1] = vertex[i][j+1]; valid_vertex[k][2] = target_x; valid_vertex[k][3] = target_y; valid_vertex[k][4] = find_distance(vertex[i][j], vertex[i][j+1], target_x, target_y); valid_vertex[k][5] = -1.0; valid_vertex[k++][6] = -2.0; } } } } } }
// Performs K-means clustering and return the sorted vector of clusters vector<point> kmeans(vector<point> initcluster, int k){ vector<point> centeroids, old_centeroids; // vector maintaining k centeroids vector<vector<point> > clusterList; // for storing the list of clusters float distance1; // temp vector, used for finding the min_distance int centeroids_change = 1; //Flag which helps the loop to terminate float min; int destination,num = 0; // Intial centeroids are random for(int i = 0; i < k; ++i){ centeroids.push_back(initcluster[i]); } // loop for finding the optimal clusters and centeroids while(centeroids_change){ clusterList.clear(); // clearing the datastructure, after last loop. // initializing the clusterList vector<point> v; for (int i = 0; i < k; ++i) { clusterList.push_back(v); } for (int i = 0; i < initcluster.size()-1; ++i){ min = find_distance(initcluster[i], centeroids[0]); //assumption, will improve while running the code destination = 0; for (int j = 0; j < centeroids.size(); ++j){ distance1 = find_distance(initcluster[i], centeroids[j]); if (distance1 <= min){ min = distance1; destination = j; } } clusterList.at(destination).push_back(initcluster[i]); } num ++; old_centeroids = centeroids; centeroids = mean_of_cluster(clusterList); centeroids_change = check_change(old_centeroids, centeroids); } cout<< "Number of loops iterated for finding Optimal Solution: "<< num<<"\n"; /* // Printing final K centeroids cout << "Initial Centeroids:"<<"\n"; for(int i=0; i <centeroids.size();++i){ cout<<centeroids[i].x<<", "<<centeroids[i].y<<"; "<<"\n"; } */ // merging clusters which overlap vector<vector<point> > updatedClusterList = unionClusters(clusterList, centeroids); // sorting the cluster List sort (updatedClusterList.begin(), updatedClusterList.end(), sortfunction); cout<<endl<<"Sorted Clusters"; print(updatedClusterList); updatedClusterList.erase(updatedClusterList.begin()+5, updatedClusterList.end()); cout<<endl<<endl<<"Final 5 Clusters"; print(updatedClusterList); centeroids = mean_of_cluster(updatedClusterList); return centeroids; }