コード例 #1
0
void scan_bulk(const class scanner_params &sp,const recursion_control_block &rcb)
{
    assert(sp.sp_version==scanner_params::CURRENT_SP_VERSION);      
    // startup
    if(sp.phase==scanner_params::PHASE_STARTUP){
        assert(sp.info->si_version==scanner_info::CURRENT_SI_VERSION);
	sp.info->name		= "bulk";
	sp.info->author		= "Simson Garfinkel";
	sp.info->description	= "perform bulk data scan";
	sp.info->flags		= scanner_info::SCANNER_DISABLED | scanner_info::SCANNER_WANTS_NGRAMS | scanner_info::SCANNER_NO_ALL;
	sp.info->feature_names.insert("bulk");
	sp.info->feature_names.insert("bulk_tags");
        sp.info->get_config("bulk_block_size",&opt_bulk_block_size,"Block size (in bytes) for bulk data analysis");

        debug = sp.info->config->debug;

	histogram::precalc_entropy_array(opt_bulk_block_size);

        sp.info->get_config("DFRWS2012",&dfrws_challenge,"True if running DFRWS2012 challenge code");
        return; 
    }
    // classify a buffer
    if(sp.phase==scanner_params::PHASE_SCAN){

	feature_recorder *bulk = sp.fs.get_name("bulk");
	feature_recorder *bulk_tags = sp.fs.get_name("bulk_tags");
    

	if(sp.sbuf.pos0.isRecursive()){
	    /* Record the fact that a recursive call was made, which tells us about the data */
	    bulk_tags->write_tag(sp.sbuf,""); // tag that we found recursive data, not sure what kind
	}

	if(sp.sbuf.pagesize < opt_bulk_block_size) return; // can't analyze something that small

	// Loop through the sbuf in opt_bulk_block_size sized chunks
	// for each one, examine the entropy and scan for bitlocker (unfortunately hardcoded)
	// This needs to have a general plug-in architecture
	for(size_t base=0;base+opt_bulk_block_size<=sp.sbuf.pagesize;base+=opt_bulk_block_size){
	    sbuf_t sbuf(sp.sbuf,base,opt_bulk_block_size);
	    bulk_ngram_entropy(sbuf,bulk,bulk_tags);
	    bulk_bitlocker(sbuf,bulk,bulk_tags);
	}
    }
    // shutdown --- combine the results if we are in DFRWS mode
    if(sp.phase==scanner_params::PHASE_SHUTDOWN){
	if(dfrws_challenge){
	    feature_recorder *bulk = sp.fs.get_name("bulk");
	    // First process the bulk_tags and lift_tags
	    bulk_process_feature_file(bulk->outdir + "/bulk_tags.txt"); 
	    bulk_process_feature_file(bulk->outdir + "/lift_tags.txt"); 

	    // Process the remaining feature files
	    dig d(bulk->outdir);
	    for(dig::const_iterator it = d.begin(); it!=d.end(); ++it){
		if(ends_with(*it,_TEXT("_tags.txt"))==false){
		    bulk_process_feature_file(*it);
		}
	    }
	    dfrws2012_bulk_process_dump();
	}
	return;		// no cleanup
    }
}
コード例 #2
0
static int
stream_reset (GMimeStream *stream)
{
	d(g_warning ("Invoked default stream_reset implementation."));
	return 0;
}
コード例 #3
0
static gint64
stream_tell (GMimeStream *stream)
{
	d(g_warning ("Invoked default stream_tell implementation."));
	return stream->position;
}
コード例 #4
0
  Int Interface::innerNormalDirection (Real & infeasible_gradient) {
    Real oldnormc = c->norm();
    Vector d(*env), dcp(*env), dn(*env);
    Real ndn;
    Real alpha, Ared, Pred;
    Real one[2] = {1,0};
    Real zero[2] = {0,0};
    Int iout, naflag;
    Bool dnavail;
    Vector gtmp (*env);
    Vector xtmp (*xc), ctmp (*c), stmp (*env);
    Real normgtmp = 0;

    Aavail = dciFalse;

    Real scalingMatrix[nvar + nconI];
    gtmp.sdmult (*J, 1, one, zero, ctmp); // g = J'*c
    pReal gtmpx = gtmp.get_doublex();
    for (Int i = 0; i < nvar+nconI; i++) {
      Real gi = gtmpx[i], zi = xcx[i], ui = u_bndx[i], li = l_bndx[i];
      if ( (gi < 0) && (ui < dciInf) ) {
        scalingMatrix[i] = 1.0/sqrt(ui - zi);
      } else if ( (gi > 0) && (li > -dciInf) ) {
        scalingMatrix[i] = 1.0/sqrt(zi - li);
      } else {
        scalingMatrix[i] = 1;
      }
    }
    normgtmp = gtmp.norm ();
    Vector gtmp_proj(*env);
    gtmp_proj.scale(gtmp, -1.0);
    projectBounds_xc(gtmp_proj);
    infeasible_gradient = gtmp_proj.norm();
//    DeltaV = normgtmp;

    if (normgtmp < dciTiny) {
      normc = oldnormc;
      iout = 6;
//      std::cout << "iout = 6" << std::endl;
      return iout;
    }
    //Now with the infinity norm
    Real lower[nvar + nconI], upper[nvar + nconI];
    for (Int i = 0; i < nvar+nconI; i++) {
      Real zi = xcx[i], li = l_bndx[i], ui = u_bndx[i];
      lower[i] = Max( -DeltaV,
          (li > -dciInf ? (li - zi) * (1 - epsmu) : -dciInf) );
      upper[i] = Min(  DeltaV,
          (ui <  dciInf ? (ui - zi) * (1 - epsmu) :  dciInf) );
    }
    Vector aux(*env);
    d = gtmp;
    pReal dx = 0;
    gtmpx = gtmp.get_doublex();
    dx = d.get_doublex();
    for (Int i = 0; i < nvar + nconI; i++) {
      gtmpx[i] /= scalingMatrix[i];
      dx[i] = -dx[i]/pow(scalingMatrix[i], 2);
    }

    aux.sdmult(*J, 0, one, zero, d);
    alpha = Min(gtmp.dot(gtmp)/aux.dot(aux), DeltaV/gtmp.norm());
    dcp.scale (d, alpha);
    pReal dcpx = dcp.get_doublex();

//    alpha = -d.dot(gtmp)/aux.dot(aux);
//    alpha = Min(alpha, DeltaV/d.norm());
    alpha = 1.0;
    for (int i = 0; i < nvar + nconI; i++) {
      Real di = dcpx[i], ui = upper[i], li = lower[i];
      if (di > dciEps) {
        alpha = Min(alpha, ui/(di));
      } else if (di < -dciEps) {
        alpha = Min(alpha, li/(di));
      } else
        dcpx[i] = 0;
    }
    Real theta = 0.99995;
    if (alpha < 1) {
      alpha = Max(theta, 1 - dcp.norm())*alpha;
      dcp.scale(alpha);
    }
/*     for (Int i = 0; i < nvar + nconI; i++)
 *       dcpx[i] *= scalingMatrix[i];
 */
    dnavail = dciFalse;
    ndn = 0;
    Ared = 0;
    Pred = 1;
//    DeltaV = DeltaV/kappa2;
    iout = 0;

    // For the inequalities
    pReal dnx = 0;

    dnavail = dciFalse;
    if (!dnavail) {
      naflag = naStep (*c, dn);

      dnavail = dciTrue;

      dnx = dn.get_doublex();
      //Project this step
      alpha = 1.0;
      for (Int i = 0; i < nvar + nconI; i++) {
        Real di = dnx[i], ui = upper[i], li = lower[i];
        if (di > dciEps) {
          alpha = Min(alpha, ui/di);
        } else if (di < -dciEps) {
          alpha = Min(alpha, li/di);
        } else
          di = 0;
      }
      if (alpha < 1) {
        alpha = Max(theta, 1 - dn.norm())*alpha;
        dn.scale(alpha);
      }

      if (naflag > 1)
        ndn = 0;
      else
        ndn = dn.norm (0);
      assert(ndn <= DeltaV || "ndn > DeltaV");
    }

    /* ||a + b||^2 = <a+b,a+b> = <a,a> + 2*<a,b> + <b,b> */
    /* m(d) = 0.5*||J*d + h||^2
     * dtr = t*dn + (1 - t)*dcp
     * m(dtr) = 0.5*||J*(t*dn + (1-t)*dcp) + h||^2
     *   = 0.5*||J*dcp + h + t*J*(dn - dcp)||^2
     *   = 0.5*||J*dcp + h||^2 + t*(J*dcp + h)'*J*(dn - dcp) + 0.5*t^2*||J*(dn - dcp)||^2 */
    Vector Adcph(*c), difdcdn(dn), Adif(*env);
    Adcph.sdmult(*J, 0, one, one, dcp);
    difdcdn.saxpy(dcp, -1);
    Adif.sdmult(*J, 0, one, zero, difdcdn);

    Real objValAdcph = 0.5*Adcph.dot(Adcph);
    Real dotAdcphAdif = Adcph.dot(Adif);
    Real halfSqrNormAdif = 0.5*Adif.dot(Adif);

    Real cauchyReduction = 0.5*oldnormc*oldnormc - objValAdcph;
    Real newtonReduction = cauchyReduction - dotAdcphAdif - halfSqrNormAdif;

    Real factor = 1.0;
    while (newtonReduction/cauchyReduction < beta1) {
      // Line search among from newton to cauchy
      factor *= 0.9;
      newtonReduction = cauchyReduction - factor*dotAdcphAdif - pow(factor,2)*halfSqrNormAdif;
      if (factor < 1e-8) {
        factor = 0;
        break;
      }
    }

    Vector xtemp(*xc);

    for (Int i = 0; i < nvar+nconI; i++) {
      if (l_bndx[i] - u_bndx[i] > -dciEps)
        continue;
      xcx[i] += (factor*dnx[i] + (1 - factor)*dcpx[i]);
      if (xcx[i] >= u_bndx[i])
        xcx[i] = u_bndx[i] - dciEps;
      else if (xcx[i] <= l_bndx[i])
        xcx[i] = l_bndx[i] + dciEps;
    }

#ifndef NDEBUG
    checkInfactibility();
#endif

    call_ccfsg_xc(dciFalse);
    normc = c->norm ();

    Ared = 0.5*(oldnormc*oldnormc - normc*normc);
    Pred = newtonReduction;

    if (Ared/Pred < beta2) {
      DeltaV /= 4;
      *xc = xtmp;
      call_ccfsg_xc(dciFalse);
      normc = c->norm();
    } else if (Ared/Pred > 0.75) {
      DeltaV *= 2;
    }

    if (normc < rho)
      return 0;

    current_time = getTime() - start_time;

    return 0;
  }
コード例 #5
0
static ssize_t
stream_write (GMimeStream *stream, const char *buf, size_t len)
{
	d(g_warning ("Invoked default stream_write implementation."));
	return 0;
}
コード例 #6
0
inline double solve_quadprog(MatrixXd & G,  VectorXd & g0,
                             const MatrixXd & CE, const VectorXd & ce0,
                             const MatrixXd & CI, const VectorXd & ci0,
                             VectorXd& x)
{
    int i, j, k, l; /* indices */
    int ip, me, mi;
    int n=g0.size();
    int p=ce0.size();
    int m=ci0.size();
    MatrixXd R(G.rows(),G.cols()), J(G.rows(),G.cols());

    LLT<MatrixXd,Lower> chol(G.cols());

    VectorXd s(m+p), z(n), r(m + p), d(n),  np(n), u(m + p);
    VectorXd x_old(n), u_old(m + p);
    double f_value, psi, c1, c2, sum, ss, R_norm;
    const double inf = std::numeric_limits<double>::infinity();
    double t, t1, t2; /* t is the step length, which is the minimum of the partial step length t1
    * and the full step length t2 */
    VectorXi A(m + p), A_old(m + p), iai(m + p);
    int q;
    int iq, iter = 0;
    bool iaexcl[m + p];

    me = p; /* number of equality constraints */
    mi = m; /* number of inequality constraints */
    q = 0;  /* size of the active set A (containing the indices of the active constraints) */

    /*
     * Preprocessing phase
     */

    /* compute the trace of the original matrix G */
    c1 = G.trace();

    /* decompose the matrix G in the form LL^T */
    chol.compute(G);

    /* initialize the matrix R */
    d.setZero();
    R.setZero();
    R_norm = 1.0; /* this variable will hold the norm of the matrix R */

    /* compute the inverse of the factorized matrix G^-1, this is the initial value for H */
    // J = L^-T
    J.setIdentity();
    J = chol.matrixU().solve(J);
    c2 = J.trace();
#ifdef TRACE_SOLVER
    print_matrix("J", J, n);
#endif

    /* c1 * c2 is an estimate for cond(G) */

    /*
    * Find the unconstrained minimizer of the quadratic form 0.5 * x G x + g0 x
    * this is a feasible point in the dual space
     * x = G^-1 * g0
    */
    x = chol.solve(g0);
    x = -x;
    /* and compute the current solution value */
    f_value = 0.5 * g0.dot(x);
#ifdef TRACE_SOLVER
    std::cerr << "Unconstrained solution: " << f_value << std::endl;
    print_vector("x", x, n);
#endif

    /* Add equality constraints to the working set A */
    iq = 0;
    for (i = 0; i < me; i++)
    {
        np = CE.col(i);
        compute_d(d, J, np);
        update_z(z, J, d,  iq);
        update_r(R, r, d,  iq);
#ifdef TRACE_SOLVER
        print_matrix("R", R, iq);
        print_vector("z", z, n);
        print_vector("r", r, iq);
        print_vector("d", d, n);
#endif

        /* compute full step length t2: i.e., the minimum step in primal space s.t. the contraint
          becomes feasible */
        t2 = 0.0;
        if (std::abs(z.dot(z)) > std::numeric_limits<double>::epsilon()) // i.e. z != 0
            t2 = (-np.dot(x) - ce0(i)) / z.dot(np);

        x += t2 * z;

        /* set u = u+ */
        u(iq) = t2;
        u.head(iq) -= t2 * r.head(iq);

        /* compute the new solution value */
        f_value += 0.5 * (t2 * t2) * z.dot(np);
        A(i) = -i - 1;

        if (!add_constraint(R, J, d, iq, R_norm))
        {
            // FIXME: it should raise an error
            // Equality constraints are linearly dependent
            return f_value;
        }
    }

    /* set iai = K \ A */
    for (i = 0; i < mi; i++)
        iai(i) = i;

l1:
    iter++;
#ifdef TRACE_SOLVER
    print_vector("x", x, n);
#endif
    /* step 1: choose a violated constraint */
    for (i = me; i < iq; i++)
    {
        ip = A(i);
        iai(ip) = -1;
    }

    /* compute s(x) = ci^T * x + ci0 for all elements of K \ A */
    ss = 0.0;
    psi = 0.0; /* this value will contain the sum of all infeasibilities */
    ip = 0; /* ip will be the index of the chosen violated constraint */
    for (i = 0; i < mi; i++)
    {
        iaexcl[i] = true;
        sum = CI.col(i).dot(x) + ci0(i);
        s(i) = sum;
        psi += std::min(0.0, sum);
    }
#ifdef TRACE_SOLVER
    print_vector("s", s, mi);
#endif


    if (std::abs(psi) <= mi * std::numeric_limits<double>::epsilon() * c1 * c2* 100.0)
    {
        /* numerically there are not infeasibilities anymore */
        q = iq;
        return f_value;
    }

    /* save old values for u, x and A */
    u_old.head(iq) = u.head(iq);
    A_old.head(iq) = A.head(iq);
    x_old = x;

l2: /* Step 2: check for feasibility and determine a new S-pair */
    for (i = 0; i < mi; i++)
    {
        if (s(i) < ss && iai(i) != -1 && iaexcl[i])
        {
            ss = s(i);
            ip = i;
        }
    }
    if (ss >= 0.0)
    {
        q = iq;
        return f_value;
    }

    /* set np = n(ip) */
    np = CI.col(ip);
    /* set u = (u 0)^T */
    u(iq) = 0.0;
    /* add ip to the active set A */
    A(iq) = ip;

#ifdef TRACE_SOLVER
    std::cerr << "Trying with constraint " << ip << std::endl;
    print_vector("np", np, n);
#endif

l2a:/* Step 2a: determine step direction */
    /* compute z = H np: the step direction in the primal space (through J, see the paper) */
    compute_d(d, J, np);
    update_z(z, J, d, iq);
    /* compute N* np (if q > 0): the negative of the step direction in the dual space */
    update_r(R, r, d, iq);
#ifdef TRACE_SOLVER
    std::cerr << "Step direction z" << std::endl;
    print_vector("z", z, n);
    print_vector("r", r, iq + 1);
    print_vector("u", u, iq + 1);
    print_vector("d", d, n);
    print_ivector("A", A, iq + 1);
#endif

    /* Step 2b: compute step length */
    l = 0;
    /* Compute t1: partial step length (maximum step in dual space without violating dual feasibility */
    t1 = inf; /* +inf */
    /* find the index l s.t. it reaches the minimum of u+(x) / r */
    for (k = me; k < iq; k++)
    {
        double tmp;
        if (r(k) > 0.0 && ((tmp = u(k) / r(k)) < t1) )
        {
            t1 = tmp;
            l = A(k);
        }
    }
    /* Compute t2: full step length (minimum step in primal space such that the constraint ip becomes feasible */
    if (std::abs(z.dot(z))  > std::numeric_limits<double>::epsilon()) // i.e. z != 0
        t2 = -s(ip) / z.dot(np);
    else
        t2 = inf; /* +inf */

    /* the step is chosen as the minimum of t1 and t2 */
    t = std::min(t1, t2);
#ifdef TRACE_SOLVER
    std::cerr << "Step sizes: " << t << " (t1 = " << t1 << ", t2 = " << t2 << ") ";
#endif

    /* Step 2c: determine new S-pair and take step: */

    /* case (i): no step in primal or dual space */
    if (t >= inf)
    {
        /* QPP is infeasible */
        // FIXME: unbounded to raise
        q = iq;
        return inf;
    }
    /* case (ii): step in dual space */
    if (t2 >= inf)
    {
        /* set u = u +  t * [-r 1) and drop constraint l from the active set A */
        u.head(iq) -= t * r.head(iq);
        u(iq) += t;
        iai(l) = l;
        delete_constraint(R, J, A, u, p, iq, l);
#ifdef TRACE_SOLVER
        std::cerr << " in dual space: "
                  << f_value << std::endl;
        print_vector("x", x, n);
        print_vector("z", z, n);
        print_ivector("A", A, iq + 1);
#endif
        goto l2a;
    }

    /* case (iii): step in primal and dual space */

    x += t * z;
    /* update the solution value */
    f_value += t * z.dot(np) * (0.5 * t + u(iq));

    u.head(iq) -= t * r.head(iq);
    u(iq) += t;
#ifdef TRACE_SOLVER
    std::cerr << " in both spaces: "
              << f_value << std::endl;
    print_vector("x", x, n);
    print_vector("u", u, iq + 1);
    print_vector("r", r, iq + 1);
    print_ivector("A", A, iq + 1);
#endif

    if (t == t2)
    {
#ifdef TRACE_SOLVER
        std::cerr << "Full step has taken " << t << std::endl;
        print_vector("x", x, n);
#endif
        /* full step has taken */
        /* add constraint ip to the active set*/
        if (!add_constraint(R, J, d, iq, R_norm))
        {
            iaexcl[ip] = false;
            delete_constraint(R, J, A, u, p, iq, ip);
#ifdef TRACE_SOLVER
            print_matrix("R", R, n);
            print_ivector("A", A, iq);
#endif
            for (i = 0; i < m; i++)
                iai(i) = i;
            for (i = 0; i < iq; i++)
            {
                A(i) = A_old(i);
                iai(A(i)) = -1;
                u(i) = u_old(i);
            }
            x = x_old;
            goto l2; /* go to step 2 */
        }
        else
            iai(ip) = -1;
#ifdef TRACE_SOLVER
        print_matrix("R", R, n);
        print_ivector("A", A, iq);
#endif
        goto l1;
    }

    /* a patial step has taken */
#ifdef TRACE_SOLVER
    std::cerr << "Partial step has taken " << t << std::endl;
    print_vector("x", x, n);
#endif
    /* drop constraint l */
    iai(l) = l;
    delete_constraint(R, J, A, u, p, iq, l);
#ifdef TRACE_SOLVER
    print_matrix("R", R, n);
    print_ivector("A", A, iq);
#endif

    s(ip) = CI.col(ip).dot(x) + ci0(ip);

#ifdef TRACE_SOLVER
    print_vector("s", s, mi);
#endif
    goto l2a;
}
コード例 #7
0
ファイル: 1.CPP プロジェクト: ManuelAlanis/BatallaNaval-C
void hongocompleto()
{
int i=0;
do{

//for(i=6;i<9;i++)
//{
setbkcolor(WHITE);
construccion();
////C
setcolor (7);
settextstyle (0,0,5);
outtextxy (30,50,"C");
////A
setcolor (7);
settextstyle (0,0,5);
outtextxy (70,55,"A");
/////R
setcolor (7);
settextstyle (0,0,5);
outtextxy (110,50,"R");

/////G
setcolor (7);
settextstyle (0,0,5);
outtextxy (150,55,"G");
/////A
setcolor (7);
settextstyle (0,0,5);
outtextxy (190,50,"A");
/////N
setcolor (7);
settextstyle (0,0,5);
outtextxy (230,55,"N");
/////D
setcolor (7);
settextstyle (0,0,5);
outtextxy (270,50,"D");
/////O
setcolor (7);
settextstyle (0,0,5);
outtextxy (310,55,"O");
c();
//a1();
//r();
//g();
//a2();
//n();
//d();
//o();
//c();
delay(200);
cabeza();
a1();
delay(200);
ojo();
r();

delay(200);
mancha1();
g();
delay(200);

mancha2();
a2();
delay(200);

mancha3();
n();
delay(200);

mancha4();
d();
delay(200);

mancha5();
o();
delay(200);
//getch();
i=i++;

//kbhit();
}while (i<2);
//}while (!kbhit());
}
コード例 #8
0
ファイル: main.cpp プロジェクト: joeeeeoj/SystemC
int sc_main(int, char**) {
    sc_signal<bool> Clk, Rst, Tx_Active, CCA_Active, MEM_Read;
    sc_signal< sc_uint<8> > RFST_in, MUX, Instruction;
    sc_signal< sc_uint<16> >Random_in;
    sc_signal<bool> Txcaln, Txon, Txoncca, ackset, Txoff, flush_tx, Rxon, Rxoff, flush_rx;
    sc_signal< sc_uint<32> > i;
    sc_signal< sc_uint<4> > W;
    sc_signal< sc_uint<3> > CSPSelmux_1;
    sc_signal< sc_uint<2> > CSPSelmux_2;

    /*sc_signal<bool> Encspx, Encspy, Incy, Decy, Encspz, Decz, Encspt, Dect, Encspctrl, Enpc, Enir, MEM_Read, Enmactimer, CSPC_out;
    sc_signal< sc_uint<3> > S, CSPSelmux_1;
    sc_signal< sc_uint<2> > CSPSelmux_2;
    sc_signal< sc_uint<8> > CSPX_out, CSPY_out, CSPZ_out, CSPT_out, CSPCTRL_out, CSPPC_out, CSPIR_out, RFST_out, CSPMux_1_out,
    	Memory_out, CSPR_out, OFECou;
    */
    CSPTOP DUT("CSPTOP");
    DUT.Clk(Clk);
    DUT.Rst(Rst);
    DUT.Tx_Active(Tx_Active);
    DUT.CCA_Active(CCA_Active);
    DUT.RFST_in(RFST_in);
    DUT.Random_in(Random_in);

    DUT.CSPIR_out(Instruction);
    DUT.W(W);
    DUT.MUX(MUX);
    DUT.i(i);
    DUT.Txcaln(Txcaln);
    DUT.Txon(Txon);
    DUT.Txoncca(Txoncca);
    DUT.ackset(ackset);
    DUT.Txoff(Txoff);
    DUT.flush_tx(flush_tx);
    DUT.Rxon(Rxon);
    DUT.Rxoff(Rxoff);
    DUT.flush_rx(flush_rx);

    DUT.CSPSelmux_2(CSPSelmux_2);
    DUT.CSPSelmux_1(CSPSelmux_1);
    DUT.MEM_Read(MEM_Read);
    /*
    	Control.Clk(Clk);
    	Control.Rst(Rst);
    	Control.OFECou(OFECou);
    	Control.Instruction(CSPIR_out);
    	Control.MUX(MUX);
    	Control.C_out(CSPC_out);

    	Control.i(i);
    	Control.Encspx(Encspx);
    	Control.Encspy(Encspy);
    	Control.Incy(Incy);
    	Control.Decy(Decy);
    	Control.Encspz(Encspz);
    	Control.Decz(Decz);
    	Control.Encspt(Encspt);
    	Control.Dect(Dect);
    	Control.Encspctrl(Encspctrl);
    	Control.Enpc(Enpc);
    	Control.S(S);
    	Control.Enir(Enir);
    	Control.Selmux_1(CSPSelmux_1);
    	Control.Selmux_2(CSPSelmux_2);
    	Control.MEM_Read(MEM_Read);
    	Control.Enmactimer(Enmactimer);
    	Control.Txcaln(Txcaln);
    	Control.Txon(Txon);
    	Control.Txoncca(Txoncca);
    	Control.ackset(ackset);
    	Control.Txoff(Txoff);
    	Control.flush_tx(flush_tx);
    	Control.Rxon(Rxon);
    	Control.Rxoff(Rxoff);
    	Control.flush_rx(flush_rx);
    */

    driver d("driver");
    d.Clk(Clk);
    d.Rst(Rst);
    d.Tx_Active(Tx_Active);
    d.CCA_Active(CCA_Active);
    d.RFST_in(RFST_in);
    d.Random_in(Random_in);
    //d.CSPIR_out(CSPIR_out);
    //d.OFECou(OFECou);
    //d.MUX(MUX);
    //d.C_out(CSPC_out);

    // trace file creation
    sc_trace_file *tf = sc_create_vcd_trace_file("CSPTOP");
    sc_trace(tf,DUT.Clk, "Clk");
    sc_trace(tf,DUT.Rst, "Rst");
    sc_trace(tf,DUT.Tx_Active, "Tx_Active");
    sc_trace(tf,DUT.CCA_Active, "CCA_Active");
    sc_trace(tf,DUT.RFST_in, "RFST_in");
    sc_trace(tf,DUT.Random_in, "Random_in");

    sc_trace(tf,DUT.Txcaln, "Txcaln");
    sc_trace(tf,DUT.Txon, "Txon");
    sc_trace(tf,DUT.Txoncca, "Txoncca");
    sc_trace(tf,DUT.ackset, "ackset");
    sc_trace(tf,DUT.Txoff, "Txoff");
    sc_trace(tf,DUT.flush_tx, "flush_tx");
    sc_trace(tf,DUT.Rxon, "Rxon");
    sc_trace(tf,DUT.Rxoff, "Rxoff");
    sc_trace(tf,DUT.flush_rx, "flush_rx");

    sc_trace(tf,DUT.MUX, "MUX");
    sc_trace(tf,DUT.i, "i");
    sc_trace(tf,DUT.W, "W");
    sc_trace(tf,DUT.MEM_Read, "MEM_Read");
    sc_trace(tf,DUT.CSPIR_out, "CSPIR_out");
    sc_trace(tf,DUT.CSPSelmux_1, "CSPSelmux_1");
    sc_trace(tf,DUT.CSPSelmux_2, "CSPSelmux_2");

    /*
    	sc_trace_file *tf = sc_create_vcd_trace_file("CSPControl");
    	sc_trace(tf,Control.Clk, "Clk");
    	sc_trace(tf,Control.Rst, "Rst");
    	sc_trace(tf,Control.OFECou, "OFECou");
    	sc_trace(tf,Control.Instruction, "Instruction");
    	sc_trace(tf,Control.MUX, "MUX");
    	sc_trace(tf,Control.C_out, "C_out");
    	//sc_trace(tf,Control.Random_in, "Random_in");
    	sc_trace(tf,Control.i, "i");
    */
    sc_start(10000,SC_NS);
    sc_close_vcd_trace_file(tf);
    system("pause");
    return 0;
}
コード例 #9
0
ファイル: RenderManager.cpp プロジェクト: Captnoord/NBK
		GLvoid CRenderManager::handlePickedObjects()
		{
			// if we are ower the menu we do not have to proccess things under the cursor
			if (CV_GAME_MANAGER->getGUIManager()->getPlayGUI()->is_mouse_over_gui())
			{
				return;
			}

			// if we are not selling or buying we don't have to process blocks (just objects TODO)
			ACTION_EVENT *ae = CV_GAME_MANAGER->getGUIManager()->getLastActionEvent();
			
			// get the block we have our cousor on
			CBlock *pickedBlock = CV_GAME_MANAGER->getPickingManager()->getLastPickedBlock();

			if (pickedBlock)
			{
				GLint type = pickedBlock->getType();

				/*if (!pickedBlock->isSellable())
				{
					return;
				}*/

				sBoundingBox *bbox = pickedBlock->getBoundingBox();

				vector3f a(bbox->A);
				vector3f b(bbox->B);
				vector3f c(bbox->C);
				vector3f d(bbox->D);
				vector3f e(bbox->E);
				vector3f f(bbox->F);
				vector3f g(bbox->G);
				vector3f h(bbox->H);

				a[1]=b[1]=c[1]=d[1]=CV_BLOCK_HEIGHT+CV_BLOCK_HEIGHT/4.0f+CV_BLOCK_HEIGHT/32.0f;
				e[1]=f[1]=g[1]=h[1]=CV_BLOCK_HEIGHT/4.0f+CV_BLOCK_HEIGHT/32.0f;

				glLineWidth(4.0f);

				if (pickedBlock->isLow())
				{
					if (!(ae->message_group==AEMG_BUILD_ROOMS || ae->message_group==AEMG_BUILD_DOORS || ae->message_group==AEMG_BUILD_TRAPS))
					{
						return;
					}

					// draw the selection box					

					if (pickedBlock->isSellable(CV_CURRENT_PLAYER_ID) && ae->message == AEM_SELL)
					{
						glColor3f(0.0f,1.0f,0.0f);
					}
					else if (pickedBlock->isBuildable(CV_CURRENT_PLAYER_ID) && ae->message != AEM_SELL)
					{
						glColor3f(0.0f,1.0f,0.0f);
					}
					else
					{
						glColor3f(1.0f,0.0f,0.0f);
					}
					
					glBegin(GL_LINES);
					{
						/*glVertex3fv(&a[0]); glVertex3fv(&b[0]);
						glVertex3fv(&b[0]); glVertex3fv(&c[0]);
						glVertex3fv(&c[0]); glVertex3fv(&d[0]);
						glVertex3fv(&d[0]); glVertex3fv(&a[0]);*/

						glVertex3fv(&e[0]); glVertex3fv(&f[0]);
						glVertex3fv(&f[0]); glVertex3fv(&g[0]);
						glVertex3fv(&g[0]); glVertex3fv(&h[0]);
						glVertex3fv(&h[0]); glVertex3fv(&e[0]);

						/*glVertex3fv(&a[0]); glVertex3fv(&e[0]);
						glVertex3fv(&b[0]); glVertex3fv(&f[0]);
						glVertex3fv(&c[0]); glVertex3fv(&g[0]);
						glVertex3fv(&d[0]); glVertex3fv(&h[0]);*/
					}
					glEnd();
				}
				else
				{		
					if (!(ae->message_group==AEMG_BUILD_ROOMS || ae->message_group==AEMG_BUILD_DOORS || ae->message_group==AEMG_BUILD_TRAPS))
						glColor3f(type==CV_BLOCK_TYPE_ROCK_ID?1.0f:0.0f,type==CV_BLOCK_TYPE_ROCK_ID?0.0f:1.0f,0.0f);
					else
						glColor3f(1.0f,0.0f,0.0f);
			
					glBegin(GL_LINES);
					{
						glVertex3fv(&a[0]); glVertex3fv(&b[0]);
						glVertex3fv(&b[0]); glVertex3fv(&c[0]);
						glVertex3fv(&c[0]); glVertex3fv(&d[0]);
						glVertex3fv(&d[0]); glVertex3fv(&a[0]);

						glVertex3fv(&e[0]); glVertex3fv(&f[0]);
						glVertex3fv(&f[0]); glVertex3fv(&g[0]);
						glVertex3fv(&g[0]); glVertex3fv(&h[0]);
						glVertex3fv(&h[0]); glVertex3fv(&e[0]);

						glVertex3fv(&a[0]); glVertex3fv(&e[0]);
						glVertex3fv(&b[0]); glVertex3fv(&f[0]);
						glVertex3fv(&c[0]); glVertex3fv(&g[0]);
						glVertex3fv(&d[0]); glVertex3fv(&h[0]);
					}
					glEnd();
				}

				glLineWidth(1.0f);
			}
		}
コード例 #10
0
ファイル: test_01.cpp プロジェクト: cihanuq/Trilinos
int main(int argc, char* argv[]) {

  Teuchos::GlobalMPISession mpiSession(&argc, &argv);
  Teuchos::RCP<const Teuchos::Comm<int> > comm
    = Teuchos::DefaultComm<int>::getComm();

  // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
  int iprint = argc - 1;
  Teuchos::RCP<std::ostream> outStream;
  Teuchos::oblackholestream bhs; // outputs nothing
  if (iprint > 0 && Teuchos::rank<int>(*comm)==0)
    outStream = Teuchos::rcp(&std::cout, false);
  else
    outStream = Teuchos::rcp(&bhs, false);

  int errorFlag  = 0;

  try {
    /**********************************************************************************************/
    /************************* CONSTRUCT ROL ALGORITHM ********************************************/
    /**********************************************************************************************/
    // Get ROL parameterlist
    std::string filename = "input.xml";
    Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
    Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
    // Build ROL algorithm
    parlist->sublist("Status Test").set("Gradient Tolerance",1.e-8);
    parlist->sublist("Status Test").set("Step Tolerance",1.e-14);
    parlist->sublist("Status Test").set("Iteration Limit",100);
    /**********************************************************************************************/
    /************************* CONSTRUCT VECTORS **************************************************/
    /**********************************************************************************************/
    // Build control vectors
    int nx = 256;
    Teuchos::RCP<std::vector<RealT> > x_rcp  = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
    ROL::StdVector<RealT> x(x_rcp);
    Teuchos::RCP<std::vector<RealT> > d_rcp  = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
    ROL::StdVector<RealT> d(d_rcp);
    for ( int i = 0; i < nx+2; i++ ) {
      (*x_rcp)[i] = random<RealT>(comm);
      (*d_rcp)[i] = random<RealT>(comm);
    }
    // Build state and adjoint vectors
    Teuchos::RCP<std::vector<RealT> > u_rcp  = Teuchos::rcp( new std::vector<RealT>(nx,1.0) );
    ROL::StdVector<RealT> u(u_rcp);
    Teuchos::RCP<std::vector<RealT> > p_rcp  = Teuchos::rcp( new std::vector<RealT>(nx,0.0) );
    ROL::StdVector<RealT> p(p_rcp);
    Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(&u,false);
    Teuchos::RCP<ROL::Vector<RealT> > pp = Teuchos::rcp(&p,false);
    /**********************************************************************************************/
    /************************* CONSTRUCT SOL COMPONENTS *******************************************/
    /**********************************************************************************************/
    // Build samplers
//    int dim = 4;
//    int nSamp = 100;
//    std::vector<RealT> tmp(2,0.0); tmp[0] = -1.0; tmp[1] = 1.0;
//    std::vector<std::vector<RealT> > bounds(dim,tmp);
//    Teuchos::RCP<ROL::BatchManager<RealT> > bman
//      = Teuchos::rcp(new ROL::StdTeuchosBatchManager<RealT,int>(comm));
//    Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
//      = Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nSamp,bounds,bman,false,false,100));
    ROL::QuadratureInfo info;
    info.dim = 4;
    info.maxLevel = 7;
    info.rule1D.clear(); info.rule1D.resize(info.dim,ROL::QUAD_CLENSHAWCURTIS);    
    info.growth1D.clear(); info.growth1D.resize(info.dim,ROL::GROWTH_DEFAULT);
    info.normalized = true;
    info.adaptive = false;
    Teuchos::RCP<ROL::BatchManager<RealT> > bman
      = Teuchos::rcp(new ROL::StdTeuchosBatchManager<RealT,int>(comm));
    Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
      = Teuchos::rcp(new ROL::SparseGridGenerator<RealT>(bman,info));
    // Print samples
    int width = 21;
    std::stringstream name;
    name << "samples_" << sampler->batchID() << ".txt";
    std::ofstream file(name.str().c_str());
    if (file.is_open()) {
      file << std::scientific << std::setprecision(12);
      for (int i = 0; i < sampler->numMySamples(); ++i) {
        std::vector<RealT> pt = sampler->getMyPoint(i);
        RealT wt = sampler->getMyWeight(i);
        for (int j = 0; j < static_cast<int>(pt.size()); ++j) {
          file << std::setw(width) << std::left << pt[j];
        }
        file << std::setw(width) << std::left << wt << std::endl;
      }
      file.close();
    }
    else {
      TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument,
        ">>> (adapters/trikota/sol/test/test_01): Unable to open file!");
    }

    /**********************************************************************************************/
    /************************* CONSTRUCT OBJECTIVE FUNCTION ***************************************/
    /**********************************************************************************************/
    // Build risk-averse objective function
    RealT alpha = 1.e-3;
    Teuchos::RCP<ROL::ParametrizedObjective_SimOpt<RealT> > pobjSimOpt
      = Teuchos::rcp(new Objective_BurgersControl<RealT>(alpha,nx));
    Teuchos::RCP<ROL::ParametrizedEqualityConstraint_SimOpt<RealT> > pconSimOpt
      = Teuchos::rcp(new EqualityConstraint_BurgersControl<RealT>(nx));
    Teuchos::RCP<ROL::ParametrizedObjective<RealT> > pObj
      = Teuchos::rcp(new ROL::Reduced_ParametrizedObjective_SimOpt<RealT>(pobjSimOpt,pconSimOpt,up,pp));
    Teuchos::RCP<ROL::Objective<RealT> > obj;
    // Test parametrized objective functions
    *outStream << "Check Derivatives of Parametrized Objective Function\n";
    pObj->setParameter(sampler->getMyPoint(0));
    pObj->checkGradient(x,d,true,*outStream);
    pObj->checkHessVec(x,d,true,*outStream);
    /**********************************************************************************************/
    /************************* RISK NEUTRAL *******************************************************/
    /**********************************************************************************************/
    *outStream << "\nSOLVE RISK NEUTRAL OPTIMAL CONTROL PROBLEM WITH TRUST REGION\n";
    // Build CVaR objective function
    Teuchos::ParameterList list;
    list.sublist("SOL").set("Stochastic Optimization Type","Risk Neutral");
    list.sublist("SOL").set("Store Sampled Value and Gradient",true);
    // Build stochastic problem
    Teuchos::RCP<ROL::Vector<RealT> > xp = Teuchos::rcp(&x,false);
    ROL::StochasticProblem<RealT> optProb(list,pObj,sampler,xp);
    optProb.checkObjectiveGradient(d,true,*outStream);
    optProb.checkObjectiveHessVec(d,true,*outStream);
    // Run ROL algorithm
    ROL::Algorithm<RealT> algo("Trust Region",*parlist,false);
    clock_t start = clock();
    xp->zero();
    algo.run(optProb,true,*outStream);
    *outStream << "Optimization time: " << (RealT)(clock()-start)/(RealT)CLOCKS_PER_SEC << " seconds.\n";
  }
  catch (std::logic_error err) {
    *outStream << err.what() << "\n";
    errorFlag = -1000;
  }; // end try

  if (errorFlag != 0)
    std::cout << "End Result: TEST FAILED\n";
  else
    std::cout << "End Result: TEST PASSED\n";

  return 0;
}
コード例 #11
0
ファイル: utils.cpp プロジェクト: Drakey83/steamlink-sdk
// Update a file or directory.
bool updateFile(const QString &sourceFileName, const QStringList &nameFilters,
                const QString &targetDirectory, unsigned flags, JsonOutput *json, QString *errorMessage)
{
    const QFileInfo sourceFileInfo(sourceFileName);
    const QString targetFileName = targetDirectory + QLatin1Char('/') + sourceFileInfo.fileName();
    if (optVerboseLevel > 1)
        std::wcout << "Checking " << sourceFileName << ", " << targetFileName<< '\n';

    if (!sourceFileInfo.exists()) {
        *errorMessage = QString::fromLatin1("%1 does not exist.").arg(QDir::toNativeSeparators(sourceFileName));
        return false;
    }

    if (sourceFileInfo.isSymLink()) {
        *errorMessage = QString::fromLatin1("Symbolic links are not supported (%1).")
                        .arg(QDir::toNativeSeparators(sourceFileName));
        return false;
    }

    const QFileInfo targetFileInfo(targetFileName);

    if (sourceFileInfo.isDir()) {
        if (targetFileInfo.exists()) {
            if (!targetFileInfo.isDir()) {
                *errorMessage = QString::fromLatin1("%1 already exists and is not a directory.")
                                .arg(QDir::toNativeSeparators(targetFileName));
                return false;
            } // Not a directory.
        } else { // exists.
            QDir d(targetDirectory);
            if (optVerboseLevel)
                std::wcout << "Creating " << QDir::toNativeSeparators(targetFileName) << ".\n";
            if (!(flags & SkipUpdateFile) && !d.mkdir(sourceFileInfo.fileName())) {
                *errorMessage = QString::fromLatin1("Cannot create directory %1 under %2.")
                                .arg(sourceFileInfo.fileName(), QDir::toNativeSeparators(targetDirectory));
                return false;
            }
        }
        // Recurse into directory
        QDir dir(sourceFileName);
        const QStringList allEntries = dir.entryList(nameFilters, QDir::Files) + dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
        foreach (const QString &entry, allEntries)
            if (!updateFile(sourceFileName + QLatin1Char('/') + entry, nameFilters, targetFileName, flags, json, errorMessage))
                return false;
        return true;
    } // Source is directory.

    if (targetFileInfo.exists()) {
        if (!(flags & ForceUpdateFile)
            && targetFileInfo.lastModified() >= sourceFileInfo.lastModified()) {
            if (optVerboseLevel)
                std::wcout << sourceFileInfo.fileName() << " is up to date.\n";
            if (json)
                json->addFile(sourceFileName, targetDirectory);
            return true;
        }
        QFile targetFile(targetFileName);
        if (!(flags & SkipUpdateFile) && !targetFile.remove()) {
            *errorMessage = QString::fromLatin1("Cannot remove existing file %1: %2")
                            .arg(QDir::toNativeSeparators(targetFileName), targetFile.errorString());
            return false;
        }
    } // target exists
    QFile file(sourceFileName);
    if (optVerboseLevel)
        std::wcout << "Updating " << sourceFileInfo.fileName() << ".\n";
    if (!(flags & SkipUpdateFile) && !file.copy(targetFileName)) {
        *errorMessage = QString::fromLatin1("Cannot copy %1 to %2: %3")
                .arg(QDir::toNativeSeparators(sourceFileName),
                     QDir::toNativeSeparators(targetFileName),
                     file.errorString());
        return false;
    }
    if (json)
        json->addFile(sourceFileName, targetDirectory);
    return true;
}
コード例 #12
0
ファイル: main.cpp プロジェクト: bondarevts/amse-qt
int main(int argc, char *argv[])
{
	QApplication app(argc, argv);
	QDialog d(0);
	QVBoxLayout *gl = new QVBoxLayout();

	QFormLayout *lay = new QFormLayout();
	lay->setWidget(0, QFormLayout::LabelRole, new QLabel(QString::fromLocal8Bit("Имя: "), &d));
	lay->setWidget(0, QFormLayout::FieldRole, new QLineEdit(&d));

	lay->setWidget(1, QFormLayout::LabelRole, new QLabel(QString::fromLocal8Bit("Фамилия: "), &d));
	lay->setWidget(1, QFormLayout::FieldRole, new QLineEdit(&d));

	lay->setWidget(2, QFormLayout::LabelRole, new QLabel(QString::fromLocal8Bit("Отчество: "), &d));
	lay->setWidget(2, QFormLayout::FieldRole, new QLineEdit(&d));
	gl->addLayout(lay);

	QFrame *line = new QFrame(&d);
	line->setFrameShape(QFrame::HLine);
	line->setFrameShadow(QFrame::Sunken);
	gl->addWidget(line);

	lay = new QFormLayout();
	QComboBox *cbox = new QComboBox(&d);
	cbox->insertItem(0, QString::fromLocal8Bit("женский"));
	cbox->insertItem(1, QString::fromLocal8Bit("мужской"));
	lay->setWidget(0, QFormLayout::LabelRole, new QLabel(QString::fromLocal8Bit("Пол: "), &d));
	lay->setWidget(0, QFormLayout::FieldRole, cbox);

	lay->setWidget(1, QFormLayout::LabelRole, new QLabel(QString::fromLocal8Bit("Дата рождения: "), &d));
	lay->setWidget(1, QFormLayout::FieldRole, new QDateEdit(&d));
	gl->addLayout(lay);

	line = new QFrame(&d);
	line->setFrameShape(QFrame::HLine);
	line->setFrameShadow(QFrame::Sunken);
	gl->addWidget(line);

	lay = new QFormLayout();
	lay->setWidget(0, QFormLayout::LabelRole, new QLabel(QString::fromLocal8Bit("Адрес: "), &d));
	lay->setWidget(0, QFormLayout::FieldRole, new QLineEdit(&d));

	lay->setWidget(1, QFormLayout::LabelRole, new QLabel(QString::fromLocal8Bit("Телефон: "), &d));
	lay->setWidget(1, QFormLayout::FieldRole, new QLineEdit(&d));
	gl->addLayout(lay);

	QHBoxLayout *lay2 = new QHBoxLayout();
	QPushButton *ok = new QPushButton("OK", &d);
	ok->setDefault(true);
	ok->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
	lay2->addWidget(ok);
	QPushButton *cancel = new QPushButton(QString::fromLocal8Bit("Отмена"), &d);
	cancel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
	lay2->addWidget(cancel);
	gl->addItem(lay2);

	d.setLayout(gl);
	d.setWindowTitle("Address book");
	d.show();
	return app.exec();
}
コード例 #13
0
ファイル: main.cpp プロジェクト: fussa2323/two-step_csjnrd
void dp(std::vector<std::string> ref, std::vector<std::string> hyp){
	int rcount = (int)ref.size();	//正解文書の単語数
	int hcount = (int)hyp.size();	//コンフュージョンセットの数
	
	std::vector<std::vector<bool> > d(rcount+1, std::vector<bool>(hcount+1));	//一致しているか
	std::vector<std::vector<int> > g(rcount+1, std::vector<int>(hcount+1));		//距離計算
	std::vector<std::vector<int> > r(rcount+1, std::vector<int>(hcount+1));		//置換,削除,挿入

	//dの算出(0:一致,1:不一致)
	for(int i = 1; i <= rcount; i++){
		for(int j = 1; j <= hcount; j++){
			d[i][j] = (ref[i-1] != hyp[j-1]);
		}
	}

	//g,rの端に値を代入
	g[0][0] = 0;
	r[0][0] = 0;

	for(int i = 1; i <= rcount; i++){
		g[i][0] = g[i-1][0] + 1;
		r[i][0] = 1;
	}

	for(int j = 1; j <= hcount; j++){
		g[0][j] = g[0][j-1] + 1;
		r[0][j] = 2;
	}
	
	//g,rの中の計算
	for(int i = 1; i <= rcount; i++){
		for(int j = 1; j <= hcount; j++){
			int l = g[i-1][j] + 1;
			int b = g[i][j-1] + 1;
			int lb = g[i-1][j-1] + d[i][j];
			if(l <= b){
				if(l <= lb){
					g[i][j] = l;
					r[i][j] = 1;
				}
				else{
					g[i][j] = lb;
					r[i][j] = 3;
				}
			}
			else{
				if(b <= lb){
					g[i][j] = b;
					r[i][j] = 2;
				}
				else{
					g[i][j] = lb;
					r[i][j] = 3;
				}
			}
		}
	}
	
	int i = rcount;
	int j = hcount;
	
	for(;;){
		if(r[i][j] == 1){
			del++;
			i--;
		}
		else if(r[i][j] == 2){
			ins++;
			j--;
		}
		else if(r[i][j] == 3){
			if(d[i][j] == 1){
				sub++;
			}
			else{
				cor++;
			}
			i--;
			j--;
		}
		else if(i == 0 && j == 0){
			break;
		}
	}
}
コード例 #14
0
ファイル: AlreadyOpen.cpp プロジェクト: wagenadl/eln
static QString servername(QString fn) {
  QDir d(QDir::current());
  fn = d.absoluteFilePath(fn);
  fn = QDir::cleanPath(fn);
  return QString("eln-%1").arg(qHash(fn));
}
コード例 #15
0
ファイル: fastcluster.cpp プロジェクト: 23119841/CppMT
void MST_linkage_core(const t_index N, const t_float * const D,
                             cluster_result & Z2) {
/*
    N: integer, number of data points
    D: condensed distance matrix N*(N-1)/2
    Z2: output data structure

    The basis of this algorithm is an algorithm by Rohlf:

    F. James Rohlf, Hierarchical clustering using the minimum spanning tree,
    The Computer Journal, vol. 16, 1973, p. 93–95.
*/
  t_index i;
  t_index idx2;
  doubly_linked_list active_nodes(N);
  auto_array_ptr<t_float> d(N);

  t_index prev_node;
  t_float min;

  // first iteration
  idx2 = 1;
  min = std::numeric_limits<t_float>::infinity();
  for (i=1; i<N; ++i) {
    d[i] = D[i-1];
#if HAVE_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
    if (d[i] < min) {
      min = d[i];
      idx2 = i;
    }
    else if (fc_isnan(d[i]))
      throw (nan_error());
#if HAVE_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
  }
  Z2.append(0, idx2, min);

  for (t_index j=1; j<N-1; ++j) {
    prev_node = idx2;
    active_nodes.remove(prev_node);

    idx2 = active_nodes.succ[0];
    min = d[idx2];
    for (i=idx2; i<prev_node; i=active_nodes.succ[i]) {
      t_float tmp = D_(i, prev_node);
#if HAVE_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
      if (tmp < d[i])
        d[i] = tmp;
      else if (fc_isnan(tmp))
        throw (nan_error());
#if HAVE_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
      if (d[i] < min) {
        min = d[i];
        idx2 = i;
      }
    }
    for (; i<N; i=active_nodes.succ[i]) {
      t_float tmp = D_(prev_node, i);
#if HAVE_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
      if (d[i] > tmp)
        d[i] = tmp;
      else if (fc_isnan(tmp))
        throw (nan_error());
#if HAVE_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
      if (d[i] < min) {
        min = d[i];
        idx2 = i;
      }
    }
    Z2.append(prev_node, idx2, min);
  }
}
コード例 #16
0
ファイル: Riemann.cpp プロジェクト: hgsteggles/Torch
void RotatedHartenLaxLeerSolver::solve(FluidArray& F, const FluidArray& Q_l, const FluidArray& Q_r, double a_l2, double a_r2, double gamma, int dim) const {
	bool pureHLLC = false, pureHLL = false;

	Eigen::Matrix<double, 3, 1> d(dim==0 ? 1 : 0, dim==1 ? 1 : 0, dim==2 ? 1 : 0);
	Eigen::Matrix<double, 3, 1> n1(Q_r[UID::VEL+0]-Q_l[UID::VEL+0], Q_r[UID::VEL+1]-Q_l[UID::VEL+1], Q_r[UID::VEL+2]-Q_l[UID::VEL+2]);
	Eigen::Matrix<double, 3, 1> n2;

	if (n1(dim) < 0)
		n1 = -1*n1;
	if (n1.norm() < 1.0e-6)
		pureHLLC = true;
	else {
		n1.normalize();
		if (n1.cross(d).norm() == 0)
			pureHLL = true;
		else {
			n2 = (n1.cross(d)).cross(n1);
			if (n2.norm() == 0)
				pureHLL = true;
			else {
				if (n2(dim) < 0)
					n2 = -1*n2;
				n2.normalize();
				if (n2.cross(d).norm() == 0)
					pureHLLC = true;
			}
		}
	}

	if (!pureHLLC && !pureHLL) {
		FluidArray F1, F2;
		FluidArray Q_l_R = Q_l;
		FluidArray Q_r_R = Q_r;

		//Eigen::Matrix<double, 3, 3> R1 = getRotationMatrix(axis1, alpha1, beta1);
		Eigen::Matrix<double, 3, 3> R1 = getRotationFromA2B(n1, d);
		rotate(R1, Q_l_R);
		rotate(R1, Q_r_R);
		m_hll.solve(F1, Q_l_R, Q_r_R, a_l2, a_r2, gamma, dim);
		//Eigen::Matrix<double, 3, 3> R1_inv = getInverseRotationMatrix(axis1, alpha1, beta1);
		Eigen::Matrix<double, 3, 3> R1_inv = getRotationFromA2B(d, n1);
		rotate(R1_inv, Q_l_R);
		rotate(R1_inv, Q_r_R);
		rotate(R1_inv, F1);

		//Eigen::Matrix<double, 3, 3> R2 = getRotationMatrix(axis2, alpha2, beta2);
		Eigen::Matrix<double, 3, 3> R2 = getRotationFromA2B(n2, d);
		rotate(R2, Q_l_R);
		rotate(R2, Q_r_R);
		m_hllc.solve(F2, Q_l_R, Q_r_R, a_l2, a_r2, gamma, dim);
		//Eigen::Matrix<double, 3, 3> R2_inv = getInverseRotationMatrix(axis2, alpha2, beta2);
		Eigen::Matrix<double, 3, 3> R2_inv = getRotationFromA2B(d, n2);
		rotate(R2_inv, Q_l_R);
		rotate(R2_inv, Q_r_R);
		rotate(R2_inv, F2);

		for (int iu = 0; iu < UID::N; ++iu)
			F[iu] = std::abs(d.dot(n1))*F1[iu] + std::abs(d.dot(n2))*F2[iu];
	}
	else if (pureHLL)
		m_hll.solve(F, Q_l, Q_r, a_l2, a_r2, gamma, dim);
	else if (pureHLLC)
		m_hllc.solve(F, Q_l, Q_r, a_l2, a_r2, gamma, dim);
}
コード例 #17
0
void FileTransferDlgNotify::createFile(const QString &name, unsigned size, bool bCanResume)
{
    m_name = name;
    m_size = size;
    m_name = m_name.replace(QRegExp("\\\\"), "/");
    FileTransfer *ft = m_dlg->m_msg->m_transfer;
    int n = m_name.findRev("/");
    if (n >= 0){
        QString path;
        QString p = m_name.left(n);
        while (!p.isEmpty()){
            if (!path.isEmpty())
                path += "/";
            QString pp = getToken(p, '/');
            if (pp == ".."){
                QString errMsg = i18n("Bad path: %1") .arg(m_name);
                m_dlg->m_msg->setError(errMsg.utf8());
                ft->setError();
                return;
            }
            path += pp;
            QDir dd(ft->dir() + "/" + path);
            if (!dd.exists()){
                QDir d(ft->dir());
                if (!d.mkdir(path)){
                    QString errMsg = i18n("Can't create: %1") .arg(path);
                    m_dlg->m_msg->setError(errMsg.utf8());
                    ft->setError();
                    return;
                }
            }
        }
    }
    m_dlg->m_msg->addFile(m_name, size);
    if (m_name.isEmpty() || (m_name[(int)(m_name.length() - 1)] == '/')){
        ft->startReceive(0);
        return;
    }
    QString shortName = m_name;
    m_name = ft->dir() + m_name;
    if (ft->m_file)
        delete ft->m_file;
    m_dlg->process();
    ft->m_file = new QFile(m_name);
    if (ft->m_file->exists()){
        switch (ft->overwrite()){
        case Skip:
            skip();
            return;
        case Replace:
            if (ft->m_file->open(IO_WriteOnly | IO_Truncate)){
                ft->startReceive(0);
                return;
            }
            break;
        case Resume:
            if (ft->m_file->open(IO_WriteOnly)){
                resume();
                return;
            }
            break;
        default:
            if (ft->m_file->open(IO_WriteOnly)){
                QStringList buttons;
                QString forAll;
                if (ft->files())
                    forAll = i18n("For all files");
                buttons.append(i18n("&Replace"));
                buttons.append(i18n("&Skip"));
                if (bCanResume && (ft->m_file->size() < size))
                    buttons.append(i18n("Resu&me"));
                m_dlg->m_ask = new BalloonMsg(NULL, quoteString(i18n("File %1 exists") .arg(shortName)),
                                              buttons, m_dlg->lblState, NULL, false, true, 150, forAll);
                QObject::connect(m_dlg->m_ask, SIGNAL(action(int, void*)), m_dlg, SLOT(action(int, void*)));
                raiseWindow(m_dlg);
                m_dlg->m_ask->show();
                return;
            }
        }
    }else{
コード例 #18
0
void MusicSearchEngine::watchForChanges()
{
	// Gather all folders registered on music locations
	QFileInfoList dirs;
	for (QString musicPath : SettingsPrivate::instance()->musicLocations()) {
		QFileInfo location(musicPath);
		QDirIterator it(location.absoluteFilePath(), QDir::Dirs | QDir::Hidden | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
		while (it.hasNext()) {
			QString entry = it.next();
			QFileInfo qFileInfo(entry);
			dirs << qFileInfo;
		}
	}

	SqlDatabase *db = SqlDatabase::instance();
	db->open();
	db->exec("PRAGMA journal_mode = MEMORY");
	db->exec("PRAGMA synchronous = OFF");
	db->exec("PRAGMA temp_store = 2");
	db->exec("PRAGMA foreign_keys = 1");

	QStringList newFoldersToAddInLibrary;
	// Add folders that were not found first
	for (QFileInfo f : dirs) {
		QSqlQuery query(*db);
		query.setForwardOnly(true);
		query.prepare("SELECT * FROM filesystem WHERE path = ?");
		query.addBindValue(f.absoluteFilePath());
		if (query.exec() && !query.next()) {
			newFoldersToAddInLibrary << f.absoluteFilePath();
			QSqlQuery prepared(*db);
			prepared.setForwardOnly(true);
			prepared.prepare("INSERT INTO filesystem (path, lastModified) VALUES (?, ?)");
			prepared.addBindValue(f.absoluteFilePath());
			prepared.addBindValue(f.lastModified().toTime_t());
			prepared.exec();
		}
	}

	if (!newFoldersToAddInLibrary.isEmpty()) {
		this->doSearch(newFoldersToAddInLibrary);
	}

	// Process in reverse mode to clean cache: from database file and check if entry exists in database
	QSqlQuery cache("SELECT * FROM filesystem", *db);
	qDebug() << Q_FUNC_INFO << "SELECT * FROM filesystem";
	cache.setForwardOnly(true);
	if (cache.exec()) {
		QStringList oldLocations;
		while (cache.next()) {
			QDir d(cache.record().value(0).toString());
			d.exists();
			QFileInfo fileInfo(cache.record().value(0).toString());
			// Remove folder in database because it couldn't be find in the filesystem
			if (!fileInfo.exists()) {
				QSqlQuery deleteFromFilesystem(*db);
				deleteFromFilesystem.prepare("DELETE FROM filesystem WHERE path = ?");
				deleteFromFilesystem.addBindValue(fileInfo.absoluteFilePath());
				qDebug() << Q_FUNC_INFO << "DELETE FROM filesystem WHERE path = ?";

				if (deleteFromFilesystem.exec()) {
					oldLocations << fileInfo.absoluteFilePath();
				}
			}
		}
		qDebug() << Q_FUNC_INFO << oldLocations;
		if (!oldLocations.isEmpty()) {
			db->rebuild(oldLocations, QStringList());
		}
	}
}
コード例 #19
0
 app * process_eq(func_decl * f, expr * arg1, expr * arg2) {
     expr * v;
     expr * t;
     if (uncnstr(arg1)) {
         v = arg1;
         t = arg2;
     }
     else if (uncnstr(arg2)) {
         v = arg2;
         t = arg1;
     }
     else {
         return 0;
     }
     
     sort * s = m().get_sort(arg1);
     
     // Remark:
     // I currently do not support unconstrained vars that have
     // uninterpreted sorts, for the following reasons:
     // - Soundness
     //     (forall ((x S) (y S)) (= x y))
     //     (not (= c1 c2))
     //
     //   The constants c1 and c2 have only one occurrence in
     //   the formula above, but they are not really unconstrained.
     //   The quantifier forces S to have interpretations of size 1.
     //   If we replace (= c1 c2) with fresh k. The formula will
     //   become satisfiable. 
     //
     // - Even if the formula is quantifier free, I would still
     //   have to build an interpretation for the eliminated 
     //   variables.
     //
     if (!m().is_fully_interp(s))
         return 0;
     
     // If the interpreted sort has only one element,
     // then it is unsound to eliminate the unconstrained variable in the equality
     sort_size sz = s->get_num_elements();
     
     if (sz.is_finite() && sz.size() <= 1)
         return 0;
     
     if (!m_mc) {
         // easy case, model generation is disabled.
         app * u;
         mk_fresh_uncnstr_var_for(f, arg1, arg2, u);
         return u;
     }
     
     expr_ref d(m());
     if (mk_diff(t, d)) {
         app * u;
         if (!mk_fresh_uncnstr_var_for(f, arg1, arg2, u))
             return u;
         add_def(v, m().mk_ite(u, t, d));
         return u;
     }
     return 0;
 }
コード例 #20
0
ファイル: bfgs.cpp プロジェクト: kevinr2763/gmsh
double BFGS (
    Vector & x,         // i: Startwert
    // o: Loesung, falls IFAIL = 0
    const MinFunction & fun,
    const OptiParameters & par,
    double eps
)


{
    int n = x.Size();
    long it;
    char a1crit, a3acrit;


    Vector d(n), g(n), p(n), temp(n), bs(n), xneu(n), y(n), s(n), x0(n);
    DenseMatrix l(n);
    DenseMatrix hesse(n);

    double /* normg, */ alphahat, hd, fold;
    double a1, a2;
    const double mu1 = 0.1, sigma = 0.1, xi1 = 1, xi2 = 10;
    const double tau = 0.1, tau1 = 0.1, tau2 = 0.6;

    Vector typx(x.Size());      // i: typische Groessenordnung der Komponenten
    double f, f0;
    double typf;               // i: typische Groessenordnung der Loesung
    double fmin = -1e5;           // i: untere Schranke fuer Funktionswert
    //  double eps = 1e-8;            // i: Abbruchschranke fuer relativen Gradienten
    double tauf = 0.1;            // i: Abbruchschranke fuer die relative Aenderung der
    //    Funktionswerte
    int ifail;                    // o:  0 .. Erfolg
    //    -1 .. Unterschreitung von fmin
    //     1 .. kein Erfolg bei Liniensuche
    //     2 .. Überschreitung von itmax

    typx = par.typx;
    typf = par.typf;


    l = 0;
    for (int i = 1; i <= n; i++)
        l.Elem(i, i) = 1;

    f = fun.FuncGrad (x, g);
    f0 = f;
    x0 = x;

    it = 0;
    do
    {
        // Restart

        if (it % (5 * n) == 0)
        {

            for (int i = 1; i <= n; i++)
                d(i-1) = typf/ sqr (typx(i-1));   // 1;
            for (int i = 2; i <= n; i++)
                for (int j = 1; j < i; j++)
                    l.Elem(i, j) = 0;

            /*
            hesse = 0;
            for (i = 1; i <= n; i++)
              hesse.Elem(i, i) = typf / sqr (typx.Get(i));

            fun.ApproximateHesse (x, hesse);

            Cholesky (hesse, l, d);
            */
        }

        it++;
        if (it > par.maxit_bfgs)
        {
            ifail = 2;
            break;
        }


        // Solve with factorized B

        SolveLDLt (l, d, g, p);

//      (*testout) << "l " << l << endl
// 		 << "d " << d << endl
// 		 << "g " << g << endl
// 		 << "p " << p << endl;


        p *= -1;
        y = g;

        fold = f;

        // line search

        alphahat = 1;
        lines (x, xneu, p, f, g, fun, par, alphahat, fmin,
               mu1, sigma, xi1, xi2, tau, tau1, tau2, ifail);

        if(ifail == 1)
            (*testout) << "no success with linesearch" << endl;

        /*
        // if (it > par.maxit_bfgs/2)
        {
          (*testout) << "x = " << x << endl;
          (*testout) << "xneu = " << xneu << endl;
          (*testout) << "f = " << f << endl;
          (*testout) << "g = " << g << endl;
        }
             */

        //      (*testout) << "it = " << it << " f = " << f << endl;
        //      if (ifail != 0) break;

        s.Set2 (1, xneu, -1, x);
        y *= -1;
        y.Add (1,g); // y += g;

        x = xneu;

        // BFGS Update

        MultLDLt (l, d, s, bs);

        a1 = y * s;
        a2 = s * bs;

        if (a1 > 0 && a2 > 0)
        {
            if (LDLtUpdate (l, d, 1 / a1, y) != 0)
            {
                cerr << "BFGS update error1" << endl;
                (*testout) << "BFGS update error1" << endl;
                (*testout) << "l " << endl << l << endl
                           << "d " << d << endl;
                ifail = 1;
                break;
            }

            if (LDLtUpdate (l, d, -1 / a2, bs) != 0)
            {
                cerr << "BFGS update error2" << endl;
                (*testout) << "BFGS update error2" << endl;
                (*testout) << "l " << endl << l << endl
                           << "d " << d << endl;
                ifail = 1;
                break;
            }
        }

        // Calculate stop conditions

        hd = eps * max2 (typf, fabs (f));
        a1crit = 1;
        for (int i = 1; i <= n; i++)
            if ( fabs (g(i-1)) * max2 (typx(i-1), fabs (x(i-1))) > hd)
                a1crit = 0;


        a3acrit = (fold - f <= tauf * max2 (typf, fabs (f)));

        //    testout << "g = " << g << endl;
        //    testout << "a1crit, a3crit = " << int(a1crit) << ", " << int(a3acrit) << endl;

        /*
        // Output for tests

        normg = sqrt (g * g);

        testout << "it =" << setw (5) << it
        << " f =" << setw (12) << setprecision (5) << f
        << " |g| =" << setw (12) << setprecision (5) << normg;

        testout << " x = (" << setw (12) << setprecision (5) << x.Elem(1);
        for (i = 2; i <= n; i++)
        testout << "," << setw (12) << setprecision (5) << x.Elem(i);
        testout << ")" << endl;
        */

        //(*testout) << "it = " << it << " f = " << f << " x = " << x << endl
        //	 << " g = " << g << " p = " << p << endl << endl;

        //      (*testout) << "|g| = " << g.L2Norm() << endl;

        if (g.L2Norm() < fun.GradStopping (x)) break;

    }
    while (!a1crit || !a3acrit);

    /*
    (*testout) << "it = " << it << " g = " << g << " f = " << f
         << " fail = " << ifail << endl;
    */
    if (f0 < f || (ifail == 1))
    {
        (*testout) << "fail, f = " << f << " f0 = " << f0 << endl;
        f = f0;
        x = x0;
    }

    //  (*testout) << "x = " << x << ", x0 = " << x0 << endl;
    return f;
}
コード例 #21
0
int main(int argc, char** argv) {


    set_program_options(opts, argc, argv);
///Carica l'opportuna struttura di adiacenza, selezionata da linea di comando
    if (opts.topologia == TORO_2D) 
        topologia = adiacenza_toroidal_lattice(opts.lato);        
    else if (opts.topologia == LINEARE){
        opts.partition_type = LINEAR_PARTITION;
        topologia = adiacenza_simple_line(opts.seq_len);
    }
    else {
        printf("Not supported topology\n");
        exit(1);
    }
    opts.seq_len = topologia.N;
    
    //logarithm lookup table, 6x program speedup
    mylog = new double[3 * opts.seq_len + 10];
    for (int i = 1; i < 3 * opts.seq_len + 10; i++)
        mylog[i] = log(i);
    mylog[0] = 0;
    myexp = new double[100];
    for (int i = 0; i < 100; i++)
        myexp[i] = exp(- opts.beta[0] * i);

    double media_globale = 0;
    double media_globale_n2 = 0;
    double media_rid_globale = 0;
    double media_rid_globale_n2 = 0;
    int n_estrazioni = 100;
    int runs = 0;

    
    // <editor-fold defaultstate="collapsed" desc="Sequenze monodimensionali">
    if (opts.topologia == LINEARE)
#pragma omp parallel
    {
        linear_partition *partitions = new linear_partition[opts.n_seq];
        int *buf_sequenze = new int[opts.n_seq * opts.seq_len];
        distance d(opts.seq_len);
        RandMT generatore;

        for (int L = 0; L < n_estrazioni; L++) {
            // Generazione di un nuovo vettore J_ij random
            // e di opts.n_seq sequenze che hanno quel J 

            double media_locale = 0;
            double media_locale_n2 = 0;
            double media_rid_locale = 0;
            double media_rid_locale_n2 = 0;
            ising_entries_jnorm(opts, buf_sequenze, generatore);

            //riempi le partizioni, a partire dalle sequenze date
            for (int i = 0; i < opts.n_seq; i++)
                partitions[i].fill(&buf_sequenze[i * opts.seq_len], opts.seq_len);


            //media delle distanze tra le coppie di sequenze generate
            //#pragma omp parallel for firstprivate(d) schedule(dynamic,10) reduction(+: media_n, media_n2)
            for (int i = 0; i < opts.n_seq; i++) {
                for (int j = i + 1; j < opts.n_seq; j++) {
                    d.dist(partitions[i], partitions[j]);
                    media_locale += d.dist_shan;
                    media_rid_locale += d.dist_shan_r;
                    media_locale_n2 += (d.dist_shan)*(d.dist_shan);
                    media_rid_locale_n2 += (d.dist_shan_r)*(d.dist_shan_r);
                }
            }
#pragma omp critical
            {
                media_globale += media_locale;
                media_globale_n2 += media_locale_n2;
                media_rid_globale += media_rid_locale;
                media_rid_globale_n2 += media_rid_locale_n2;
                runs += 1;
            }


        }
    }// </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Reticoli bidimensionali">
    if (opts.topologia == TORO_2D) {
        std::clock_t start = std::clock();
        double time_diff;
        double completed_ratio;
#pragma omp parallel num_threads(opts.threads)
        {
            general_partition *partitions = new general_partition[opts.n_seq];
            distance d(opts.seq_len);
            RandMT generatore;


            for (int L = 0; L < n_estrazioni; L++) {
                // Generazione di un nuovo vettore J_ij random
                // e di opts.n_seq sequenze che hanno quel J 

                double media_locale = 0;
            double media_locale_n2 = 0;
            double media_rid_locale = 0;
            double media_rid_locale_n2 = 0;

                ising_lattice(opts, generatore, partitions);

                //media delle distanze tra le coppie di sequenze generate
                //#pragma omp parallel for firstprivate(d) schedule(dynamic,10) reduction(+: media_n, media_n2)
                for (int i = 0; i < opts.n_seq; i++) {
                    for (int j = i + 1; j < opts.n_seq; j++) {
                        d(partitions[i], partitions[j]);
                         media_locale += d.dist_shan;
                    media_rid_locale += d.dist_shan_r;
                    media_locale_n2 += (d.dist_shan)*(d.dist_shan);
                    media_rid_locale_n2 += (d.dist_shan_r)*(d.dist_shan_r);
                    }
                }
#pragma omp critical
                {
                   media_globale += media_locale;
                media_globale_n2 += media_locale_n2;
                media_rid_globale += media_rid_locale;
                media_rid_globale_n2 += media_rid_locale_n2;
                    runs += 1;
                }


#ifdef _OPENMP
                int this_thread = omp_get_thread_num();
                if (this_thread)
                    continue;
                double time_ratio = omp_get_num_threads();
#else
                double time_ratio = 1.0;
#endif
                fprintf(stderr, "\r");
                time_diff = (std::clock() - start) / (double) CLOCKS_PER_SEC / time_ratio;
                completed_ratio = (L + 1.0) / n_estrazioni;
                fprintf(stderr, "%.1f%% done, ETA %.0fs    ",
                        completed_ratio * 100, ceil(time_diff * (1 / completed_ratio - 1)));
                fflush(stderr);

            }
        }
        time_diff = (std::clock() - start) / (double) CLOCKS_PER_SEC;
        fprintf(stderr, "\r100%% done in %.1f seconds of CPU time\n", time_diff);


    }// </editor-fold>


    double varianza_n, varianza_r;
    int Nd = runs * (opts.n_seq * (opts.n_seq - 1)) / 2;
    media_globale /= Nd;
    media_globale_n2 /= Nd;
    media_rid_globale /= Nd;
    media_rid_globale_n2 /= Nd;

    varianza_n = media_globale_n2 - media_globale*media_globale;
    varianza_r = media_rid_globale_n2 - media_rid_globale*media_rid_globale;
	int lunghezza;
	if(opts.topologia == TORO_2D)
		lunghezza=opts.lato;
	else
		lunghezza=opts.seq_len;
    printf("%d %f %f %f %f\n", lunghezza, media_globale, varianza_n, media_rid_globale, varianza_r);
    //fprintf(stderr, "%d %f %f\n", opts.seq_len, media_globale, varianza_n);


    return 0;
}
コード例 #22
0
ファイル: chemPointISAT.C プロジェクト: qyzeng/OpenFOAM-dev
void Foam::chemPointISAT<CompType, ThermoType>::qrDecompose
(
    const label nCols,
    scalarSquareMatrix& R
)
{
    scalarField c(nCols);
    scalarField d(nCols);
    scalar scale, sigma, sum;

    for (label k=0; k<nCols-1; k++)
    {
        scale = 0;
        for (label i=k; i<nCols; i++)
        {
            scale=max(scale, mag(R(i, k)));
        }
        if (scale == 0)
        {
            c[k] = d[k] = 0;
        }
        else
        {
            for (label i=k; i<nCols; i++)
            {
                R(i, k) /= scale;
            }
            sum = 0;
            for (label i=k; i<nCols; i++)
            {
                sum += sqr(R(i, k));
            }
            sigma = sign(R(k, k))*sqrt(sum);
            R(k, k) += sigma;
            c[k] = sigma*R(k, k);
            d[k] = -scale*sigma;
            for (label j=k+1; j<nCols; j++)
            {
                sum=0;
                for ( label i=k; i<nCols; i++)
                {
                    sum += R(i, k)*R(i, j);
                }
                scalar tau = sum/c[k];
                for ( label i=k; i<nCols; i++)
                {
                    R(i, j) -= tau*R(i, k);
                }
            }
        }
    }

    d[nCols-1] = R(nCols-1, nCols-1);

    // form R
    for (label i=0; i<nCols; i++)
    {
        R(i, i) = d[i];
        for ( label j=0; j<i; j++)
        {
            R(i, j)=0;
        }
    }
}
コード例 #23
0
ファイル: date.cpp プロジェクト: ipritish/cpp_basics
int main()
{
	Date d(11,25,2015);
	std::cout << d.GetMonth() << "\n";
	return 0;
}
コード例 #24
0
ファイル: hack.fight.c プロジェクト: ajinkya93/netbsd-src
/* return TRUE if mon still alive */
boolean
hmon(struct monst *mon, struct obj *obj, int thrown)
{
	int tmp;
	boolean         hittxt = FALSE;

	if (!obj) {
		tmp = rnd(2);	/* attack with bare hands */
		if (mon->data->mlet == 'c' && !uarmg) {
			pline("You hit the cockatrice with your bare hands.");
			pline("You turn to stone ...");
			done_in_by(mon);
		}
	} else if (obj->olet == WEAPON_SYM || obj->otyp == PICK_AXE) {
		if (obj == uwep && (obj->otyp > SPEAR || obj->otyp < BOOMERANG))
			tmp = rnd(2);
		else {
			if (strchr(mlarge, mon->data->mlet)) {
				tmp = rnd(objects[obj->otyp].wldam);
				if (obj->otyp == TWO_HANDED_SWORD)
					tmp += d(2, 6);
				else if (obj->otyp == FLAIL)
					tmp += rnd(4);
			} else {
				tmp = rnd(objects[obj->otyp].wsdam);
			}
			tmp += obj->spe;
			if (!thrown && obj == uwep && obj->otyp == BOOMERANG
			    && !rn2(3)) {
				pline("As you hit %s, the boomerang breaks into splinters.",
				      monnam(mon));
				freeinv(obj);
				setworn((struct obj *) 0, obj->owornmask);
				obfree(obj, (struct obj *) 0);
				obj = NULL;
				tmp++;
			}
		}
		if (mon->data->mlet == 'O' && obj != NULL &&
		    obj->otyp == TWO_HANDED_SWORD &&
		    !strcmp(ONAME(obj), "Orcrist"))
			tmp += rnd(10);
	} else
		switch (obj->otyp) {
		case HEAVY_IRON_BALL:
			tmp = rnd(25);
			break;
		case EXPENSIVE_CAMERA:
			pline("You succeed in destroying your camera. Congratulations!");
			freeinv(obj);
			if (obj->owornmask)
				setworn((struct obj *) 0, obj->owornmask);
			obfree(obj, (struct obj *) 0);
			return (TRUE);
		case DEAD_COCKATRICE:
			pline("You hit %s with the cockatrice corpse.",
			      monnam(mon));
			if (mon->data->mlet == 'c') {
				tmp = 1;
				hittxt = TRUE;
				break;
			}
			pline("%s is turned to stone!", Monnam(mon));
			killed(mon);
			return (FALSE);
		case CLOVE_OF_GARLIC:	/* no effect against demons */
			if (strchr(UNDEAD, mon->data->mlet))
				mon->mflee = 1;
			tmp = 1;
			break;
		default:
			/* non-weapons can damage because of their weight */
			/* (but not too much) */
			tmp = obj->owt / 10;
			if (tmp < 1)
				tmp = 1;
			else
				tmp = rnd(tmp);
			if (tmp > 6)
				tmp = 6;
		}

	/****** NOTE: perhaps obj is undefined!! (if !thrown && BOOMERANG) */

	tmp += u.udaminc + dbon();
	if (u.uswallow) {
		if ((tmp -= u.uswldtim) <= 0) {
			pline("Your arms are no longer able to hit.");
			return (TRUE);
		}
	}
	if (tmp < 1)
		tmp = 1;
	mon->mhp -= tmp;
	if (mon->mhp < 1) {
		killed(mon);
		return (FALSE);
	}
	if (mon->mtame && (!mon->mflee || mon->mfleetim)) {
		mon->mflee = 1;	/* Rick Richardson */
		mon->mfleetim += 10 * rnd(tmp);
	}
	if (!hittxt) {
		if (thrown) {
			/* this assumes that we cannot throw plural things */
			if (obj == NULL)
				panic("thrown non-object");
			hit(xname(obj) /* or: objects[obj->otyp].oc_name */ ,
			    mon, exclam(tmp));
		} else if (Blind)
			pline("You hit it.");
		else
			pline("You hit %s%s", monnam(mon), exclam(tmp));
	}
	if (u.umconf && !thrown) {
		if (!Blind) {
			pline("Your hands stop glowing blue.");
			if (!mon->mfroz && !mon->msleep)
				pline("%s appears confused.", Monnam(mon));
		}
		mon->mconf = 1;
		u.umconf = 0;
	}
	return (TRUE);		/* mon still alive */
}
コード例 #25
0
static gboolean
stream_eos (GMimeStream *stream)
{
	d(g_warning ("Invoked default stream_eos implementation."));
	return stream->position >= stream->bound_end;
}
コード例 #26
0
ファイル: hack.fight.c プロジェクト: ajinkya93/netbsd-src
/* hitmm returns 0 (miss), 1 (hit), or 2 (kill) */
int
hitmm(struct monst *magr, struct monst *mdef)
{
	const struct permonst *pa = magr->data, *pd = mdef->data;
	int             didhit;
	schar           tmp;
	boolean         vis;

	if (strchr("Eauy", pa->mlet))
		return (0);
	if (magr->mfroz)
		return (0);	/* riv05!a3 */
	tmp = pd->ac + pa->mlevel;
	if (mdef->mconf || mdef->mfroz || mdef->msleep) {
		tmp += 4;
		if (mdef->msleep)
			mdef->msleep = 0;
	}
	didhit = (tmp > rnd(20));
	if (didhit)
		mdef->msleep = 0;
	vis = (cansee(magr->mx, magr->my) && cansee(mdef->mx, mdef->my));
	if (vis) {
		char            buf[BUFSZ];
		if (mdef->mimic)
			seemimic(mdef);
		if (magr->mimic)
			seemimic(magr);
		(void) snprintf(buf, sizeof(buf), "%s %s", Monnam(magr),
			       didhit ? "hits" : "misses");
		pline("%s %s.", buf, monnam(mdef));
	} else {
		boolean         far = (dist(magr->mx, magr->my) > 15);
		if (far != far_noise || moves - noisetime > 10) {
			far_noise = far;
			noisetime = moves;
			pline("You hear some noises%s.",
			      far ? " in the distance" : "");
		}
	}
	if (didhit) {
		if (magr->data->mlet == 'c' && !magr->cham) {
			magr->mhpmax += 3;
			if (vis)
				pline("%s is turned to stone!", Monnam(mdef));
			else if (mdef->mtame)
				pline("You have a peculiarly sad feeling for a moment, then it passes.");
			monstone(mdef);
			didhit = 2;
		} else if ((mdef->mhp -= d(pa->damn, pa->damd)) < 1) {
			magr->mhpmax += 1 + rn2(pd->mlevel + 1);
			if (magr->mtame && magr->mhpmax > 8 * pa->mlevel) {
				if (pa == &li_dog)
					magr->data = pa = &dog;
				else if (pa == &dog)
					magr->data = pa = &la_dog;
			}
			if (vis)
				pline("%s is killed!", Monnam(mdef));
			else if (mdef->mtame)
				pline("You have a sad feeling for a moment, then it passes.");
			mondied(mdef);
			didhit = 2;
		}
	}
	return (didhit);
}
コード例 #27
0
static gint64
stream_seek (GMimeStream *stream, gint64 offset, GMimeSeekWhence whence)
{
	d(g_warning ("Invoked default stream_seek implementation."));
	return -1;
}
コード例 #28
0
static int callback_http_only(libwebsocket_context *context, struct libwebsocket *wsi,enum libwebsocket_callback_reasons reason, void *user, void *in, size_t len)
{
	unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 4096 + LWS_SEND_BUFFER_POST_PADDING];
	DebugOut() << __SMALLFILE__ << ":" << __LINE__ << reason << "callback_http_only" << endl;
	switch (reason)
	{
		case LWS_CALLBACK_CLOSED:
			//fprintf(stderr, "mirror: LWS_CALLBACK_CLOSED\n");
			//wsi_mirror = NULL;
			//printf("Connection closed!\n");
			break;

			//case LWS_CALLBACK_PROTOCOL_INIT:
		case LWS_CALLBACK_CLIENT_ESTABLISHED:
		{
			//This happens when a client initally connects. We need to request the support event types.
			source->clientConnected = true;
			source->checkSubscriptions();
			//printf("Incoming connection!\n");
			DebugOut() << __SMALLFILE__ <<":"<< __LINE__ << "Incoming connection" << endl;

			QVariantMap toSend;
			toSend["type"] = "method";
			toSend["name"] = "getSupported";
			toSend["transactionid"] = amb::createUuid().c_str();

			lwsWriteVariant(wsi, toSend);

			break;
		}
		case LWS_CALLBACK_CLIENT_RECEIVE:
		{
			QByteArray d((char*)in, len);

			WebSocketSource * manager = source;

			if(manager->expectedMessageFrames && manager->partialMessageIndex < manager->expectedMessageFrames)
			{
				manager->incompleteMessage += d;
				manager->partialMessageIndex++;
				break;
			}
			else if(manager->expectedMessageFrames && manager->partialMessageIndex == manager->expectedMessageFrames)
			{
				d = manager->incompleteMessage + d;
				manager->expectedMessageFrames = 0;
			}

			DebugOut(7) << "data received: " << d.data() << endl;

			int start = d.indexOf("{");

			if(manager->incompleteMessage.isEmpty() && start > 0)
			{
				DebugOut(7)<< "We have an incomplete message at the beginning.  Toss it away." << endl;
				d = d.right(start-1);
			}


			int end = d.lastIndexOf("}");

			if(end == -1)
			{
				manager->incompleteMessage += d;
				break;
			}

			QByteArray tryMessage = manager->incompleteMessage + d.left(end+1);

			DebugOut(6) << "Trying to parse message: " << tryMessage.data() << endl;

			QJsonDocument doc;

			QJsonParseError parseError;

			doc = QJsonDocument::fromJson(tryMessage, &parseError);

			if(doc.isNull())
			{
				DebugOut(7) << "Invalid or incomplete message" << endl;
				DebugOut(7) << parseError.errorString().toStdString() << ": " << parseError.offset << endl;
				manager->incompleteMessage += d;
				break;
			}

			manager->incompleteMessage = end == d.length()-1 ? "" : d.right(end);

			QVariantMap call = doc.toVariant().toMap();

			string type = call["type"].toString().toStdString();
			string name = call["name"].toString().toStdString();
			string id = call["transactionid"].toString().toStdString();

			if(type == "multiframe")
			{
				manager->expectedMessageFrames = call["frames"].toInt();
				manager->partialMessageIndex = 1;
				manager->incompleteMessage = "";

			}
			else if (type == "valuechanged")
			{
				QVariantMap data = call["data"].toMap();

				string value = data["value"].toString().toStdString();
				double timestamp = data["timestamp"].toDouble();
				int sequence = data["sequence"].toInt();
				Zone::Type zone = data["zone"].toInt();
				string type = data["type"].toString().toStdString();

				DebugOut() << __SMALLFILE__ <<":"<< __LINE__ << "Value changed:" << name << value << endl;

				try
				{
					auto property = properties.append(name, source->uuid(), zone, type);

					if(!property)
					{
						DebugOut(DebugOut::Warning) << "We either don't have this or don't support it ("
													<< name << "," << zone << "," << type << ")" << endl;
					}

					property->timestamp = timestamp;
					property->sequence = sequence;
					property->fromString(value);

					m_re->updateProperty(property.get(), source->uuid());

					double currenttime = amb::currentTime();

					/** This is now the latency between when something is available to read on the socket, until
					 *  a property is about to be updated in AMB.  This includes libwebsockets parsing and the
					 *  JSON parsing in this section.
					 */

					DebugOut()<<"websocket network + parse latency: "<<(currenttime - property->timestamp)*1000<<"ms"<<endl;
					totalTime += (currenttime - oldTimestamp)*1000;
					numUpdates ++;
					averageLatency = totalTime / numUpdates;

					DebugOut()<<"Average parse latency: "<<averageLatency<<endl;
				}
				catch (exception ex)
				{
					//printf("Exception %s\n",ex.what());
					DebugOut() << __SMALLFILE__ <<":"<< __LINE__ << "Exception:" << ex.what() << "\n";
				}
			}
			else if (type == "methodReply")
			{
				if (name == "getSupported" || name == "supportedChanged")
				{

					QVariant data = call["data"];

					QVariantList supported = data.toList();

					DebugOut() << __SMALLFILE__ <<":"<< __LINE__ << "Got getSupported request"<<endl;

					double serverTime = call["systemTime"].toDouble();

					DebugOut() << "Server time is: " << serverTime << endl;

					if(serverTime)
						source->serverTimeOffset = amb::Timestamp::instance()->epochTime() - serverTime;

					Q_FOREACH(QVariant p, supported)
					{
						QVariantMap d = p.toMap();
						Zone::Type zone = d["zone"].toInt();
						std::string name = d["property"].toString().toStdString();
						std::string proptype = d["type"].toString().toStdString();
						std::string source = d["source"].toString().toStdString();

						properties.append(name, source, zone, proptype);
					}

					source->updateSupported();

				}
				else if (name == "getRanged")
				{
					QVariantList data = call["data"].toList();

					std::list<AbstractPropertyType*> propertylist;

					Q_FOREACH(QVariant d, data)
					{
						QVariantMap obj = d.toMap();

						std::string name = obj["property"].toString().toStdString();
						std::string value = obj["value"].toString().toStdString();
						double timestamp = obj["timestamp"].toDouble() + source->serverTimeOffset;
						int sequence = obj["sequence"].toInt();

						AbstractPropertyType* type = VehicleProperty::getPropertyTypeForPropertyNameValue(name, value);
						if(!type)
						{
							DebugOut() << "TODO: support custom types here: " << endl;
							continue;
						}
						type->timestamp = timestamp;
						type->sequence = sequence;

						propertylist.push_back(type);
					}
コード例 #29
0
static GMimeStream *
stream_substream (GMimeStream *stream, gint64 start, gint64 end)
{
	d(g_warning ("Invoked default stream_tell implementation."));
	return NULL;
}
コード例 #30
0
ファイル: application.cpp プロジェクト: alisheikh/tdesktop
Application::Application(int &argc, char **argv) : PsApplication(argc, argv),
    serverName(psServerPrefix() + cGUIDStr()), closing(false),
	updateRequestId(0), updateReply(0), updateThread(0), updateDownloader(0) {

	DEBUG_LOG(("Application Info: creation.."));

	QByteArray d(QDir((cPlatform() == dbipWindows ? cExeDir() : cWorkingDir()).toLower()).absolutePath().toUtf8());
	char h[33] = { 0 };
	hashMd5Hex(d.constData(), d.size(), h);
	serverName = psServerPrefix() + h + '-' + cGUIDStr();

	if (mainApp) {
		DEBUG_LOG(("Application Error: another Application was created, terminating.."));
		exit(0);
	}
	mainApp = this;

	installEventFilter(new _DebugWaiter(this));

#if defined Q_OS_LINUX || defined Q_OS_LINUX64
    QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/DejaVuSans.ttf"));
    QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/NanumMyeongjo-Regular.ttf"));
#endif
    QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Regular.ttf"));
    QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Bold.ttf"));
    QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Semibold.ttf"));

	float64 dpi = primaryScreen()->logicalDotsPerInch();
	if (dpi <= 108) { // 0-96-108
		cSetScreenScale(dbisOne);
	} else if (dpi <= 132) { // 108-120-132
		cSetScreenScale(dbisOneAndQuarter);
	} else if (dpi <= 168) { // 132-144-168
		cSetScreenScale(dbisOneAndHalf);
	} else { // 168-192-inf
		cSetScreenScale(dbisTwo);
	}

    if (devicePixelRatio() > 1) {
        cSetRetina(true);
        cSetRetinaFactor(devicePixelRatio());
        cSetIntRetinaFactor(int32(cRetinaFactor()));
    }

	if (!cLangFile().isEmpty() && QFileInfo(cLangFile()).exists()) {
		LangLoaderPlain loader(cLangFile());
		cSetLangErrors(loader.errors());
		if (!cLangErrors().isEmpty()) {
			LOG(("Lang load errors: %1").arg(cLangErrors()));
		} else if (!loader.warnings().isEmpty()) {
			LOG(("Lang load warnings: %1").arg(loader.warnings()));
		}
	}

	Local::start();
	style::startManager();
	anim::startManager();
	historyInit();

	DEBUG_LOG(("Application Info: inited.."));

    window = new Window();

	psInstallEventFilter();

	connect(&socket, SIGNAL(connected()), this, SLOT(socketConnected()));
	connect(&socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
	connect(&socket, SIGNAL(error(QLocalSocket::LocalSocketError)), this, SLOT(socketError(QLocalSocket::LocalSocketError)));
	connect(&socket, SIGNAL(bytesWritten(qint64)), this, SLOT(socketWritten(qint64)));
	connect(&socket, SIGNAL(readyRead()), this, SLOT(socketReading()));
	connect(&server, SIGNAL(newConnection()), this, SLOT(newInstanceConnected()));
	connect(this, SIGNAL(aboutToQuit()), this, SLOT(closeApplication()));
	connect(&updateCheckTimer, SIGNAL(timeout()), this, SLOT(startUpdateCheck()));
	connect(this, SIGNAL(updateFailed()), this, SLOT(onUpdateFailed()));
	connect(this, SIGNAL(updateReady()), this, SLOT(onUpdateReady()));
	connect(this, SIGNAL(applicationStateChanged(Qt::ApplicationState)), this, SLOT(onAppStateChanged(Qt::ApplicationState)));
	connect(&writeUserConfigTimer, SIGNAL(timeout()), this, SLOT(onWriteUserConfig()));
	writeUserConfigTimer.setSingleShot(true);

	connect(&killDownloadSessionsTimer, SIGNAL(timeout()), this, SLOT(killDownloadSessions()));

	if (cManyInstance()) {
		startApp();
	} else {
        DEBUG_LOG(("Application Info: connecting local socket to %1..").arg(serverName));
		socket.connectToServer(serverName);
	}
}