示例#1
0
 void checkRawAccess() {
     Printf("Raw access+++++++++++++++++++++++++++\n");
     VD data = { 0, 1, 1,
                 2, 3, 2,
                 1, 3, 2,
                 4, 2, 2};
     Matrix m(3, data);
     print(m);
     
     double expected, test;
     size_t rows = data.size() / 3;
     // check read
     for (int i = 0; i < rows; i++) {
         for (int j = 0; j < 3; j++) {
             expected = data[i * 3 + j];
             test = m(i, j);
             unitpp::assert_eq(spf("Expected value not equal to readen at row: %i, col: %i", i, j), test, expected);
         }
     }
     
     // check write
     int val = 0;
     for (int i = 0; i < rows; i++) {
         for (int j = 0; j < 3; j++) {
             m(i, j) = val++;
         }
     }
     VD testVector;
     m.rowPackedCopy(testVector);
     for (int i = 0; i < testVector.size(); i++) {
         test = testVector[i];
         unitpp::assert_eq(spf("Value found: %i, but was expected: %i", test, i), test, i);
     }
 }
示例#2
0
 double doExec() {
     
     if (!loadTestData()) {
         std::cerr << "Failed to load test data" << std::endl;
         return -1;
     }
     
     //
     // Start solution testing
     //
     double score = 0, sse;
     int scenario = 0;
     for (int i = 0; i < subsetsNum; i++) {
         scenario = i % 3;
         generateTestData(scenario, i);
         VD res = test->predict(0, scenario, DTrain, DTest);
         
         Assert(groundTruth.size() == res.size(), "Expected results count not equal to found. Expected: %lu, but found: %lu", groundTruth.size(), res.size());
         sse = 0;
         for (int j = 0; j < res.size(); j++) {
             double e = res[j] - groundTruth[j];
             sse += e * e;
         }
         // calculate score
         double s = 1000000 * fmax(0, 1.0 - sse/sse0);
         Printf("%i.) Score = %f, sse: %f, sse0: %f\n", i, s, sse, sse0);
         score += s;
     }
     return score / subsetsNum;
 }
示例#3
0
int main() {

  const int m = 4;
  const int n = 3;  
  DOUBLE _A[m][n] = {
    { 6, -1, 0 },
    { -1, -5, 0 },
    { 1, 5, 1 },
    { -1, -5, -1 }
  };
  DOUBLE _b[m] = { 10, -4, 5, -5 };
  DOUBLE _c[n] = { 1, -1, 0 };
  
  VVD A(m);
  VD b(_b, _b + m);
  VD c(_c, _c + n);
  for (int i = 0; i < m; i++) A[i] = VD(_A[i], _A[i] + n);

  LPSolver solver(A, b, c);
  VD x;
  DOUBLE value = solver.Solve(x);
  
  cerr << "VALUE: "<< value << endl;
  cerr << "SOLUTION:";
  for (size_t i = 0; i < x.size(); i++) cerr << " " << x[i];
  cerr << endl;
  return 0;
}
 LPSolver(const VVD &A, const VD &b, const VD &c) :
  m(b.size()), n(c.size()),
  N(n + 1), B(m), D(m + 2, VD(n + 2)) {
  for (int i = 0; i < m; i++) for (int j = 0; j < n; j++)
    D[i][j] = A[i][j];
  for (int i = 0; i < m; i++) { B[i] = n + i; D[i][n] = -1;
    D[i][n + 1] = b[i]; }
  for (int j = 0; j < n; j++) { N[j] = j; D[m][j] = -c[j]; }
  N[n] = -1; D[m + 1][n] = 1; }
示例#5
0
void MLComputeTest::dotProduct_benchmark_vector()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        MLCompute::dotProduct(data, data);
    }
}
示例#6
0
void MLComputeTest::correlation_benchmark_parallel()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        correlation_parallel(data, data);
    }
}
示例#7
0
void MLComputeTest::correlation_benchmark_alternative()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        correlation_helper(data, data);
    }
}
示例#8
0
void MLComputeTest::stdev_benchmark()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        MLCompute::stdev(data);
    }
}
示例#9
0
 LPSolver(const VD &b, const VD &c) : 
   m(b.size()), n(c.size()), N(n+1), B(m), D(m+2, VD(n+2)) {
   for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) D[i][j] = AA[i][j];
   for (int i = 0; i < m; i++) { B[i] = n+i; D[i][n] = -1; D[i][n+1] = b[i]; }
   for (int j = 0; j < n; j++) { N[j] = j; D[m][j] = -c[j]; }
   N[n] = -1; D[m+1][n] = 1;
   /*for (int i = 0; i < m+2; i++) {
    for (int j = 0; j < n+2; j++){ cout<<D[i][j]<<" ";}
    cout<<endl;
   }*/
 }
示例#10
0
int main() {
  int n;
  cin >> n;
  VD arr(n+1);
  for (int i = 0; i <= n; i++) cin >> arr[i];
  
  VD ans = roots(poly(arr));
  cout << ans.size() << endl;
  for (int i = 0; i < ans.size(); i++) printf("%.4f\n", ans[i]);
  
  return 0;
}
示例#11
0
void MLComputeTest::min_benchmark()
{
    VD data;
    data.reserve(10000);
    for (int i = 0; i < 10000; ++i) {
        data.append(-10000 + qrand());
    }
    QBENCHMARK
    {
        MLCompute::min(data.size(), data.data());
    }
}
示例#12
0
VD generateVoronoi(int ** setPoints, int numberofPoints){
	VD vd;

	int i = 0;
	for(i = 0; i < numberofPoints * 3; i+=3){
		Site_2 p(Point_2((*setPoints)[i], (*setPoints)[i + 1]));
		vd.insert(p);
	}

	return vd;

}
示例#13
0
 void set(VVD & A, VD & B, VD & C) {
   n = C.size();
   m = A.size();
   left.resize(m);
   up.resize(n);
   pos.resize(n);
   res.resize(n);
   status = -2;
   v = 0;
   a = A;
   b = B;
   c = C;
 }
示例#14
0
  void solve() {
    for (int i = 0; i < n; i++)
      up[i] = i;
    for (int i = 0; i < m; i++)
      left[i] = i + n;

    while (1) {
      int x = -1;
      for (int i = 0; i < m; i++)
        if (lt(b[i], 0) && (x == -1 || b[i] < b[x])) {
          x = i;
        }
      if (x == -1) break;
      int y = -1;
      for (int j = 0; j < n; j++)
        if (lt(a[x][j], 0)) {
          y = j; 
          break;
        }
      if (y == -1) {
        status = -1;
        return;
        assert(false); // no solution
      }
      pivot(x, y);
    }
    while (1) {
      int y = -1;
      for (int i = 0; i < n; i++)
          if (lt(0, c[i])  && (y == -1 || (c[i] > c[y]))) {
              y = i;
          }
      if (y == -1) break;
      
      int x = -1;
      for (int i = 0; i < m; i++) {
          if (lt(0, a[i][y])) {
              if (x == -1 || (b[i] / a[i][y] < b[x] / a[x][y])) {
                  x = i;
              } 
          }
      }
      if (y == -1) {
          status = 1;
          return;
          assert(false); // infinite solution
      }
      pivot(x, y);
    }

    res.assign(n, 0);

    for (int i = 0; i < m; i++) {
        if (left[i] < n) {
            res[left[i]] = b[i];
        }
    }
    status = 0;
  }
示例#15
0
VD roots(const poly &p) {
  if (p.is_constant()) return VD(0);
  VD critical_values = roots(p.derivative());
  critical_values.push_back(1e6);
  
  VD ans;
  double lower = -1e6;
  for (int i = 0; i < critical_values.size(); i++) {
    double upper = critical_values[i];
    if (sgn(p.eval(lower)) != sgn(p.eval(upper)))
      ans.push_back(bisect(p, lower, upper));
    
    lower = upper;
  }
  
  return ans;
}
示例#16
0
 double eval(double x) const {
   double ans = 0;
   for (int i = coeff.size() - 1; i >= 0; i--) {
     ans *= x;
     ans += coeff[i];
   }
   return ans;
 }
示例#17
0
void init(VD & t, int & n, PDD * p, PDD & a, PDD & b) {
	t.clear();
	double tmp;
	for (int i = 0; i < n; ++i) {
		scanf("%lf", &tmp);
		t.PB(tmp);
	}
	std::sort(t.begin(), t.end());
	t.erase(std::unique(t.begin(), t.end()), t.end());
	n = t.size();
	for (int i = 0; i < n; ++i) {
		p[i] = at(a, b, t[i]);
	}
}
示例#18
0
 virtual QStringList
 formatFromPixelCoordinate( const VD & pix ) override
 {
     CARTA_ASSERT( pix.size() >= 2 );
     QStringList res;
     res.append( QString::number( pix[0] ) );
     res.append( QString::number( pix[1] ) );
     return res;
 }
示例#19
0
DotNode* GraphKMeans::getNextMean(const vector<DotNode*>& means, ConnectedDotGraph& g)
{
	VD minDist;
	for (int i = 0; i < (int)g.nodes.size(); i++)
	{
		double minD = 123456789.0;
		for (int j = 0; j < (int)means.size(); j++)
		{
			double d = g.getShortestPath(g.nodes[i], means[j], true);
			minD = min(minD, d);
		}

		minDist.push_back(Sqr2(minD));
	}

	int p = randWithProbability(minDist);
	if (minDist[p] < 1e-6) return NULL;

	return g.nodes[p];
}
示例#20
0
void MLComputeTest::dotProduct_benchmark_arrays()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        MLCompute::dotProduct(data.size(), data.data(), data.data());
    }
}
示例#21
0
void MLComputeTest::dotProduct_benchmark_inner_product()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        std::inner_product(data.constBegin(), data.constEnd(), data.constBegin(), 0);
    }
}
示例#22
0
void MLComputeTest::mean_benchmark_alternative()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        (void)(std::accumulate(data.constBegin(), data.constEnd(), 0) / data.size());
    }
}
示例#23
0
double stdev_helper(const VD& data)
{
    double sumsqr = std::inner_product(data.constBegin(), data.constEnd(), data.constBegin(), 0);
    double sum = std::accumulate(data.constBegin(), data.constEnd(), 0);
    const int ct = data.size();
    return sqrt((sumsqr - sum * sum / ct) / (ct - 1));
}
示例#24
0
double correlation_parallel(const VD& data1, const VD& data2)
{
    if (data1.size() != data2.size())
        return 0;
    std::promise<corr_intermediate> sum1_promise;
    std::future<corr_intermediate> sum1_future = sum1_promise.get_future();
    std::thread sum1_thread(
        correlation_parallel_helper,
        data1.begin(), data1.end(),
        std::move(sum1_promise));
    std::promise<corr_intermediate> sum2_promise;
    std::future<corr_intermediate> sum2_future = sum2_promise.get_future();
    std::thread sum2_thread(
        correlation_parallel_helper,
        data2.begin(), data2.end(),
        std::move(sum2_promise));

    corr_intermediate itm1 = std::move(sum1_future.get());
    corr_intermediate itm2 = std::move(sum2_future.get());
    sum1_thread.join();
    sum2_thread.join();
    if (!itm1.stdev || !itm2.stdev)
        return 0;
    return std::inner_product(itm1.Y.constBegin(), itm1.Y.constEnd(), itm2.Y.constBegin(), 0);
}
示例#25
0
vector<Item> fixItems(vector<Item>& curItems, int curRoadId)
{
	vector<Item> goodItems;
	VD sps;
	int curTime = -1;

	for (int i = 0; i < (int)curItems.size(); i++)
	{
		if ( curItems[i].time == curTime )
		{
			sps.push_back(curItems[i].speed);
		}
		else
		{
			if ( !sps.empty() ) 
				goodItems.push_back(Item(curTime, MedianValue(sps)));
			sps.clear();
			sps.push_back(curItems[i].speed);
			curTime = curItems[i].time;
		}
	}

	if ( !sps.empty() ) 
		goodItems.push_back(Item(curTime, MedianValue(sps)));

	return goodItems;
}
示例#26
0
int main(){
     int n;
     while(cin >> n and n){
          vector<point> myGoats(n);
          for(int i = 0; i < n; ++i){
               double x,y;
               cin >> x >> y;
               myGoats[i] = (point(x,y));
          }          
          map< int, pair<int,int> > At;
          VD b;
          VD c (n,1);
          int cont = 0;
          for(int i = 0; i < n; ++i){
               for(int j = i + 1; j < n; ++j){
                    b.push_back(myGoats[i].dist2point(myGoats[j]));
                    At[cont].first = i;
                    At[cont].second = j;
                    cont += 1;
               }
          }
          
          for(int i = 0; i < b.size(); ++i) for(int j = 0; j < n; ++j) AA[i][j] = 0;
          for(int i = 0; i < b.size(); ++i){
               AA[i][At[i].first] = 1;
               AA[i][At[i].second] = 1;
          } 
          
          VD x;
          LPSolver mySolver = LPSolver( b, c);
          double d = mySolver.Solve(x);
          //double acum = 0.0;
          //for(int i = 0; i < n; ++i) acum += x[i];
          printf("%.2f\n", d);
     }
     return 0;
}
示例#27
0
void MLComputeTest::sum_benchmark_accumulate()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        std::accumulate(data.constBegin(), data.constEnd(), 0);
    }
}
示例#28
0
MotionPlannerGraph*
MotionPlanner::init_graph(int island_idx)
{
    if (this->graphs[island_idx + 1] == NULL) {
        Polygons pp;
        if (island_idx == -1) {
            pp = this->outer;
        } else {
            pp = this->inner[island_idx];
        }
        
        MotionPlannerGraph* graph = this->graphs[island_idx + 1] = new MotionPlannerGraph();
        
        // add polygon boundaries as edges
        size_t node_idx = 0;
        Lines lines;
        for (Polygons::const_iterator polygon = pp.begin(); polygon != pp.end(); ++polygon) {
            graph->nodes.push_back(polygon->points.back());
            node_idx++;
            for (Points::const_iterator p = polygon->points.begin(); p != polygon->points.end(); ++p) {
                graph->nodes.push_back(*p);
                double dist = graph->nodes[node_idx-1].distance_to(*p);
                graph->add_edge(node_idx-1, node_idx, dist);
                graph->add_edge(node_idx, node_idx-1, dist);
                node_idx++;
            }
            polygon->lines(&lines);
        }
        
        // add Voronoi edges as internal edges
        {
            typedef voronoi_diagram<double> VD;
            typedef std::map<const VD::vertex_type*,size_t> t_vd_vertices;
            VD vd;
            t_vd_vertices vd_vertices;
            
            boost::polygon::construct_voronoi(lines.begin(), lines.end(), &vd);
            for (VD::const_edge_iterator edge = vd.edges().begin(); edge != vd.edges().end(); ++edge) {
                if (edge->is_infinite()) continue;
                
                const VD::vertex_type* v0 = edge->vertex0();
                const VD::vertex_type* v1 = edge->vertex1();
                Point p0 = Point(v0->x(), v0->y());
                Point p1 = Point(v1->x(), v1->y());
                // contains() should probably be faster than contains(),
                // and should it fail on any boundary points it's not a big problem
                if (island_idx == -1) {
                    if (!this->outer.contains(p0) || !this->outer.contains(p1)) continue;
                } else {
                    if (!this->inner[island_idx].contains(p0) || !this->inner[island_idx].contains(p1)) continue;
                }
                
                t_vd_vertices::const_iterator i_v0 = vd_vertices.find(v0);
                size_t v0_idx;
                if (i_v0 == vd_vertices.end()) {
                    graph->nodes.push_back(p0);
                    v0_idx = node_idx;
                    vd_vertices[v0] = node_idx;
                    node_idx++;
                } else {
                    v0_idx = i_v0->second;
                }
                
                t_vd_vertices::const_iterator i_v1 = vd_vertices.find(v1);
                size_t v1_idx;
                if (i_v1 == vd_vertices.end()) {
                    graph->nodes.push_back(p1);
                    v1_idx = node_idx;
                    vd_vertices[v1] = node_idx;
                    node_idx++;
                } else {
                    v1_idx = i_v1->second;
                }
                
                double dist = graph->nodes[v0_idx].distance_to(graph->nodes[v1_idx]);
                graph->add_edge(v0_idx, v1_idx, dist);
            }
        }
        
        return graph;
    }
    return this->graphs[island_idx + 1];
}
示例#29
0
MotionPlannerGraph*
MotionPlanner::init_graph(int island_idx)
{
    if (this->graphs[island_idx + 1] == NULL) {
        // if this graph doesn't exist, initialize it
        MotionPlannerGraph* graph = this->graphs[island_idx + 1] = new MotionPlannerGraph();
        
        /*  We don't add polygon boundaries as graph edges, because we'd need to connect
            them to the Voronoi-generated edges by recognizing coinciding nodes. */
        
        typedef voronoi_diagram<double> VD;
        VD vd;
        
        // mapping between Voronoi vertices and graph nodes
        typedef std::map<const VD::vertex_type*,size_t> t_vd_vertices;
        t_vd_vertices vd_vertices;
        
        // get boundaries as lines
        ExPolygonCollection env = this->get_env(island_idx);
        Lines lines = env.lines();
        boost::polygon::construct_voronoi(lines.begin(), lines.end(), &vd);
        
        // traverse the Voronoi diagram and generate graph nodes and edges
        for (VD::const_edge_iterator edge = vd.edges().begin(); edge != vd.edges().end(); ++edge) {
            if (edge->is_infinite()) continue;
            
            const VD::vertex_type* v0 = edge->vertex0();
            const VD::vertex_type* v1 = edge->vertex1();
            Point p0 = Point(v0->x(), v0->y());
            Point p1 = Point(v1->x(), v1->y());
            
            // skip edge if any of its endpoints is outside our configuration space
            if (!env.contains_b(p0) || !env.contains_b(p1)) continue;
            
            t_vd_vertices::const_iterator i_v0 = vd_vertices.find(v0);
            size_t v0_idx;
            if (i_v0 == vd_vertices.end()) {
                graph->nodes.push_back(p0);
                vd_vertices[v0] = v0_idx = graph->nodes.size()-1;
            } else {
                v0_idx = i_v0->second;
            }
            
            t_vd_vertices::const_iterator i_v1 = vd_vertices.find(v1);
            size_t v1_idx;
            if (i_v1 == vd_vertices.end()) {
                graph->nodes.push_back(p1);
                vd_vertices[v1] = v1_idx = graph->nodes.size()-1;
            } else {
                v1_idx = i_v1->second;
            }
            
            // Euclidean distance is used as weight for the graph edge
            double dist = graph->nodes[v0_idx].distance_to(graph->nodes[v1_idx]);
            graph->add_edge(v0_idx, v1_idx, dist);
        }
        
        return graph;
    }
    return this->graphs[island_idx + 1];
}
示例#30
0
int main() {
  int n;
  scanf("%d", &n);
  int cnt = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      scanf("%d", g[i]+j), to[i][j] = j, di[i][j] = g[i][j];
      if (g[i][j] > 0) {
        id[i][j] = cnt++;
      }
    }
  }
  for (int k = 0; k < n; ++k) {
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < n; ++j) {
        if (g[i][k] < 0 || g[k][j] < 0) continue;
        if (g[i][j] < 0 || g[i][j] > g[i][k] + g[k][j]) {
          g[i][j] = g[i][k] + g[k][j];
          to[i][j] = to[i][k];
        }
      }
    }
  }
  VVD A;
  VD B;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      if (di[i][j] <= 0) continue;
      VD cur(cnt, 0);
      cur[id[i][j]] = 1;
      A.push_back(cur);
      B.push_back(1 * di[i][j]);
    }
  }
  int r;
  scanf("%d", &r);
  for (int i = 0; i < r; ++i) {
    int s, d, t;
    scanf("%d %d %d", &s, &d, &t);
    t -= g[s][d];
    VD cur(cnt, 0);
    while (s != d) {
      int v = to[s][d];
      cur[id[s][v]] = 1;
      s = v;
    }
    A.push_back(cur);
    B.push_back(t + EPS);
    for (int j = 0; j < cnt; ++j)
      cur[j] *= -1;
    A.push_back(cur);
    B.push_back(-t + EPS);
  }
  int q;
  scanf("%d", &q);
  simplex solver;
  for (int i = 0; i < q; ++i) {
    int s, d;
    scanf("%d %d", &s, &d);
    LD low = g[s][d], up = g[s][d] * 2;
    if (g[s][d] != 0) {
      VD x(cnt), c(cnt);
      int now = s;
      while (now != d) {
        int v = to[now][d];
        c[id[now][v]] = 1;
        now = v;
      }
      solver.set(A, B, c);
      solver.solve();
      if (solver.status == 0) up = solver.v + g[s][d];
      for (int j = 0; j < cnt; ++j)
        c[j] *= -1;
      solver.set(A, B, c);
      solver.solve();
      if (solver.status == 0) low = -solver.v + g[s][d];
    }
    printf("%d %d %.20lf %.20lf\n", s, d, (double)low, (double)up);
  }
  return 0;
}