Exemplo n.º 1
1
void Pages::oauth(Document *doc){
    if(path != "/oauth/yt" && path != "/oauth/yt/unlink")
        return;

    if(!Session::user())
        return doc->redirect("/login?redirect=/account");

    Youtube yt(Session::user().id);

    if(path == "/oauth/yt"){
        std::string error = cgi("error");
        std::string code = cgi("code");
        if (!error.empty() || code.empty())
            return doc->redirect("/account");

        doc->setHtml("html/bsod.tpl", "Linking your YouTube account");
        if (!code.empty() && yt.link(code)){
            doc->dict()->SetValue("TITLE", "Success");
            doc->dict()->SetValue("MESSAGE", "Your YouTube account is now linked to your EqBeats account.");
        } else {
            doc->dict()->SetValue("TITLE", "There was a problem");
            doc->dict()->SetValue("MESSAGE", "Try again in a few minutes. If it still doesn't work, drop us a note.");
        }
    }
    else if (path == "/oauth/yt/unlink"){
        yt.unlink();
        doc->redirect("/account");
    }
}
OpenANN::Environment::State DoublePoleBalancing::rk4(const State& s, double force, const State& der)
{
  const double TIME_DELTA = 0.01;
  State result(6);

  double hh = TIME_DELTA * 0.5, h6 = TIME_DELTA / 6.0;
  State dym(6);
  State dyt(6);
  State yt(6);

  yt = s + hh * der;
  dyt = derivative(yt, force);
  dyt(0) = yt(1);
  dyt(2) = yt(3);
  dyt(4) = yt(5);
  yt = s + hh * dyt;
  dym = derivative(yt, force);
  dym(0) = yt(1);
  dym(2) = yt(3);
  dym(4) = yt(5);
  yt = s + TIME_DELTA * dym;
  dym += dyt;
  dyt = derivative(yt, force);
  dyt(0) = yt(1);
  dyt(2) = yt(3);
  dyt(4) = yt(5);
  result = s + h6 * (der + dyt + 2.0 * dym);

  return result;
}
Exemplo n.º 3
0
void MyWidget::process()
{
    ui->plainTextEdit->clear();
    variant = ui->comboBox->currentIndex();
    print(QString("Variant %1").arg(variant));
    print(QString("[%1; %2]").arg(x0(), 0, 'g', 5).arg(xFinish(), 0, 'g', 3));

    //calc

    qreal x = x0(), y = y0(), z = z0();
    for (int i = 1; x < xFinish() || qFuzzyCompare(x, xFinish()); ++i)
    {
        qreal k1 = h() * f(x, y, z);
        qreal q1 = h() * g(x, y, z);

        qreal k2 = h() * f(x + h() / 2.0, y + k1 / 2.0, z + q1 / 2.0);
        qreal q2 = h() * g(x + h() / 2.0, y + k1 / 2.0, z + q1 / 2.0);

        qreal k3 = h() * f(x + h() / 2.0, y + k2 / 2.0, z + q2 / 2.0);
        qreal q3 = h() * g(x + h() / 2.0, y + k2 / 2.0, z + q2 / 2.0);

        qreal k4 = h() * f(x + h(), y + k3, z + q3);
        qreal q4 = h() * g(x + h(), y + k3, z + q3);

        print(QString("#%1").arg(i));
        print(QString("y(%1) = %2").arg(x, 0, 'g', 5).arg(y, 0, 'g', 5));
        print(QString("y_ex(%1) = %2").arg(x, 0, 'g',5).arg(yt(x), 0, 'g', 5));
        print(QString("error(%1) = %2").arg(x, 0, 'g',5).arg(ypo(y, x), 0, 'g', 5));

        x += h();
        y += (k1 + 2.0 * k2 + 2.0 * k3 + k4) / 6.0;
        z += (q1 + 2.0 * q2 + 2.0 * q3 + q4) / 6.0;

    }
}
Exemplo n.º 4
0
void TEpidemModel::RungeKutta(const TFltV& y, const TFltV& dydx, double x, double h, TFltV& SirOutV) {
  const int n = y.Len();
  IAssert(y.Len() == n && dydx.Len() == n);
  TFltV dym(n), dyt(n), yt(n);
  int i;
  double hh=h*0.5;
  double h6=h/6.0;
  double xh=x+hh;
  for (i=0; i < n; i++) {
    yt[i]=y[i]+hh*dydx[i];
  }
  GetDerivs(xh, yt, dyt);
  for (i=0; i<n; i++) {
    yt[i]=y[i]+hh*dyt[i];
  }
  GetDerivs(xh,yt,dym);
  for (i=0; i<n; i++) {
	  yt[i]=y[i]+h*dym[i];
	  dym[i] += dyt[i];
  }
  GetDerivs(x+h,yt,dyt);
  SirOutV.Clr(false);  
  for (i=0; i<n; i++) {
    SirOutV.Add(y[i]+h6 * (dydx[i]+dyt[i]+2.0*dym[i]));
  }
}
Exemplo n.º 5
0
int main()
{
    size_t n = 1000;
    std::vector<double> x, y;

    const double w = 0.05;
    const double a = n/2;

    for (size_t i=0; i<n; i++) {
        x.push_back(i);
        y.push_back(a*sin(w*i));
    }

    std::vector<double> xt(2), yt(2);

    plt::title("Tangent of a sine curve");
    plt::xlim(x.front(), x.back());
    plt::ylim(-a, a);
    plt::axis("equal");

    // Plot sin once and for all.
    plt::named_plot("sin", x, y);

    // Prepare plotting the tangent.
    plt::Plot plot("tangent");

    plt::legend();

    for (size_t i=0; i<n; i++) {
        if (i % 10 == 0) {
            update_window(x[i], y[i], a*w*cos(w*x[i]), xt, yt);

            // Just update data for this plot.
            plot.update(xt, yt);

            // Small pause so the viewer has a chance to enjoy the animation.
            plt::pause(0.1);
        }
   }
}
Exemplo n.º 6
0
Adaboost<MatType, WeakLearner>::Adaboost(const MatType& data, 
        const arma::Row<size_t>& labels, int iterations, 
        size_t classes, const WeakLearner& other)
{
  // note: put a fail safe for the variable 'classes' or 
  // remove it entirely by using unique function.
  int i, j, k;
  double rt, alphat = 0.0, zt;
  
  // To be used for prediction by the Weak Learner for prediction.
  arma::Row<size_t> predictedLabels(labels.n_cols);
  
  // Use tempData to modify input Data for incorporating weights.
  MatType tempData(data);
  
  // Build the classification Matrix yt from labels
  arma::mat yt(predictedLabels.n_cols, classes);
  
  // Build a classification matrix of the form D(i,l)
  // where i is the ith instance
  // l is the lth class.
  buildClassificationMatrix(yt, labels);
  
  // ht(x), to be loaded after a round of prediction every time the weak
  // learner is run, by using the buildClassificationMatrix function
  arma::mat ht(predictedLabels.n_cols, classes);

  // This matrix is a helper matrix used to calculate the final hypothesis.
  arma::mat sumFinalH(predictedLabels.n_cols, classes);
  sumFinalH.fill(0.0);
  
  // load the initial weights into a 2-D matrix
  const double initWeight = (double) 1 / (data.n_cols * classes);
  arma::mat D(data.n_cols, classes);
  D.fill(initWeight);
  // D.print("The value of D after initialization.");
  
  // Weights are to be compressed into this rowvector
  // for focussing on the perceptron weights.
  arma::rowvec weights(predictedLabels.n_cols);
  // weights.print("This is the value of weight just after initialization.");
  // This is the final hypothesis.
  arma::rowvec finalH(predictedLabels.n_cols);

  // now start the boosting rounds
  for (i = 0; i < iterations; i++)
  {
    std::cout<<"Run "<<i<<" times !\n";
    // Initialized to zero in every round.
    rt = 0.0; 
    zt = 0.0;
    
    // Build the weight vectors
    D.print("The value of D in each iteration, just before going for training.");
    buildWeightMatrix(D, weights);
    // D.print("This is the value of D, before sending off to modify data");
    // call the other weak learner and train the labels.
    WeakLearner w(other, tempData, weights, labels);
    w.Classify(tempData, predictedLabels);

    //Now from predictedLabels, build ht, the weak hypothesis
    buildClassificationMatrix(ht, predictedLabels);

    // Now, start calculation of alpha(t) using ht
    
    // begin calculation of rt

    for (j = 0;j < ht.n_rows; j++)
    {
      for (k = 0;k < ht.n_cols; k++)
        rt += (D(j,k) * yt(j,k) * ht(j,k));
    }

    // end calculation of rt

    alphat = 0.5 * log((1 + rt) / (1 - rt));

    // end calculation of alphat
    
    // now start modifying weights

    for (j = 0;j < D.n_rows; j++)
    {
      for (k = 0;k < D.n_cols; k++)
      {  
        // we calculate zt, the normalization constant
        zt += D(j,k) * exp(-1 * alphat * yt(j,k) * ht(j,k));
        D(j,k) = D(j,k) * exp(-1 * alphat * yt(j,k) * ht(j,k));

        // adding to the matrix of FinalHypothesis 
        sumFinalH(j,k) += (alphat * ht(j,k));
      }
    }

    // normalization of D

    D = D / zt;
  
  }

  // Iterations are over, now build a strong hypothesis
  // from a weighted combination of these weak hypotheses.
  
  // This step of storing it in a temporary row vector can be improved upon ? 
  arma::rowvec tempSumFinalH;
  arma::uword max_index;
  for (i = 0;i < sumFinalH.n_rows; i++)
  {
    tempSumFinalH = sumFinalH.row(i);
    tempSumFinalH.max(max_index);
    finalH(i) = max_index;
  }
  // labels.print("These are the labels.");
  finalH.print("This is the final hypothesis.");
  int counterror = 0;
  for (i = 0; i < labels.n_cols; i++)
    if(labels(i) != finalH(i))
    { 
      std::cout<<i<<"th prediction not correct!\n";
      counterror++;
    }
  std::cout<<"There are "<<counterror<<" number of misclassified records.\n";  
  std::cout<<"The error rate is: "<<(double)counterror/labels.n_cols;
  //finalH is the final hypothesis.
}
Exemplo n.º 7
0
void graph(FILE * fp)
{
   static char buf[BUFLNG], arg[BUFLNG / 2], xtype[16], ytype[16];
   static double xa, ya, xap, yap, xmin, xmax, ymin, ymax;
   static double xs = -NSCALE, ys = -NSCALE;
   int n, c;
   char *s, *p;
   double x, y, lpt, th, dt, lscale, rad;
   int is_grid, old_lbl = 0;
   char xory;

   h *= fct;
   w *= fct;

   for (n = 0; (s = fgets(buf, BUFLNG, fp));) {
      s = getarg(s, arg);
      if (s == NULL || *arg == '#');    /* comment line */
      else if ((!is_t && strcmp(arg, "x") == 0)
               || (is_t && strcmp(arg, "y") == 0)) {
         s = gettyp(s, xtype);
         if (sscanf(s, "%lf %lf %lf", &xmin, &xmax, &xa) != 3)
            xa = xmin;
         if (strncmp(xtype, "log", 3) == 0) {
            xmin = log10(xmin);
            xmax = log10(xmax);
            xa = log10(xa);
            is_xlog = (xtype[3] == '*') ? -1 : 1;
         }
         xfct = xl / (xmax - xmin);
         xap = (xa - xmin) * xfct;
         x00 = -xmin * xfct;
      } else if ((!is_t && strcmp(arg, "y") == 0)
                 || (is_t && strcmp(arg, "x") == 0)) {
         s = gettyp(s, ytype);
         if (sscanf(s, "%lf %lf %lf", &ymin, &ymax, &ya) != 3)
            ya = ymin;
         if (strncmp(ytype, "log", 3) == 0) {
            ymin = log10(ymin);
            ymax = log10(ymax);
            ya = log10(ya);
            is_ylog = (ytype[3] == '*') ? -1 : 1;
         }
         yfct = (yl) ? yl / (ymax - ymin) : 0;
         yap = (ya - ymin) * yfct;
         y00 = -ymin * yfct;
      } else if ((!is_t && strncmp(arg, "xscale", 6) == 0)
                 || (is_t && strncmp(arg, "yscale", 6) == 0)) {
         is_grid = *(arg + 6);
         if (type < 0 || (ya != ymin && ya != ymax)) {
            plot(0.0, yap, 3);
            plot(xl, yap, 2);
         }
         ys = yap - h - MSCALE;
         while ((s = getarg(s, p = arg)) != NULL) {
            if (*p != '"') {
               x = atof((is_number(*p)) ? p : p + 1);
               if (strncmp(xtype, "mel", 3) == 0)
                  x = argapf(x / nz(xmax, xmin),
                             atof(xtype + 3)) * nz(xmax, xmin);
               else if (is_xlog)
                  x = log10(x);
               x = (x - xmin) * xfct;
               lscale = (*p == 's') ? LSCALE / 2 : LSCALE;
               if (*p != '\\' && *p != '@') {
                  plot(x, yap, 3);
                  plot(x, yap + lscale, 2);
                  if (type > 0 && !is_grid && yap == 0) {
                     plot(x, yl, 3);
                     plot(x, yl - lscale, 2);
                  }
               } else if (*p == '\\')
                  ++p;
            }
            if (is_number(*p) || *p++ == '"')
               _symbol(x - sleng(p, h, w) / 2, ys - ysadj(), p, h, w, 0.0);
         }
      } else if ((!is_t && strncmp(arg, "yscale", 6) == 0)
                 || (is_t && strncmp(arg, "xscale", 6) == 0)) {
         is_grid = *(arg + 6);
         if (type < 0 || (xa != xmin && xa != xmax)) {
            plot(xap, 0.0, 3);
            plot(xap, yl, 2);
         }
         while ((s = getarg(s, p = arg)) != NULL) {
            if (*p != '"') {
               y = atof((is_number(*p)) ? p : p + 1);
               if (strncmp(ytype, "mel", 3) == 0)
                  y = argapf(y / nz(ymax, ymin),
                             atof(ytype + 3)) * nz(ymax, ymin);
               else if (is_ylog)
                  y = log10(y);
               y = (y - ymin) * yfct;
               lscale = (*p == 's') ? LSCALE / 2 : LSCALE;
               if (*p != '\\' && *p != '@') {
                  plot(xap, y, 3);
                  plot(xap + lscale, y, 2);
                  if (type > 0 && !is_grid && xap == 0) {
                     plot(xl, y, 3);
                     plot(xl - lscale, y, 2);
                  }
               } else if (*p == '\\')
                  ++p;
            }
            if (is_number(*p) || *p++ == '"') {
               x = xap - sleng(p, h, w) - MSCALE;
               if (x < xs)
                  xs = x;
               _symbol(x, y - h * 0.5, p, h, w, 0.0);
            }
         }
      } else if (strcmp(arg + 1, "grid") == 0) {
         draw_fig0(xbuf, ybuf, n, wf, hf, fct);
         if ((!is_t && (*arg == 'x')) || (is_t && (*arg == 'y'))) {
            ybuf[0] = 0;
            ybuf[1] = yl;
            while ((s = getarg(s, arg)) != NULL) {
               x = atof(arg);
               if (is_xlog)
                  x = log10(x);
               xbuf[0] = xbuf[1]
                   = (x - xmin) * xfct;
               draw_fig0(xbuf, ybuf, 2, wf, hf, fct);
            }
         } else {
            xbuf[0] = 0;
            xbuf[1] = xl;
            while ((s = getarg(s, arg)) != NULL) {
               y = atof(arg);
               if (is_ylog)
                  y = log10(y);
               ybuf[0] = ybuf[1]
                   = (y - ymin) * yfct;
               draw_fig0(xbuf, ybuf, 2, wf, hf, fct);
            }
         }
         n = 0;
      } else if (strcmp(arg + 1, "circle") == 0) {
         xory = *arg;
         s = getarg(s, arg);
         x = xt(atof(arg));
         s = getarg(s, arg);
         y = yt(atof(arg));
         swap(&x, &y);
         x = xfct * x + x00;
         y = yfct * y + y00;
         while ((s = getarg(s, arg)) != NULL) {
            if ((!is_t && xory == 'x') || (is_t && xory == 'y'))
               rad = xt(atof(arg)) * xfct;
            else
               rad = yt(atof(arg)) * yfct;
            pntstyl(ptyp);
            circle(x, y, rad, rad, 0., 360.);
         }
      } else if (strcmp(arg, "circle") == 0) {
         s = getarg(s, arg);
         x = xt(atof(arg));
         s = getarg(s, arg);
         y = yt(atof(arg));
         swap(&x, &y);
         x = xfct * x + x00;
         y = yfct * y + y00;
         while ((s = getarg(s, arg)) != NULL) {
            rad = atof(arg);
            pntstyl(ptyp);
            circle(x, y, rad, rad, 0., 360.);
         }
      } else if (strcmp(arg + 1, "name") == 0) {
         s = getname(s, p = arg + 1);
         if ((!is_t && *arg == 'x') || (is_t && *arg == 'y'))
            _symbol((xl - sleng(s, h, w)) / 2,
                    (*p) ? -atof(p) - h : ys - h - NSCALE, s, h, w, 0.0);
         else
            _symbol((*p) ? -atof(p) : xs - MSCALE,
                    (yl - sleng(s, h, w)) / 2, s, h, w, 90.0);
      } else if (strncmp(arg, "title", 5) == 0 || strncmp(arg, "print", 5) == 0) {
         sscanf(s, "%lf %lf", &x, &y);
         swap(&x, &y);
         if (*arg == 'p') {
            x = xfct * xt(x) + x00;
            y = yfct * yt(y) + y00;
         }
         s = gettxt_fig(s);
         th = getarg(s + strlen(s) + 1, arg) ? atof(arg) : 0;
         if (*(arg + 5)) {
            x -= rx(LADJ * h / 2, h / 2, th);
            y -= ry(LADJ * h / 2, h / 2, th);
         }
         _symbol(x, y, s, h, w, th);
      } else if (strcmp(arg, "eod") == 0 || strcmp(arg, "EOD") == 0) {
         draw_fig0(xbuf, ybuf, n, wf, hf, fct);
         n = 0;
      } else if (strcmp(arg, "pen") == 0) {
         n = flush(xbuf, ybuf, n, wf, hf, fct);
         pen(atoi(s));
      } else if (strcmp(arg, "join") == 0) {
         n = flush(xbuf, ybuf, n, wf, hf, fct);
         join(atoi(s));
      } else if (strcmp(arg, "csize") == 0) {
         if (sscanf(s, "%lf %lf", &h, &w) != 2)
            w = h;
      } else if (strcmp(arg, "hight") == 0) {
         if (sscanf(s, "%lf %lf", &mh, &mw) != 2)
            mw = mh;
      } else if (strcmp(arg, "line") == 0) {
         n = flush(xbuf, ybuf, n, wf, hf, fct);
         if (sscanf(s, "%d %lf", &ltype, &lpt) != 2) {
            if (ltype > 0)
               lpt = lpit[ltype - 1];
         }
         if (--ltype >= 0)
            mode(lmod[ltype], lpt);
      } else if (strcmp(arg, "italic") == 0)
         italic(atof(s));
      else if (strcmp(arg, "mark") == 0) {
         while (*s == ' ' || *s == '\t')
            ++s;
         if (*s == '\\' && *(s + 1) == '0')
            *label = '\0';
         else
            strcpy(label, s);
      } else if (strcmp(arg, "paint") == 0) {
         sscanf(s, "%d %lf %lf", &ptyp, &dhat, &that);
      } else if (strcmp(arg, "clip") == 0) {
         draw_fig0(xbuf, ybuf, n, wf, hf, fct);
         for (n = 0; (s = getarg(s, arg)) != NULL; ++n) {
            x = xt(atof(arg));
            if ((s = getarg(s, arg)) == NULL)
               break;
            y = yt(atof(arg));
            swap(&x, &y);
            xbuf[n] = xfct * x + x00;
            ybuf[n] = yfct * y + y00;
         }
         if (n == 0) {
            xclip0 = yclip0 = 0;
            xclip1 = xl;
            yclip1 = yl;
            swap(&xclip1, &yclip1);
         } else if (n == 2) {
            xclip0 = xbuf[0];
            yclip0 = ybuf[0];
            xclip1 = xbuf[1];
            yclip1 = ybuf[1];
         }
         n = 0;
      } else if (strcmp(arg, "box") == 0) {
         draw_fig0(xbuf, ybuf, n, wf, hf, fct);
         for (n = 0; (s = getarg(s, arg)) != NULL; ++n) {
            x = xt(atof(arg));
            if ((s = getarg(s, arg)) == NULL)
               break;
            y = yt(atof(arg));
            swap(&x, &y);
            xbuf[n] = xfct * x + x00;
            ybuf[n] = yfct * y + y00;
         }
         if (n == 2) {
            xbuf[2] = xbuf[1];
            ybuf[3] = ybuf[2] = ybuf[1];
            ybuf[1] = ybuf[0];
            xbuf[3] = xbuf[0];
            n = 4;
         }
         polyg(xbuf, ybuf, n, wf, hf, fct);
         n = 0;
      } else {
         x = xt(atof(arg));
         s = getarg(s, arg);
         y = yt(atof(arg));
         swap(&x, &y);
         xbuf[n] = x = xfct * x + x00;
         ybuf[n] = y = yfct * y + y00;
         if (is_in(x, y) && ((s = getarg(s, arg))
                             || *label || old_lbl > 0)) {
            c = 0;
            if (s || *label) {
               if (s == NULL)
                  s = getarg(label, arg);
               if (*arg == '\\' && (abs(c = atoi(arg + 1))) < 16)
                  mark(abs(c), &x, &y, 1, mh, 1);
               else if (abs(c) == 16) {
                  pntstyl(ptyp);
                  circle(x, y, mh / 2, mh / 2, 0., 360.);
               } else {
                  if (c) {
                     *arg = c;
                     *(arg + 1) = '\0';
                  }
                  _symbol(x - LADJ * h / 2, y - w / 2, arg, h, w, atof(s));
               }
            }
            if (c > 0)
               n = flush(xbuf, ybuf, n, wf, hf, fct);
            if ((c > 0 || old_lbl > 0) && n) {
               dt = atan2(y - ybuf[0], x - xbuf[0]);
               if (old_lbl > 0) {
                  xbuf[0] += MADJ * mh * cos(dt);
                  ybuf[0] += MADJ * mh * sin(dt);
               }
               if (c > 0) {
                  xbuf[1] -= MADJ * mh * cos(dt);
                  ybuf[1] -= MADJ * mh * sin(dt);
               }
               draw_fig0(xbuf, ybuf, 2, wf, hf, fct);
               xbuf[0] = x;
               ybuf[0] = y;
               n = 0;
            }
            old_lbl = c;
         }
         if (++n >= BUFLNG)
            n = flush(xbuf, ybuf, n, wf, hf, fct);
      }
   }
   draw_fig0(xbuf, ybuf, n, wf, hf, fct);
}
Exemplo n.º 8
0
void YoungTableauTest::Init(void)
{
	Add("Test 1", [&]() {
		int A[20];
		for (int i = 0; i < 20; i++) {
			A[i] = 20 - i;
		}

		Test::YoungTableau<int> yt(4, 5);
		yt.SortRows(A, 20);
		Logger().Print(A, 20, yt.Columns());

		yt.SortColumns(A, 20);
		Logger().Print(A, 20, yt.Columns());

		ASSERT1(yt.Verify(A, 20));
	});

	Add("Test 2", [&]() {
		int A[20];
		for (int i = 0; i < 20; i++) {
			A[i] = 20 - i;
		}

		Test::YoungTableau<int> yt1(4, 5, A, 20);
		Logger() << yt1;
		ASSERT1(yt1.Verify());

		Test::YoungTableau<int> yt2(4, 5);
		yt2.Init(A, 20);
		Logger() << yt2;
		ASSERT1(yt2.Verify());

		yt2.Create(A, 20);
		Logger().Print(A, 20, yt2.Columns());
		ASSERT1(yt2.Verify(A, 20));
	});

	Add("Test 3", [&]() {
		int A[20];
		for (int i = 0; i < 20; i++) {
			A[i] = 20 - i;
		}

		Test::YoungTableau<int> yt(5, 4, A, 20);
		Logger() << yt;
		ASSERT1(yt.Verify());
	});

	Add("Test 4", [&]() {
		int A[20];
		for (int i = 0; i < 20; i++) {
			A[i] = 20 - i;
		}

		Test::YoungTableau<int> yt(3, 7);
		yt.Push(A, 20);
		Logger() << yt;
		ASSERT1(yt.Verify());
	});

	Add("Test 5", [&]() {
		int A[20];
		for (int i = 0; i < 20; i++) {
			A[i] = 20 - i;
		}

		Test::YoungTableau<int> yt(7, 3);
		yt.Init(A, 20);
		Logger() << yt;
		ASSERT1(yt.Verify());
	});

	Add("Test 6", [&]() {
		int A[20];
		for (int i = 0; i < 20; i++) {
			A[i] = 20 - i;
		}

		Test::YoungTableau<int> yt(2, 13);
		yt.Init(A, 20);
		Logger() << yt;
		ASSERT1(yt.Verify());
	});

	Add("Test 7", [&]() {
		int A[20];
		for (int i = 0; i < 20; i++) {
			A[i] = 20 - i;
		}

		Test::YoungTableau<int> yt(2, 19);
		yt.Push(A, 20);
		Logger() << yt;
		ASSERT1(yt.Verify());
	});

	Add("Test 8", [&]() {
		int A[20];
		for (int i = 0; i < 20; i++) {
			A[i] = 20 - i;
		}

		Test::YoungTableau<int> yt(1, 20);
		yt.Init(A, 20);
		Logger() << yt;
		ASSERT1(yt.Verify());
	});

	Add("Test 9", [&]() {
		int A[20];
		for (int i = 0; i < 20; i++) {
			A[i] = 20 - i;
		}

		Test::YoungTableau<int> yt(1, 21, A, 20);
		Logger() << yt;
		ASSERT1(yt.Verify());
	});

	Add("Test 10", [&]() {
		int A = 1;

		Test::YoungTableau<int> yt(1, 21);
		yt.Push(&A, 1);
		Logger() << yt;
		ASSERT1(yt.Verify());
	});

	Add("Test 11", [&]() {
		for (int i = 0; i < 100; i++) {
			int lenA = 1 + Test::Random::Next();
			unique_ptr<int[]> A(new int[lenA]);
			
			int lenB = 1 + Test::Random::Next();
			unique_ptr<int[]> B(new int[lenB]);
			
			for (int j = 0; j < lenA; j++) {
				A[j] = Test::Random::Next();
			}

			for (int j = 0; j < lenB; j++) {
				B[j] = Test::Random::Next();
			}
			
			int len = max(500, max(lenA, lenB) >> 3);
			int cols = Test::Random::Next(1, len >> 3);
			int rows = Test::Random::Next(1, (len / cols) << 3);

			Logger().WriteInformation("Run %d, tableau %d X %d, , %d elements and then push %d elements\n", i, rows, cols, lenA, lenB);
			Test::YoungTableau<int> yt(rows, cols);
			yt.Push(A.get(), lenA);
			ASSERT1(yt.Verify());
			yt.Push(B.get(), lenB);
			ASSERT1(yt.Verify());
		}
	});
Exemplo n.º 9
0
void OrganizedData::process(RawData* raw, int nBlock, double pTest, int nSupport)
{
    int nData = raw->nData, nDim = raw->nDim - 1;

    this->nSupport = nSupport;
    this->nBlock   = nBlock;
    this->nDim     = nDim;

    train   = field<mat>(nBlock,2);
    test    = field<mat>(nBlock,2);
    support = field<mat>(1,2);

    mat xm(nSupport,nDim),
        ym(nSupport,1);

    vec mark(nData); mark.fill(0);

    printf("Randomly selecting %d supporting point ...\n", nSupport);

    for (int i = 0; i < nSupport; i++)
	{
		int pos = IRAND(0, nData - 1);
		while (mark[pos] > 0)
			pos = IRAND(0, nData - 1);
		mark[pos] = 1;
		for (int j = 0; j < nDim; j++)
			xm(i, j) = raw->X(pos,j);
		ym(i,0) = raw->X(pos,nDim);
	}

	support(0,0) = xm; xm.clear();
	support(0,1) = ym; ym.clear();

    cout << "Partitioning the remaining data into " << nBlock << " cluster using K-Mean ..." << endl;

    vvd _remain;

    for (int i = 0; i < nData; i++) if (!mark(i))
    {
        rowvec R = raw->X.row(i);
        _remain.push_back(r2v(R));
    }

    mat remaining = v2m(_remain);

    mark.clear();

    RawData* remain = new RawData(remaining);

    KMean* partitioner = new KMean(remain);

    Partition* clusters = partitioner->cluster(nBlock);

    cout << "Packaging training/testing data points into their respective cluster" << endl;

    for (int i = 0; i < nBlock; i++)
    {
        cout << "Processing block " << i + 1 << endl;

        int bSize   = (int) clusters->member[i].size(),
            tSize   = (int) floor(bSize * pTest),
            pos     = 0,
            counter = 0;

        mark = vec(bSize); mark.fill(0);

        if (bSize > tSize)  // if we can afford to draw tSize test points from this block without depleting it ...
        {
            mat xt(tSize,nDim),
                yt(tSize,1);

            for (int j = 0; j < tSize; j++)
            {
                pos = IRAND(0, bSize - 1);
				while (mark[pos] > 0)
					pos = IRAND(0, bSize - 1);
				mark[pos] = 1; pos = clusters->member[i][pos];

				for (int t = 0; t < nDim; t++)
					xt(j, t) = remain->X(pos,t);
				yt(j,0) = remain->X(pos,nDim);
            }

            bSize  -= tSize;
            nTest  += tSize;

            test(i,0) = xt; xt.clear();
            test(i,1) = yt; yt.clear();
        }

        nTrain += bSize;

        mat xb(bSize,nDim),
            yb(bSize,1);

        //cout << remain->X.n_rows << endl;

        for (int j = 0; j < (int)mark.n_elem; j++) if (mark[j] < 1)
        {
            for (int t = 0; t < nDim; t++) {
                xb(counter,t) = remain->X(clusters->member[i][j],t);
            }
            yb(counter++,0) = remain->X(clusters->member[i][j],nDim);
        }

        train(i,0) = xb; xb.clear();
        train(i,1) = yb; yb.clear();

        mark.clear();

        printf("Done ! nData[%d] = %d, nTrain[%d] = %d, nTest[%d] = %d .\n", i, (int) clusters->member[i].size(), i, train(i,0).n_rows, i, (int) test(i,0).n_rows);
    }
}
Exemplo n.º 10
0
void
arrangement::compute_ACScellBeginEnd()
{
    int ncr_begin = -1;
    int ncr_end = -1;

    Walk_pl walk_pl(nonCriticalRegions);

    // get NCR start
    Rational xt(target_centre.x());
    Rational yt(target_centre.y());
    Conic_point_2 pt(xt,yt);
    Arrangement_2::Vertex_handle v = insert_point(nonCriticalRegions, pt, walk_pl);
    try
    {
        ncr_begin = v->face()->data();
        nonCriticalRegions.remove_isolated_vertex(v);
    }
    catch (const std::exception exn)
    {
        target_centre = QPoint(target_centre.x()+1, target_centre.y()+1);
        compute_ACScellBeginEnd();
        return;
    }

    // get NCR end
    Rational xe(target_centre_end.x());
    Rational ye(target_centre_end.y());
    Conic_point_2 pe(xe,ye);
    Arrangement_2::Vertex_handle w = insert_point(nonCriticalRegions, pe, walk_pl);
    try
    {
        ncr_end = w->face()->data();
        nonCriticalRegions.remove_isolated_vertex(w);
    }
    catch (const std::exception exn)
    {
        target_centre_end = QPoint(target_centre_end.x()+1, target_centre_end.y()+1);
        compute_ACScellBeginEnd();
        return;
    }

    // retrieve ACScell
    for (int i = 0; i < (int) ACScells.size(); i++)
    if (ACScells[i].NCR == ncr_begin)
    {
        Rational x(manipulator_centre.x());
        Rational y(manipulator_centre.y());
        Conic_point_2 p(x,y);
        Walk_pl walk(ACScells[i].arr);
        Arrangement_2::Vertex_handle u = insert_point(ACScells[i].arr, p, walk);
        try
        {
            if (!u->face()->is_unbounded())
            {
                ACScells[i].arr.remove_isolated_vertex(u);
                AcscellBegin = i;
                break;
            }
        }
        catch (const std::exception exn)
        {
            manipulator_centre = QPoint(manipulator_centre.x()+1, manipulator_centre.y()+1);
            compute_ACScellBeginEnd();
            return;
        }
    }

    for (int i = 0; i < (int) ACScells.size(); i++)
    if (ACScells[i].NCR == ncr_end)
    {
        Rational x(manipulator_centre_end.x());
        Rational y(manipulator_centre_end.y());
        Conic_point_2 p(x,y);
        Walk_pl walk(ACScells[i].arr);
        Arrangement_2::Vertex_handle u = insert_point(ACScells[i].arr, p, walk);
        try
        {
            if (!u->face()->is_unbounded())
            {
                ACScells[i].arr.remove_isolated_vertex(u);
                AcscellEnd = i;
                break;
            }
        }
        catch (const std::exception exn)
        {
            manipulator_centre_end = QPoint(manipulator_centre_end.x()+1, manipulator_centre_end.y()+1);
            compute_ACScellBeginEnd();
            return;
        }
    }
}
Exemplo n.º 11
0
Transformation Boonas:: parseParams(int start, int argc, char** argv, Transformation matrix) 
{
	QString currIn;
	
	for(int i = start; i < (argc - 1); i += 2) // iterate through parameters skiping every other
	{
		if(strcmp(argv[i], "XT") == 0)
		{
			currIn = argv[i + 1];
			matrix = xt(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "YT") == 0)
		{
			currIn = argv[i + 1];
			matrix = yt(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "ZT") == 0)
		{
			currIn = argv[i + 1];
			matrix = zt(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "XS") == 0)
		{
			currIn = argv[i + 1];
			matrix = xs(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "YS") == 0)
		{
			currIn = argv[i + 1];
			matrix = ys(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "ZS") == 0)
		{
			currIn = argv[i + 1];
			matrix = zs(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "US") == 0)
		{
			currIn = argv[i + 1];
			matrix = us(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "XD") == 0)
		{
			currIn = argv[i + 1];
			matrix = xd(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "YD") == 0)
		{
			currIn = argv[i + 1];
			matrix = yd(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "ZD") == 0)
		{
			currIn = argv[i + 1];
			matrix = zd(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "XR") == 0)
		{
			currIn = argv[i + 1];
			matrix = xr(currIn.toFloat(), matrix);
		}
		else if(strcmp(argv[i], "YR") == 0)
		{
			currIn = argv[i + 1];
			matrix = yr(currIn.toFloat(), matrix);
		}
		else // MUST BE ZR
		{
			currIn = argv[i + 1];
			matrix = zr(currIn.toFloat(), matrix);
		}
	}
	
	return matrix;
}
Exemplo n.º 12
0
void Boonas::doRotate(QString outfile, QString vectx, QString vecty, QString vectz, QString px, QString py, QString pz, QString divisions, QString degrees) 
{
	Point centerP(px.toFloat(), py.toFloat(), pz.toFloat());
	Vector centerV(vectx.toFloat(), vecty.toFloat(), vectz.toFloat());
	Transformation matrix;
	float theta;
	float phi;
	float angleOfRot = degrees.toFloat() / divisions.toFloat();
	
	// translate to x
	matrix = xt(-px.toFloat(), matrix);
	matrix = yt(-py.toFloat(), matrix);
	matrix = zt(-pz.toFloat(), matrix);
	
	
	if(vectz.toFloat() == 0)
	{
		if((vectx.toFloat() == 1) && (vectz.toFloat() == 0))
		{
			theta = 1.57079633;
		}
		else
		{
			theta = 0.0;
		}
	}
	else
	{
		theta = atan(vectx.toFloat() / vectz.toFloat());
	}
	
	matrix = yr(-theta, matrix);
	phi = atan(vecty.toFloat() / (sqrt((vectx.toFloat() * vectx.toFloat()) + (vectz.toFloat() * vectz.toFloat()))));
	matrix = xr(phi, matrix);
	
	// apply matrix
	doMult(matrix);
	
	// do rotates and divisions along Z
	doZrm(outfile, angleOfRot, divisions.toFloat());
	
	// have to re-read from a temp file after this
	delete orig;
	orig = new LNHHolder();
	readTfile(outfile);
	
	//unrotate
	matrix = Transformation();
	matrix = xr(-phi, matrix);
	matrix = yr(theta, matrix);
	
	// untranslate
	matrix = xt(px.toFloat(), matrix);
	matrix = yt(py.toFloat(), matrix);
	matrix = zt(pz.toFloat(), matrix);
	
	// apply matrix
	doMult(matrix);
	
	return;
}