::rl::math::Vector SchmersalLss300::getDistances() const { assert(this->isConnected()); ::rl::math::Vector distances(this->getDistancesCount()); ::rl::math::Real scale = static_cast< ::rl::math::Real>(0.01); ::std::uint16_t count = Endian::hostWord(this->data[8], this->data[7]); ::std::uint8_t mask = 0x1F; for (::std::size_t i = 0; i < count; ++i) { if (this->data[10 + i * 2] & 32) { distances(i) = ::std::numeric_limits< ::rl::math::Real>::quiet_NaN(); } else { distances(i) = Endian::hostWord(this->data[10 + i * 2] & mask, this->data[9 + i * 2]); distances(i) *= scale; } } return distances; }
void ClassicalScaling::run( PointWiseMapping* mymap ){ // Retrieve the distances from the dimensionality reduction object double half=(-0.5); Matrix<double> distances( half*mymap->modifyDmat() ); // Apply centering transtion unsigned n=distances.nrows(); double sum; // First HM for(unsigned i=0;i<n;++i){ sum=0; for(unsigned j=0;j<n;++j) sum+=distances(i,j); for(unsigned j=0;j<n;++j) distances(i,j) -= sum/n; } // Now (HM)H for(unsigned i=0;i<n;++i){ sum=0; for(unsigned j=0;j<n;++j) sum+=distances(j,i); for(unsigned j=0;j<n;++j) distances(j,i) -= sum/n; } // Diagonalize matrix std::vector<double> eigval(n); Matrix<double> eigvec(n,n); diagMat( distances, eigval, eigvec ); // Pass final projections to map object for(unsigned i=0;i<n;++i){ for(unsigned j=0;j<mymap->getNumberOfProperties();++j) mymap->setProjectionCoordinate( i, j, sqrt(eigval[n-1-j])*eigvec(n-1-j,i) ); } }
void NeighborSearchRules< SortPolicy, MetricType, TreeType>:: UpdateAfterRecursion(TreeType& queryNode, TreeType& /* referenceNode */) { // Find the worst distance that the children found (including any points), and // update the bound accordingly. double worstDistance = SortPolicy::BestDistance(); // First look through children nodes. for (size_t i = 0; i < queryNode.NumChildren(); ++i) { if (SortPolicy::IsBetter(worstDistance, queryNode.Child(i).Stat().Bound())) worstDistance = queryNode.Child(i).Stat().Bound(); } // Now look through children points. for (size_t i = 0; i < queryNode.NumPoints(); ++i) { if (SortPolicy::IsBetter(worstDistance, distances(distances.n_rows - 1, queryNode.Point(i)))) worstDistance = distances(distances.n_rows - 1, queryNode.Point(i)); } // Take the worst distance from all of these, and update our bound to reflect // that. queryNode.Stat().Bound() = worstDistance; }
/** * Returns a vector of distances between the points in R and point y */ vec GreedyMaxMinDesign::dist(mat R, vec y) { vec distances(R.rows()); // For each point x in R for (int i=0; i<R.rows(); i++) { vec x = R.get_row(i); distances(i) = weightedSquareNorm(x-y); } return distances; }
void CartesianCoordinatesTest::distanceMatrix() { chemkit::CartesianCoordinates coordinates(4); coordinates.setPosition(0, chemkit::Point3(1, 0, 0)); coordinates.setPosition(1, chemkit::Point3(2, 0, 0)); coordinates.setPosition(2, chemkit::Point3(0, 5, 0)); coordinates.setPosition(3, chemkit::Point3(10, 5, 2)); chemkit::Matrix distances = coordinates.distanceMatrix(); QVERIFY(distances.rows() == 4); QVERIFY(distances.cols() == 4); QCOMPARE(qRound(distances(0, 0)), 0); QCOMPARE(qRound(distances(0, 1)), 1); QCOMPARE(qRound(distances(1, 0)), 1); }
size_t closest_point_index_rayOMP(const pcl::PointCloud<PointT>& cloud, const Eigen::Vector3f& direction_pre, const Eigen::Vector3f& line_pt, double& distance_to_ray) { Eigen::Vector3f direction = direction_pre / direction_pre.norm(); PointT point; std::vector<double> distances(cloud.points.size(), 10); // Initialize to value 10 // Generate a vector of distances #pragma omp parallel for for (size_t index = 0; index < cloud.points.size(); index++) { point = cloud.points[index]; Eigen::Vector3f cloud_pt(point.x, point.y, point.z); Eigen::Vector3f difference = (line_pt - cloud_pt); // https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line#Vector_formulation double distance = (difference - (difference.dot(direction) * direction)).norm(); distances[index] = distance; } double min_distance = std::numeric_limits<double>::infinity(); size_t min_index = 0; // Find index of maximum (TODO: Figure out how to OMP this) for (size_t index = 0; index < cloud.points.size(); index++) { const double distance = distances[index]; if (distance < min_distance) { min_distance = distance; min_index = index; } } distance_to_ray = min_distance; return (min_index); }
static void kmeans_center_multiple_restarts( unsigned nb_restarts, cluster_t nb_center, void (*center_init_f)(cluster_t, histogram_c &, dataset_t &, nbgen &), histogram_c ¢er, dataset_t &dataset, nbgen &rng) { std::vector<histogram_c> center_c(nb_restarts); for (unsigned i = 0; i < nb_restarts; ++i) center_init_f(nb_center, center_c[i], dataset, rng); unsigned nb_features = dataset[0].histogram.size(); std::vector<double> cluster_dists(nb_restarts); for (unsigned r = 0; r < nb_restarts; ++r) { double sum = 0; unsigned count = 0; std::vector<double> distances(nb_center, 0); for (unsigned i = 0; i < nb_center; ++i) { for (unsigned j = 0; j < nb_center; ++j) { if (j == i) continue; double dist = l2_distance(center_c[r][i], center_c[r][j], nb_features); distances[i] += dist; ++count; } sum += distances[i]; } cluster_dists[r] = sum / count; // printf("restart:%u -> %f\n", r, cluster_dists[r]); } size_t max_cluster = std::distance( cluster_dists.begin(), std::max_element(cluster_dists.begin(), cluster_dists.end())); // printf("min center index: %zu\n", max_cluster); center = center_c[max_cluster]; }
void PolycrystalReducedIC::initialSetup() { //Set up domain bounds with mesh tools for (unsigned int i = 0; i < LIBMESH_DIM; i++) { _bottom_left(i) = _mesh.getMinInDimension(i); _top_right(i) = _mesh.getMaxInDimension(i); } _range = _top_right - _bottom_left; if (_op_num > _grain_num) mooseError("ERROR in PolycrystalReducedIC: Number of order parameters (op_num) can't be larger than the number of grains (grain_num)"); MooseRandom::seed(_rand_seed); //Randomly generate the centers of the individual grains represented by the Voronoi tesselation _centerpoints.resize(_grain_num); _assigned_op.resize(_grain_num); std::vector<Real> distances(_grain_num); //Assign actual center point positions for (unsigned int grain = 0; grain < _grain_num; grain++) { for (unsigned int i = 0; i < LIBMESH_DIM; i++) _centerpoints[grain](i) = _bottom_left(i) + _range(i) * MooseRandom::rand(); if (_columnar_3D) _centerpoints[grain](2) = _bottom_left(2) + _range(2) * 0.5; } //Assign grains to specific order parameters in a way that maximizes the distance _assigned_op = PolycrystalICTools::assignPointsToVariables(_centerpoints, _op_num, _mesh, _var); }
std::vector<float> WorkerStemFit::compute_distances(std::vector<pcl::ModelCoefficients> &cylinders) { std::vector<float> distances ( _cloud->points.size () ); std::fill ( distances.begin (), distances.end (), 0.5 ); pcl::octree::OctreePointCloudSearch<PointI> octree ( 0.02f ); octree.setInputCloud ( _cloud ); octree.addPointsFromInputCloud (); for (size_t i = 0; i < cylinders.size(); i++) { pcl::ModelCoefficients cylinder = cylinders.at(i); std::vector<int> indices = indexOfPointsNearCylinder ( octree, cylinder ); for ( size_t i = 0; i < indices.size (); i++ ) { PointI point = _cloud->points[indices[i]]; simpleTree::Cylinder cyl (cylinder); float dist = cyl.distToPoint ( point ); if ( std::abs ( dist ) < std::abs ( distances[indices[i]] ) ) { distances[indices[i]] = dist; } } } return distances; }
std::pair<std::vector<count>, node> BFS::run_Feist(const Graph& g, node source) const { count infDist = std::numeric_limits<count>::max(); count n = g.numberOfNodes(); std::vector<count> distances(n, infDist); std::queue<node> q; distances[source] = 0; q.push(source); node max_node; while (! q.empty()) { node current = q.front(); q.pop(); //std::cout << "current node in BFS: " << current << " "; // insert untouched neighbors into queue g.forNeighborsOf(current, [&](node neighbor) { if (distances[neighbor] == infDist) { q.push(neighbor); distances[neighbor] = distances[current] + 1; max_node = neighbor; } }); } return std::make_pair (distances, max_node); }
template <typename PointT> double pcl::MaximumLikelihoodSampleConsensus<PointT>::computeMedianAbsoluteDeviation ( const PointCloudConstPtr &cloud, const boost::shared_ptr <std::vector<int> > &indices, double sigma) { std::vector<double> distances (indices->size ()); Eigen::Vector4f median; // median (dist (x - median (x))) computeMedian (cloud, indices, median); for (size_t i = 0; i < indices->size (); ++i) { pcl::Vector4fMapConst pt = cloud->points[(*indices)[i]].getVector4fMap (); Eigen::Vector4f ptdiff = pt - median; ptdiff[3] = 0; distances[i] = ptdiff.dot (ptdiff); } std::sort (distances.begin (), distances.end ()); double result; size_t mid = indices->size () / 2; // Do we have a "middle" point or should we "estimate" one ? if (indices->size () % 2 == 0) result = (sqrt (distances[mid-1]) + sqrt (distances[mid])) / 2; else result = sqrt (distances[mid]); return (sigma * result); }
void KMeans<ScalarType, AssignmentType>::calculateInitGuess(const std::vector<Eigen::Matrix<ScalarType, Eigen::Dynamic, 1> >& data, std::vector<Eigen::Matrix<ScalarType, Eigen::Dynamic, 1> >& initGuess, unsigned int meanCount) { assert(meanCount > 0u); assert(data.size() > 0u); //first clear the initGuess vector. might not be empty. initGuess.clear(); UniformRNG<double> rng; unsigned int dataSize = data.size(); //insert first point. initGuess.push_back(data[std::rand() % dataSize]); Eigen::VectorXf distances(dataSize); float distance, minDistance; int minDistanceElement=0; double draw; //create meanCount guesses. first value has been taken. for (unsigned int g=1; g<meanCount; g++) { //calculate distances to nearest cluster mean guess for (unsigned int i=0; i<dataSize; i++) { distance = minDistance = std::numeric_limits<float>::max(); for (unsigned int j=0; j<initGuess.size(); j++) { // since we don't need the distance, but only the // /smallest/ distance, we can omit the sqrt operation. // it is not proven to be faster this way, so I will have // both instructions here - you can choose. both work. distance = (initGuess[j] - data[i]).norm(); //distance = (initGuess[j] - data[i]).array().square().sum(); if (distance < minDistance) { minDistance = distance; } } distances[i] = minDistance; } //draw random value in [0, maxDistance]; draw = rng.rand() * distances.maxCoeff(); //find the element that best fits to the drawn value (distance). minDistance = std::numeric_limits<float>::max(); for (unsigned int i=0; i<dataSize; i++) { distance = std::fabs(distances[i] - draw); if (distance < minDistance) { minDistance = distance; minDistanceElement = i; } } //take that element. initGuess.push_back(data[minDistanceElement]); } assert(initGuess.size() == meanCount); }
bool Search(U_INT src, U_INT trg, T& PathRes, U_INT& Cost) { typedef boost::graph_traits<GraphT>::vertex_descriptor vertex_descriptor; std::vector<vertex_descriptor> predecessors(num_vertices(hGraph)); if (src>=num_vertices(hGraph) || trg>=num_vertices(hGraph)) return false; vertex_descriptor source_vertex = vertex(src, hGraph); vertex_descriptor target_vertex = vertex(trg, hGraph); std::vector<U_INT> distances(num_vertices(hGraph)); typedef std::vector<boost::default_color_type> colormap_t; colormap_t colors(num_vertices(hGraph)); try { boost::astar_search( hGraph, source_vertex, distance_heuristic<GraphT>(hGraph, target_vertex), boost::predecessor_map(&predecessors[0]). weight_map(get(( &xEdge::cost ), hGraph)). distance_map(&distances[0]). color_map(&colors[0]). visitor(astar_goal_visitor<vertex_descriptor>(target_vertex))); } catch (found_goal fg) { Cost=distances[target_vertex]; PathRes.clear(); PathRes.push_front(target_vertex); size_t max=num_vertices(hGraph); while (target_vertex != source_vertex) { if (target_vertex == predecessors[target_vertex]) return false; target_vertex = predecessors[target_vertex]; PathRes.push_front(target_vertex); if (!max--) return false; } return true; } return false; }
void toNormalizedNEXUS(ifstream & inf, ostream *os) { NxsTaxaBlock taxa; NxsTreesBlock trees(&taxa); NxsAssumptionsBlock assumptions(&taxa); NxsCharactersBlock character(&taxa, &assumptions); NxsDataBlock data(&taxa, &assumptions); NxsDistancesBlock distances(&taxa); NxsUnalignedBlock unaligned(&taxa, &assumptions); NormalizingReader nexus(os); nexus.Add(&taxa); nexus.Add(&trees); nexus.Add(&assumptions); nexus.Add(&character); nexus.Add(&data); nexus.Add(&distances); nexus.Add(&unaligned); if (os) { *os << "#NEXUS\n"; } NormalizingToken token(inf, os); nexus.Execute(token); }
void computeVarianceAndCorrespondences( const pcl::PointCloud<pcl::PointXYZ>::ConstPtr & cloudA, const pcl::PointCloud<pcl::PointXYZ>::ConstPtr & cloudB, double maxCorrespondenceDistance, double & variance, int & correspondencesOut) { variance = 1; correspondencesOut = 0; pcl::registration::CorrespondenceEstimation<pcl::PointXYZ, pcl::PointXYZ>::Ptr est; est.reset(new pcl::registration::CorrespondenceEstimation<pcl::PointXYZ, pcl::PointXYZ>); est->setInputTarget(cloudB); est->setInputSource(cloudA); pcl::Correspondences correspondences; est->determineCorrespondences(correspondences, maxCorrespondenceDistance); if(correspondences.size()>=3) { std::vector<double> distances(correspondences.size()); for(unsigned int i=0; i<correspondences.size(); ++i) { distances[i] = correspondences[i].distance; } //variance std::sort(distances.begin (), distances.end ()); double median_error_sqr = distances[distances.size () >> 1]; variance = (2.1981 * median_error_sqr); }
inline void cv_dist_vector_LogEucl::train(int tr_scale, int tr_shift ) { distances(tr_scale, tr_shift); svm_train(); }
double getlength(int n,point *p) { if(n==1) return 0; double ans=0; for(int i=0;i<n;i++) ans+=distances(p[i],p[(i+n+1)%n]); return ans; }
inline void cv_dist_vector_GrassBC::train(int tr_scale, int tr_shift ) { distances(tr_scale, tr_shift); svm_train(); }
std::vector<ompl::control::ProductGraph::State*> ompl::control::ProductGraph::computeLead( ProductGraph::State* start, const boost::function<double(ProductGraph::State*, ProductGraph::State*)>& edgeWeight) { std::vector<GraphType::vertex_descriptor> parents(boost::num_vertices(graph_)); std::vector<double> distances(boost::num_vertices(graph_)); EdgeIter ei, eend; //first build up the edge weights for (boost::tie(ei,eend) = boost::edges(graph_); ei != eend; ++ei) { GraphType::vertex_descriptor src = boost::source(*ei, graph_); GraphType::vertex_descriptor target = boost::target(*ei, graph_); graph_[*ei].cost = edgeWeight(graph_[src], graph_[target]); } int startIndex = stateToIndex_[start]; boost::dijkstra_shortest_paths(graph_, boost::vertex(startIndex,graph_), boost::weight_map(get(&Edge::cost, graph_)).distance_map( boost::make_iterator_property_map(distances.begin(), get(boost::vertex_index, graph_) )).predecessor_map( boost::make_iterator_property_map(parents.begin(), get(boost::vertex_index, graph_)) ) ); //pick state from solutionStates_ such that distance[state] is minimized State* bestSoln = *solutionStates_.begin(); double cost = distances[boost::vertex(stateToIndex_[bestSoln], graph_)]; for (std::vector<State*>::const_iterator s = solutionStates_.begin()+1; s != solutionStates_.end(); ++s) { if (distances[boost::vertex(stateToIndex_[*s], graph_)] < cost) { cost = distances[boost::vertex(stateToIndex_[*s], graph_)]; bestSoln = *s; } } //build lead from bestSoln parents std::stack<State*> leadStack; while (!(bestSoln == start)) { leadStack.push(bestSoln); bestSoln = graph_[parents[boost::vertex(stateToIndex_[bestSoln], graph_)]]; } leadStack.push(bestSoln); std::vector<State*> lead; while (!leadStack.empty()) { lead.push_back(leadStack.top()); leadStack.pop(); // Truncate the lead as early when it hits the desired automaton states // \todo: more elegant way to do this? if (lead.back()->cosafeState == solutionStates_.front()->cosafeState && lead.back()->safeState == solutionStates_.front()->safeState) break; } return lead; }
DBL_MATRIX Alignment::estimateAlpha_(DBL_MATRIX& points, DBL_MATRIX& rt_vec) { unsigned int n_points = points.rowCount(); unsigned int rt_size = rt_vec.rowCount(); if(n_points < 1){ MSPP_LOG(logERROR) << "Alignment::estimateAlpha_(): number of points must be greater than 0!" << std::endl; } mspp_precondition(n_points >= 1 , "Alignment::estimateAlpha_(): number of points must be greater than 0!"); if(points.columnCount() != rt_vec.columnCount()){ MSPP_LOG(logERROR) << "Alignment::estimateAlpha_(): Wrong dimensionality of input - points and rt_vec must have equal dimensions!" << std::endl; } mspp_precondition(points.columnCount() == rt_vec.columnCount() , "Alignment::estimateAlpha_(): Wrong dimensionality of input - points and rt_vec must have equal dimensions!"); //vector containing new alpha values DBL_MATRIX returnAlpha (n_points,1,0.); for(unsigned int i = 0; i < n_points; i++){ DBL_MATRIX pointMat = rt_vec; pointMat.init(0.); //fill each line in pointMat with points(i,*) for(unsigned int k = 0; k < rt_size; k++){ for(int l = 0; l < rt_vec.columnCount(); l++){ pointMat(k,l) = points(i,l); } } //calculate distances from rt_vec to points(i,*) vigra::linalg::Matrix<double> distances = rt_vec - pointMat; std::vector<double> sqrdist (rt_size); //needs to be sorted --> vector for(unsigned int k = 0; k < rt_size; k++){ double sum = 0; for(int l = 0; l < rt_vec.columnCount(); l++){ sum += pow(distances(k,l) , 2); } sqrdist[k] = sum; } //sort sqrdist std::sort(sqrdist.begin(),sqrdist.end()); double mean = 0; int range = ((20<rt_size)?20:rt_size); for(int k = 0; k < range; k++){ mean += sqrdist[k]; } mean /= range; returnAlpha(i,0) =( 1./sqrt(mean) * 10 + 0.1 ); } return returnAlpha; }
void LowessSmoothing::smoothData(const DoubleVector& input_x, const DoubleVector& input_y, DoubleVector& smoothed_output) { if (input_x.size() != input_y.size()) { throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Sizes of x and y values not equal! Aborting... ", String(input_x.size())); } // unable to smooth over 2 or less data points (we need at least 3) if (input_x.size() <= 2) { smoothed_output = input_y; return; } Size input_size = input_y.size(); // const Size q = floor( input_size * alpha ); const Size q = (window_size_ < input_size) ? static_cast<Size>(window_size_) : input_size - 1; DoubleVector distances(input_size, 0.0); DoubleVector sortedDistances(input_size, 0.0); for (Size outer_idx = 0; outer_idx < input_size; ++outer_idx) { // Compute distances. // Size inner_idx = 0; for (Size inner_idx = 0; inner_idx < input_size; ++inner_idx) { distances[inner_idx] = std::fabs(input_x[outer_idx] - input_x[inner_idx]); sortedDistances[inner_idx] = distances[inner_idx]; } // Sort distances in order from smallest to largest. std::sort(sortedDistances.begin(), sortedDistances.end()); // Compute weigths. std::vector<double> weigths(input_size, 0); for (Size inner_idx = 0; inner_idx < input_size; ++inner_idx) { weigths.at(inner_idx) = tricube_(distances[inner_idx], sortedDistances[q]); } //calculate regression Math::QuadraticRegression qr; std::vector<double>::const_iterator w_begin = weigths.begin(); qr.computeRegressionWeighted(input_x.begin(), input_x.end(), input_y.begin(), w_begin); //smooth y-values double rt = input_x[outer_idx]; smoothed_output.push_back(qr.eval(rt)); } return; }
int main() { #ifndef ONLINE_JUDGE freopen("in.txt","r",stdin); #endif int t; scanf("%d",&t); while(t--) { scanf("%d",&n); int pos=0; for(int i=0;i<n;i++) { scanf("%d %lf %lf",&number[i],&p[i].x,&p[i].y); if(p[pos].y>p[i].y) pos=i; } printf("%d %d",n,number[pos]); memset(vis,0,sizeof(vis)); vis[pos]=1; point last=p[pos]; for(int i=1;i<n;i++) { double dist; for(int j=0;j<n;j++) if(!vis[j]) { pos=j; break; } for(int j=pos+1;j<n;j++) { if(vis[j])continue; double tmp=xmult(p[pos],p[j],last); double tmpdist=distances(last,p[j]); if(tmp<-eps || (zero(tmp) && tmpdist<dist)) { pos=j; dist=tmpdist; } } printf(" %d",number[pos]); vis[pos]=1; last=p[pos]; } printf("\n"); } return 0; }
template <typename PointT> void pcl::UnaryClassifier<PointT>::queryFeatureDistances (std::vector<pcl::PointCloud<pcl::FPFHSignature33>::Ptr> &trained_features, pcl::PointCloud<pcl::FPFHSignature33>::Ptr query_features, std::vector<int> &indi, std::vector<float> &dist) { // estimate the total number of row's needed int n_row = 0; for (size_t i = 0; i < trained_features.size (); i++) n_row += static_cast<int> (trained_features[i]->points.size ()); // Convert data into FLANN format int n_col = 33; flann::Matrix<float> data (new float[n_row * n_col], n_row, n_col); for (size_t k = 0; k < trained_features.size (); k++) { pcl::PointCloud<pcl::FPFHSignature33>::Ptr hist = trained_features[k]; int c = static_cast<int> (hist->points.size ()); for (size_t i = 0; i < c; ++i) for (size_t j = 0; j < data.cols; ++j) data[(k*c)+i][j] = hist->points[i].histogram[j]; } // build kd-tree given the training features flann::Index<flann::ChiSquareDistance<float> > *index; index = new flann::Index<flann::ChiSquareDistance<float> > (data, flann::LinearIndexParams ()); //flann::Index<flann::ChiSquareDistance<float> > index (data, flann::LinearIndexParams ()); //flann::Index<flann::ChiSquareDistance<float> > index (data, flann::KMeansIndexParams (5, -1)); //flann::Index<flann::ChiSquareDistance<float> > index (data, flann::KDTreeIndexParams (4)); index->buildIndex (); int k = 1; indi.resize (query_features->points.size ()); dist.resize (query_features->points.size ()); // Query all points for (size_t i = 0; i < query_features->points.size (); i++) { // Query point flann::Matrix<float> p = flann::Matrix<float>(new float[n_col], 1, n_col); memcpy (&p.ptr ()[0], query_features->points[i].histogram, p.cols * p.rows * sizeof (float)); flann::Matrix<int> indices (new int[k], 1, k); flann::Matrix<float> distances (new float[k], 1, k); index->knnSearch (p, indices, distances, k, flann::SearchParams (512)); indi[i] = indices[0][0]; dist[i] = distances[0][0]; delete[] p.ptr (); } //std::cout << "kdtree size: " << index->size () << std::endl; delete[] data.ptr (); }
// This function returns the "anchor point" closes to the specified bacteria. // It calculates the distance between the bacteria centrum and the various // anchors on the food nugget, and then it takes the shortest of those // distances and returns the coordinates of that anchor. coordinate_pair_t food::closest_anchor(const vector & bacteria_vector) { coordinate_pair_t retval; vector this_vector = vector(0, 0, F_ANCHOR_1_X + x, F_ANCHOR_1_Y + y); float distance_1, distance_2, distance_3, distance_4, eval_dist; std::valarray<float> distances(4); if(anchor_1 == 0) { distance_1 = vector::distance_between(this_vector, bacteria_vector); distances[0] = distance_1; } else distances[0] = INFINITY; if(anchor_2 == 0) { this_vector.set_xy(F_ANCHOR_2_X + x, F_ANCHOR_2_Y + y); distance_2 = vector::distance_between(this_vector, bacteria_vector); distances[1] = distance_2; } else distances[1] = INFINITY; if(anchor_3 == 0) { this_vector.set_xy(F_ANCHOR_3_X + x, F_ANCHOR_3_Y + y); distance_3 = vector::distance_between(this_vector, bacteria_vector); distances[2] = distance_3; } else distances[2] = INFINITY; if(anchor_4 == 0) { this_vector.set_xy(F_ANCHOR_4_X + x, F_ANCHOR_4_Y + y); distance_4 = vector::distance_between(this_vector, bacteria_vector); distances[3] = distance_4; } else distances[3] = INFINITY; eval_dist = distances.min(); if(eval_dist == distance_1) retval = ANCHOR_1; if(eval_dist == distance_2) retval = ANCHOR_2; if(eval_dist == distance_3) retval = ANCHOR_3; if(eval_dist == distance_4) retval = ANCHOR_4; return retval; }
inline double NeighborSearchRules<SortPolicy, MetricType, TreeType>::Score( const size_t queryIndex, TreeType& referenceNode) const { const arma::vec queryPoint = querySet.unsafe_col(queryIndex); const double distance = SortPolicy::BestPointToNodeDistance(queryPoint, &referenceNode); const double bestDistance = distances(distances.n_rows - 1, queryIndex); return (SortPolicy::IsBetter(distance, bestDistance)) ? distance : DBL_MAX; }
double clusteringValidity::getMaximumDistance(const dmatrix& m1, const dmatrix& m2) const { int i,j; dmatrix distances(m1.rows(),m2.rows()); l2Distance<double> dist; for (i=0; i<m1.rows(); i++) { for (j=0; j<m2.rows(); j++) { distances[i][j]=dist.apply(m1.getRow(i),m2.getRow(j)); } } return distances.maximum(); }
void BeliefGenerator<M>::expandBeliefList(size_t max, BeliefList * blp) const { assert(blp); auto & bl = *blp; size_t size = bl.size(); std::vector<Belief> newBeliefs(A); std::vector<double> distances(A); auto dBegin = std::begin(distances), dEnd = std::end(distances); // L1 distance auto computeDistance = [this](const Belief & lhs, const Belief & rhs) { double distance = 0.0; for ( size_t i = 0; i < S; ++i ) distance += std::abs(lhs[i] - rhs[i]); return distance; }; Belief helper; double distance; // We apply the discovery process also to all beliefs we discover // along the way. for ( auto it = std::begin(bl); it != std::end(bl); ++it ) { // Compute all new beliefs for ( size_t a = 0; a < A; ++a ) { distances[a] = 0.0; for ( int j = 0; j < 20; ++j ) { size_t s = sampleProbability(S, *it, rand_); size_t o; std::tie(std::ignore, o, std::ignore) = model_.sampleSOR(s, a); helper = updateBelief(model_, *it, a, o); // Compute distance (here we compare also against elements we just added!) distance = computeDistance(helper, bl.front()); for ( auto jt = ++std::begin(bl); jt != std::end(bl); ++jt ) { if ( checkEqualSmall(distance, 0.0) ) break; // We already have it! distance = std::min(distance, computeDistance(helper, *jt)); } // Select the best found over 20 times if ( distance > distances[a] ) { distances[a] = distance; newBeliefs[a] = helper; } } } // Find furthest away, add only if it is new. size_t id = std::distance( dBegin, std::max_element(dBegin, dEnd) ); if ( checkDifferentSmall(distances[id], 0.0) ) { bl.emplace_back(std::move(newBeliefs[id])); ++size; if ( size == max ) break; } } }
double clusteringValidity::getStandardDiameter(const dmatrix& m1) const { dmatrix distances(m1.rows(),m1.rows()); int j,k; l2Distance<double> dist; for (j=0; j<m1.rows(); j++) { for (k=j+1; k<m1.rows(); k++) { distances[j][k]=dist.apply(m1.getRow(j), m1.getRow(k)); } } return distances.maximum(); }
int Targets::getCurrentTarget(Point point) { vector<double> distances(targets.size()); // debugtee(targets); transform(targets.begin(), targets.end(), distances.begin(), sigc::mem_fun(point, &Point::distance)); // debugtee(distances); return min_element(distances.begin(), distances.end()) - distances.begin(); // for(int i=0; i<targets.size(); i++) // if (point.distance(targets[i]) < 30) // return i; // return -1; }
DelaunayConstraints::DelaunayConstraints(PatchSet& patches) { Point2f* positions = new Point2f[patches.size()]; vector<vector<int> > neighborhoods; C = Mat_<double>(patches.size(), patches.size()); // C = Mat_<float>(patches.size(),patches.size()); for (int i = 0; i < patches.size(); i++) { positions[i] = patches.get_position(i); neighborhoods.push_back(vector<int>()); } // determine neighborhoods using Delaunay triangulation delaunay_neihgbours(positions, patches.size(), neighborhoods); float* D ; D = new float[patches.size()]; // add closest non-DT node to the neighborhood for nodes with only two neighbors for (int i = 0; i < patches.size(); i++) { // KAKO DELUJE TA KODA? if (neighborhoods[i].size() > 2) { continue; } // tovrimo trikotnik na silo, èe sosed nima dveh sosedov // kako prepreèimo kolinearnost izbranih treh toèk? distances(positions[i], positions, patches.size(), D); int minNode = -1; float minDistance = FLT_MAX; for (int j = 0; j < patches.size(); j++) { if (D[j] > 0 && j != neighborhoods[i][0] && j != neighborhoods[i][1] && D[j] < minDistance) { minNode = j; minDistance = D[j]; } } if (minNode >= 0) { neighborhoods[i].push_back(minNode); } } delete [] D; C.setTo(0.0); for (int i = 0; i < neighborhoods.size(); i++) { for (int j = 0; j < neighborhoods[i].size(); j++) { C.at<double>(i, neighborhoods[i][j]) = 1.0; } } delete [] positions; }