コード例 #1
0
void cfg_menu_update_all_down()
{
	if(menu_item==0)
	{
		setP(20, menu_cfg_items_x[MENU_CFG_SAVE], 25 + 20*8 , menu_cfg_items_x[MENU_CFG_SAVE]+15);
		drawRect(0, true, 0);

		//menu_cfg_update_items();

		menu_item=12;
		draw_cfg_menu_items();

		menu_item=0;
		setP(20, menu_cfg_items_x[menu_item], 25 + 20*8 , menu_cfg_items_x[menu_item]+15);
		drawRect(0, false, 0);
		
	}
	else
	{
		setP(20, menu_cfg_items_x[menu_item-1], 25 + 20*8 , menu_cfg_items_x[menu_item-1]+15);
		drawRect(0, true, 0);

		//menu_cfg_update_items();
				
		menu_item-=1;
		draw_cfg_menu_items();

		menu_item+=1;
		setP(20, menu_cfg_items_x[menu_item], 25 + 20*8 , menu_cfg_items_x[menu_item]+15);
		drawRect(0, false, 0);
	}
	draw_cfg_menu_items();
	draw_cfg_menu();
}
コード例 #2
0
void cfg_menu_update_all_up()
{
	if(menu_item==12)
	{
		setP(20, menu_cfg_items_x[MENU_CFG_CPU], 25 + 20*8 , menu_cfg_items_x[MENU_CFG_CPU]+15);
		drawRect(0, true, 0);

		//menu_cfg_update_items();

		menu_item=0;
		draw_cfg_menu_items();

		menu_item=12;
		setP(20, menu_cfg_items_x[menu_item], 25 + 20*8 , menu_cfg_items_x[menu_item]+15);
		drawRect(0, false, 0);
		
	}
	else
	{
		setP(20, menu_cfg_items_x[menu_item+1], 25 + 20*8 , menu_cfg_items_x[menu_item+1]+15);
		drawRect(0, true, 0);

		//menu_cfg_update_items();
				
		menu_item+=1;
		draw_cfg_menu_items();

		menu_item-=1;
		setP(20, menu_cfg_items_x[menu_item], 25 + 20*8 , menu_cfg_items_x[menu_item]+15);
		drawRect(0, false, 0);
	}
	draw_cfg_menu_items();
	draw_cfg_menu();
}
コード例 #3
0
ファイル: Canhao.cpp プロジェクト: amandapriscilla/portfolio
void Canhao::mover(){
		if((key[KEY_RIGHT] || key[KEY_DOWN])&& this->tiro == false){
            if(p.x < 1200){
                this->proxBola->setP(proxBola->getP().x+10, proxBola->getP().y); // bola do canhao
                setP(this->p.x+10, this->p.y);
            }
		}
		else if((key[KEY_LEFT] || key[KEY_UP]) && this->tiro == false){
			if(p.x > 40){
                this->proxBola->setP(proxBola->getP().x-10, proxBola->getP().y); // bola do canhao
                setP(this->p.x-10, this->p.y);
			}
		}
}
コード例 #4
0
ファイル: beesActions.c プロジェクト: k4ppa/ABC_Algorithm
	void generateEmployedP(Bees bees, int i)
	{
		float newP;
		if (isEmployed(bees, i)) 
			newP = calcolateP(bees, i);
			setP(bees, i, newP);
	}
コード例 #5
0
// Set from OpenSSL representation
void OSSLDHPublicKey::setFromOSSL(const DH* inDH)
{
	const BIGNUM* bn_p = NULL;
	const BIGNUM* bn_g = NULL;
	const BIGNUM* bn_pub_key = NULL;

	DH_get0_pqg(inDH, &bn_p, NULL, &bn_g);
	DH_get0_key(inDH, &bn_pub_key, NULL);

	if (bn_p)
	{
		ByteString inP = OSSL::bn2ByteString(bn_p);
		setP(inP);
	}
	if (bn_g)
	{
		ByteString inG = OSSL::bn2ByteString(bn_g);
		setG(inG);
	}
	if (bn_pub_key)
	{
		ByteString inY = OSSL::bn2ByteString(bn_pub_key);
		setY(inY);
	}
}
コード例 #6
0
bool RSAPrivateKey::deserialise(ByteString& serialised)
{
	ByteString dP = ByteString::chainDeserialise(serialised);
	ByteString dQ = ByteString::chainDeserialise(serialised);
	ByteString dPQ = ByteString::chainDeserialise(serialised);
	ByteString dDP1 = ByteString::chainDeserialise(serialised);
	ByteString dDQ1 = ByteString::chainDeserialise(serialised);
	ByteString dD = ByteString::chainDeserialise(serialised);
	ByteString dN = ByteString::chainDeserialise(serialised);
	ByteString dE = ByteString::chainDeserialise(serialised);

	if ((dD.size() == 0) ||
	    (dN.size() == 0) ||
	    (dE.size() == 0))
	{
		return false;
	}

	setP(dP);
	setQ(dQ);
	setPQ(dPQ);
	setDP1(dDP1);
	setDQ1(dDQ1);
	setD(dD);
	setN(dN);
	setE(dE);

	return true;
}
コード例 #7
0
// Set from OpenSSL representation
void OSSLDSAPrivateKey::setFromOSSL(const DSA* dsa)
{
	if (dsa->p) { ByteString p = OSSL::bn2ByteString(dsa->p); setP(p); }
	if (dsa->q) { ByteString q = OSSL::bn2ByteString(dsa->q); setQ(q); }
	if (dsa->g) { ByteString g = OSSL::bn2ByteString(dsa->g); setG(g); }
	if (dsa->priv_key) { ByteString x = OSSL::bn2ByteString(dsa->priv_key); setX(x); }
}
コード例 #8
0
ファイル: Canhao.cpp プロジェクト: amandapriscilla/portfolio
Canhao::Canhao(Ponto p1){
	setP(p1.x, p1.y);
	proxBola = new Bola(50);
	proxBola->randomColor();
	proxBola->setP(p1.x+40, p1.y-5);
	tiro = false;
}
コード例 #9
0
// Set from OpenSSL representation
void OSSLDSAPublicKey::setFromOSSL(const DSA* inDSA)
{
	const BIGNUM* bn_p = NULL;
	const BIGNUM* bn_q = NULL;
	const BIGNUM* bn_g = NULL;
	const BIGNUM* bn_pub_key = NULL;

	DSA_get0_pqg(inDSA, &bn_p, &bn_q, &bn_g);
	DSA_get0_key(inDSA, &bn_pub_key, NULL);

	if (bn_p)
	{
		ByteString inP = OSSL::bn2ByteString(bn_p);
		setP(inP);
	}
	if (bn_q)
	{
		ByteString inQ = OSSL::bn2ByteString(bn_q);
		setQ(inQ);
	}
	if (bn_g)
	{
		ByteString inG = OSSL::bn2ByteString(bn_g);
		setG(inG);
	}
	if (bn_pub_key)
	{
		ByteString inY = OSSL::bn2ByteString(bn_pub_key);
		setY(inY);
	}
}
コード例 #10
0
ファイル: swdoor.cpp プロジェクト: Andriks/SwDoor
bool SwDoor::moveDoorLine(QPointF &p, QPointF &what_moving)
{
    calcCoef(p, what_moving);
    if (setP())
        return true;
    else
        return false;
}
コード例 #11
0
// Set from Botan representation
void BotanDHPublicKey::setFromBotan(const Botan::DH_PublicKey* dh)
{
	ByteString p = BotanUtil::bigInt2ByteString(dh->group_p());
	setP(p);
	ByteString g = BotanUtil::bigInt2ByteString(dh->group_g());
	setG(g);
	ByteString y = BotanUtil::bigInt2ByteString(dh->get_y());
	setY(y);
}
コード例 #12
0
// Set from Botan representation
void BotanDSAPrivateKey::setFromBotan(const Botan::DSA_PrivateKey* inDSA)
{
    ByteString inP = BotanUtil::bigInt2ByteString(inDSA->group_p());
    setP(inP);
    ByteString inQ = BotanUtil::bigInt2ByteString(inDSA->group_q());
    setQ(inQ);
    ByteString inG = BotanUtil::bigInt2ByteString(inDSA->group_g());
    setG(inG);
    ByteString inX = BotanUtil::bigInt2ByteString(inDSA->get_x());
    setX(inX);
}
コード例 #13
0
// Set from Botan representation
void BotanDSAPrivateKey::setFromBotan(const Botan::DSA_PrivateKey* dsa)
{
	ByteString p = BotanUtil::bigInt2ByteString(dsa->group_p());
	setP(p);
	ByteString q = BotanUtil::bigInt2ByteString(dsa->group_q());
	setQ(q);
	ByteString g = BotanUtil::bigInt2ByteString(dsa->group_g());
	setG(g);
	ByteString x = BotanUtil::bigInt2ByteString(dsa->get_x());
	setX(x);
}
コード例 #14
0
void gui_print(char *msg)
{
	setP(0, 253, 480, 272);
	drawRect(0, true, 0);
	setP0(5, 265);
	drawString(msg, FSHADOW);

	setP0(400, 265);
	if(state & PSP_USB_ACTIVATED) drawString("USB: ON", FSHADOW);
		else drawString("USB: OFF", FSHADOW);
}
コード例 #15
0
ファイル: elements_nodes.c プロジェクト: AdrianoOP/FEM
int setParamsN(element *e){
    int i,j,k;
    char buff[256];
    if(organizeNodes(e->no)<0){
        return(-1);
    }
    else{
        if(setP(e)<0 || setQ(e)<0 || setR(e)<0)
            return(-1);
    }
    return(0);
}
コード例 #16
0
ファイル: ChFun.cpp プロジェクト: rrnntt/SmallProject
/** Sets a new value to the i-th parameter.
 *  @param i :: The parameter index
 *  @param value :: The new value
 *  @param explicitlySet :: A boolean falgging the parameter as explicitly set (by user)
 */
void ChFun::setParameter(size_t i, const double& value, bool explicitlySet)
{
  if (i >= nParams())
  {
    throw std::out_of_range("ChFun parameter index out of range.");
  }
  setP( i, value );
  if (explicitlySet)
  {
    m_explicitlySet[i] = true;
  }
  this->updateStateRequired();
}
コード例 #17
0
bool DHParameters::deserialise(ByteString& serialised)
{
	ByteString dP = ByteString::chainDeserialise(serialised);
	ByteString dG = ByteString::chainDeserialise(serialised);

	if ((dP.size() == 0) ||
	    (dG.size() == 0))
	{
		return false;
	}

	setP(dP);
	setG(dG);

	return true;
}
コード例 #18
0
void draw_menu_section()
{
	setP(20, 2, 300, 18);
	drawRect(0, true, 0);

	setP0(25, 12);
	if(menu_section == MENU_SECTION_MAIN) drawString("Main", FTHICK | FSHADOW);
		else drawString("Main", FSHADOW);
#ifndef LIGHT
	setP0(75, 12);
	if(menu_section == MENU_SECTION_MUSIC) drawString("Music", FTHICK | FSHADOW);
		else drawString("Music", FSHADOW);
#endif
#ifdef VSH
	setP0(135, 12);
	if(menu_section == MENU_SECTION_TM) drawString("Tm", FTHICK | FSHADOW);
		else drawString("Tm", FSHADOW);

	setP0(175, 12);
	if(menu_section == MENU_SECTION_INFO) drawString("Infos", FTHICK | FSHADOW);
		else drawString("Infos", FSHADOW);

	setP0(235, 12);
	if(menu_section == MENU_SECTION_CFG) drawString("Config", FTHICK | FSHADOW);
		else drawString("Config", FSHADOW);
#elif GAME
#ifndef LIGHT
	setP0(130, 12);
	if(menu_section == MENU_SECTION_INFO) drawString("Infos", FTHICK | FSHADOW);
		else drawString("Infos", FSHADOW);

	setP0(185, 12);
	if(menu_section == MENU_SECTION_CFG) drawString("Config", FTHICK | FSHADOW);
		else drawString("Config", FSHADOW);
#else
	setP0(75, 12);
	if(menu_section == MENU_SECTION_INFO) drawString("Infos", FTHICK | FSHADOW);
		else drawString("Infos", FSHADOW);

	setP0(135, 12);
	if(menu_section == MENU_SECTION_CFG) drawString("Config", FTHICK | FSHADOW);
		else drawString("Config", FSHADOW);
#endif
#endif
}
コード例 #19
0
// Set from Botan representation
void BotanRSAPrivateKey::setFromBotan(const Botan::RSA_PrivateKey* inRSA)
{
	ByteString inP = BotanUtil::bigInt2ByteString(inRSA->get_p());
	setP(inP);
	ByteString inQ = BotanUtil::bigInt2ByteString(inRSA->get_q());
	setQ(inQ);
	ByteString inDP1 = BotanUtil::bigInt2ByteString(inRSA->get_d1());
	setDP1(inDP1);
	ByteString inDQ1 = BotanUtil::bigInt2ByteString(inRSA->get_d2());
	setDQ1(inDQ1);
	ByteString inPQ = BotanUtil::bigInt2ByteString(inRSA->get_c());
	setPQ(inPQ);
	ByteString inD = BotanUtil::bigInt2ByteString(inRSA->get_d());
	setD(inD);
	ByteString inN = BotanUtil::bigInt2ByteString(inRSA->get_n());
	setN(inN);
	ByteString inE = BotanUtil::bigInt2ByteString(inRSA->get_e());
	setE(inE);
}
コード例 #20
0
ファイル: DHPrivateKey.cpp プロジェクト: bellgrim/SoftHSMv2
bool DHPrivateKey::deserialise(ByteString& serialised)
{
	ByteString dP = ByteString::chainDeserialise(serialised);
	ByteString dG = ByteString::chainDeserialise(serialised);
	ByteString dX = ByteString::chainDeserialise(serialised);

	if ((dP.size() == 0) ||
	    (dG.size() == 0) ||
	    (dX.size() == 0))
	{
		return false;
	}

	setP(dP);
	setG(dG);
	setX(dX);

	return true;
}
コード例 #21
0
// Set from Botan representation
void BotanRSAPrivateKey::setFromBotan(const Botan::RSA_PrivateKey* rsa)
{
	ByteString p = BotanUtil::bigInt2ByteString(rsa->get_p());
	setP(p);
	ByteString q = BotanUtil::bigInt2ByteString(rsa->get_q());
	setQ(q);
	ByteString dp1 = BotanUtil::bigInt2ByteString(rsa->get_d1());
	setDP1(dp1);
	ByteString dq1 = BotanUtil::bigInt2ByteString(rsa->get_d2());
	setDQ1(dq1);
	ByteString pq = BotanUtil::bigInt2ByteString(rsa->get_c());
	setPQ(pq);
	ByteString d = BotanUtil::bigInt2ByteString(rsa->get_d());
	setD(d);
	ByteString n = BotanUtil::bigInt2ByteString(rsa->get_n());
	setN(n);
	ByteString e = BotanUtil::bigInt2ByteString(rsa->get_e());
	setE(e);
}
コード例 #22
0
// Set from OpenSSL representation
void OSSLRSAPrivateKey::setFromOSSL(const RSA* inRSA)
{
	if (inRSA->p)
	{
		ByteString inP = OSSL::bn2ByteString(inRSA->p);
		setP(inP);
	}
	if (inRSA->q)
	{
		ByteString inQ = OSSL::bn2ByteString(inRSA->q);
		setQ(inQ);
	}
	if (inRSA->dmp1)
	{
		ByteString inDP1 = OSSL::bn2ByteString(inRSA->dmp1);
		setDP1(inDP1);
	}
	if (inRSA->dmq1)
	{
		ByteString inDQ1 = OSSL::bn2ByteString(inRSA->dmq1);
		setDQ1(inDQ1);
	}
	if (inRSA->iqmp)
	{
		ByteString inPQ = OSSL::bn2ByteString(inRSA->iqmp);
		setPQ(inPQ);
	}
	if (inRSA->d)
	{
		ByteString inD = OSSL::bn2ByteString(inRSA->d);
		setD(inD);
	}
	if (inRSA->n)
	{
		ByteString inN = OSSL::bn2ByteString(inRSA->n);
		setN(inN);
	}
	if (inRSA->e)
	{
		ByteString inE = OSSL::bn2ByteString(inRSA->e);
		setE(inE);
	}
}
コード例 #23
0
void update_all_button()
{
		setP(195, 75, 195 + 17*8 , 88);
		drawRect(0, true, 0);
		setP0(200, 85);
		gprintf("%s + %s", config->button_combo, config->button_menu);

		setP(195, 90, 195 + 20*8 , 103);
		drawRect(0, true, 0);
		setP0(200, 100);
		gprintf("%s + %s", config->button_combo, config->button_screenshot);

		setP(195, 105, 195 + 20*8 , 118);
		drawRect(0, true, 0);
		setP0(200, 115);
		gprintf("%s + %s", config->button_combo, config->button_cpu_plus);

		setP(195, 120, 195 + 20*8 , 133);
		drawRect(0, true, 0);
		setP0(200, 130);
		gprintf("%s + %s", config->button_combo, config->button_cpu_minus);

		setP(195, 135, 195 + 20*8 , 148);
		drawRect(0, true, 0);
		setP0(200, 145);
		gprintf("%s + %s", config->button_combo, config->button_brightness_plus);

		setP(195, 150, 195 + 20*8 , 163);
		drawRect(0, true, 0);
		setP0(200, 160);
		gprintf("%s + %s", config->button_combo, config->button_brightness_minus);

		setP(195, 165, 195 + 20*8 , 178);
		drawRect(0, true, 0);
		setP0(200, 175);
		gprintf("%s + %s", config->button_combo, config->button_music_menu);
}
コード例 #24
0
/*----------------------------------------------------------------------*
 |  recreate this level (public)                             m.gee 01/05|
 |  this function assumes, that the graph of the fine level problem has |
 |  not changed since call to the constructor and therefore             |
 | the graph and it's coloring do not have to be recomputed             |  
 |  IMPORTANT:                                                          |
 |  No matter on which level we are here, the vector xfine is ALWAYS    |
 |  a fine grid vector here!                                            |
 *----------------------------------------------------------------------*/
bool ML_NOX::ML_Nox_MatrixfreeLevel::recreateLevel(int level, int nlevel, int plevel, 
                                                   ML* ml, ML_Aggregate* ag, Epetra_CrsMatrix** P,
                                                   ML_NOX::Ml_Nox_Fineinterface& interface, 
                                                   const Epetra_Comm& comm, const Epetra_Vector& xfine) 
{
   // make some tests
   if (level != level_)
   {
     cout << "**ERR**: ML_Epetra::ML_Nox_MatrixfreeLevel::recreateLevel:\n"
          << "**ERR**: level_ " << level_ << " not equal level " << level << "\n"
          << "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1;
   }
   if (nlevel != nlevel_)
   {
     cout << "**ERR**: ML_Epetra::ML_Nox_MatrixfreeLevel::recreateLevel:\n"
          << "**ERR**: nlevel_ " << nlevel_ << " not equal nlevel " << nlevel << "\n" 
          << "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1;
   }
   // printlevel might have changed
   ml_printlevel_ = plevel;
   ml_            = ml;
   ag_            = ag;
   destroyP();  // safer to use the new Ps
   setP(NULL);

   // we need the graph of the operator on this level. On the fine grid we can just ask the
   // fineinterface for it, on the coarser levels it has to be extracted from the ML-hierachy
   bool same;
   if (level_==0)
   {
      const Epetra_CrsGraph* graph = interface.getGraph();
      // check whether the old graph matches the new one
      same = compare_graphs(graph,graph_);
      destroyFD(); // we are here to recompute the FD-operator (this destroys graph_)
      graph_ = ML_NOX::deepcopy_graph(graph);
   }
   else
   {
      // Note that ML has no understanding of global indices, so it makes up new GIDs
      // (This also holds for the Prolongators P)
      Epetra_CrsMatrix* tmpMat  = 0;
      int               maxnnz  = 0;
      double            cputime = 0.0;
      ML_Operator2EpetraCrsMatrix(&(ml_->Amat[level_]), tmpMat, maxnnz, false, cputime);
      // get a view from the graph
      const Epetra_CrsGraph& graph = tmpMat->Graph();
      // compare the graph to the existing one
      same = compare_graphs(&graph,graph_);
      destroyFD(); // we are here to recompute the FD-operator (this destroys graph_)
      double t0 = GetClock();
      graph_ = ML_NOX::deepcopy_graph(&graph);
      // delete the copy of the Epetra_CrsMatrix
      if (tmpMat) delete tmpMat; tmpMat = 0;
      double t1 = GetClock();
      if (ml_printlevel_ > 0 && 0 == comm_.MyPID())
         cout << "matrixfreeML (level " << level_ << "): extraction/copy of Graph in " << cputime+t1-t0 << " sec\n"
              << "                        max-nonzeros in Graph: " << maxnnz << "\n";
   }
   
   // recreate this levels coarse interface
   if (same)
      coarseinterface_->recreate(ml_printlevel_,P,&(graph_->RowMap()));
   else
   {
      delete coarseinterface_;
      coarseinterface_ = new ML_NOX::Nox_CoarseProblem_Interface(fineinterface_,level_,ml_printlevel_,
                                                                 P,&(graph_->RowMap()),nlevel_);
   }
   
   // restrict the xfine-vector to this level 
   Epetra_Vector* xthis = coarseinterface_->restrict_fine_to_this(xfine);
   if (!xthis)
   {
     cout << "**ERR**: ML_Epetra::ML_Nox_MatrixfreeLevel::ML_Nox_MatrixfreeLevel:\n"
          << "**ERR**: ML_Epetra::Nox_CoarseProblem_Interface::restrict_fine_to_this returned NULL on level " 
          << level_ << "\n"
          << "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1;
   }

   Epetra_Vector* xc = new Epetra_Vector(graph_->RowMap(),false);
   // FIXME: after intesive testing, this test might be obsolet
#if 0
   bool samemap = xc->Map().PointSameAs(xthis->Map());
   if (samemap)
   {
#endif
      xc->Update(1.0,*xthis,0.0);
#if 0
   }
   else
   {
      cout << "**WRN** Maps are not equal in\n"
           << "**WRN** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
      // import the xthis vector in the Map that ML produced for graph_
      Epetra_Import* importer = new Epetra_Import(graph_->RowMap(),xthis->Map());  
      int ierr = xc->Import(*xthis,*importer,Insert);
      if (ierr)
      {
         cout << "**ERR**: ML_Epetra::ML_Nox_MatrixfreeLevel::ML_Nox_MatrixfreeLevel:\n"
              << "**ERR**: export from xthis to xc returned err=" << ierr <<"\n"
              << "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1;
      }
      if (importer) delete importer; importer = 0;
   }
#endif   
   if (xthis) delete xthis; xthis = 0;

   // create the coloring of the graph
   if (ml_printlevel_>0 && comm_.MyPID()==0)
   {
      cout << "matrixfreeML (level " << level_ << "): Entering Recoloring on level " << level_ << "\n";
      fflush(stdout);
   }
   double t0 = GetClock();
   if (!same) // te graph has obviously changed, so we need to recolor
   {
      if (colorMap_) delete colorMap_; colorMap_ = 0;
      if (colorMapIndex_) delete colorMapIndex_; colorMapIndex_ = 0;
      if (colorcolumns_) delete colorcolumns_; colorcolumns_ = 0;

      colorMap_ = ML_NOX::ML_Nox_collapsedcoloring(graph_,bsize_,isDiagonalOnly_,ml_printlevel_);
      if (!colorMap_) colorMap_ = ML_NOX::ML_Nox_standardcoloring(graph_,isDiagonalOnly_);
      colorMapIndex_ = new EpetraExt::CrsGraph_MapColoringIndex(*colorMap_);
      colorcolumns_  = &(*colorMapIndex_)(*graph_);
    }
    else if (ml_printlevel_>0 && comm_.MyPID()==0)
      cout << "matrixfreeML (level " << level_ << "): Reusing existing Coloring on level " << level_ << "\n";
    double t1 = GetClock();
    if (ml_printlevel_>5)
    {
      cout << "matrixfreeML (level " << level_ << "): Proc " << comm_.MyPID() <<" (Re)Coloring time is " << (t1-t0) << " sec\n";
      fflush(stdout);
    }

#if 0
   // print the colorMap_
   if (comm_.MyPID()==0)
   cout << "colorMap_\n";
   cout << *colorMap_;
   for (int i=0; i<colorcolumns_->size(); i++)
   {
      if (comm_.MyPID()==0)
         cout << "the " << i << " th colorcolumn_ - vector\n";
      cout << colorcolumns_->operator[](i);
   }
#endif
   
   // construct the FiniteDifferenceColoring-Matrix
   if (ml_printlevel_>0 && comm_.MyPID()==0)
   {
      cout << "matrixfreeML (level " << level_ << "): Entering Construction FD-Operator on level " << level_ << "\n";
      fflush(stdout);
   }

   t0 = GetClock();
#if 1 // FD-operator with coloring (see the #if 1 in ml_nox_matrixfreelevel.H as well!)
   FD_ = new NOX::EpetraNew::FiniteDifferenceColoring(*coarseinterface_,
                                                      *xc,
                                                      *graph_,
                                                      *colorMap_,
                                                      *colorcolumns_,
                                                      true,
                                                      isDiagonalOnly_,
                                                      fd_beta_,fd_alpha_);
#else // FD-operator without coloring
   FD_ = new NOX::EpetraNew::FiniteDifference(*coarseinterface_,
                                              *xc,
                                              *graph_,
                                              fd_beta_,fd_alpha_);
#endif

   // set differencing method
   if (fd_centered_)
   {
      FD_->setDifferenceMethod(NOX::EpetraNew::FiniteDifferenceColoring::Centered);
   }

   bool err = FD_->computeJacobian(*xc); 
   if (err==false)
   {
     cout << "**ERR**: ML_Epetra::ML_Nox_MatrixfreeLevel::ML_Nox_MatrixfreeLevel:\n"
          << "**ERR**: NOX::Epetra::FiniteDifferenceColoring returned an error on level " 
          << level_ << "\n"
          << "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1;
   }

   t1 = GetClock();
   if (ml_printlevel_>5)
      cout << "matrixfreeML (level " << level_ << "): Proc " << comm_.MyPID() 
           <<" Finite Differencing operator constr. in " << (t1-t0) << " sec\n";

   // get ref to computed Epetra_CrsMatrix  
   A_ = dynamic_cast<Epetra_CrsMatrix*>(&(FD_->getUnderlyingMatrix()));
   
   // print number of calls to the coarse interface
   if (ml_printlevel_>5 && comm_.MyPID()==0)
      cout << "matrixfreeML (level " << level_ << "): Calls to coarse-computeF in FD-Operator: "
           << coarseinterface_->numcallscomputeF() << "\n"; 
   
   // set counter for number of calls to the coarseinterface_->computeF back to zero
   coarseinterface_->resetnumcallscomputeF();   
   
   // tidy up 
   if (xc)       delete xc;       xc = 0;
   
   return true;
}
コード例 #25
0
ファイル: RNAMencoding.cpp プロジェクト: HongMok/QSC_NAM
void RNAMencoding(IplImage *img, double epsilon, vector<GrayLevel> &P, vector<char> &Q, vector<CouplePoints> &blks, int &frag_num, int HWratio, int DIRpriority)
{
	CvMat *R = cvCreateMat(img->height, img->width, CV_32FC1);
	CvMat *F = cvCreateMat(img->height, img->width, CV_32FC1);

	cvmSetZero(R);
	cvmSetZero(F);

	int r, c;
	int x1, y1, x2, y2;
	uchar *ptr;
	CouplePoints ps;


	for(r = 0; r < F->rows; r++)
	{
		ptr = (uchar *)(F->data.ptr + r*F->step);

		for(c = 0; c < F->cols; c++)
		{
			x1 = c;
			y1 = r;

			if(ptr[x1] != 0)
				continue;

			x2 = x1;
			y2 = y1;

			setPS(ps, x1, y1, x2, y2);
			if(DIRpriority == DIA_FIRST)//1.对角线搜索
			{
				while(x2<img->width && y2<img->height && IsHomogeneousBlock(img, ps, epsilon) == true && canF(F, ps))
				{
					x2++;
					y2++;
					setPS(ps, x1, y1, x2, y2);
				}
				x2--;
				y2--;

				int temp_x2 = x2 + 1;
				int temp_y2 = y2 + 1;


				//对角线方向停止,横向继续
				setPS(ps, x1, y1, temp_x2, y2);
				while(temp_x2<img->width && IsHomogeneousBlock(img, ps, epsilon) == true && canF(F, ps))
				{
					temp_x2++;
					setPS(ps, x1, y1, temp_x2, y2);
				}
				temp_x2--;
				//对角线方向停止,纵向继续
				setPS(ps, x1, y1, x2, temp_y2);
				while(temp_y2<img->height && IsHomogeneousBlock(img, ps, epsilon) == true && canF(F, ps))
				{
					temp_y2++;
					setPS(ps, x1, y1, x2, temp_y2);
				}
				temp_y2--;

				if(temp_x2 - x2 > temp_y2 - y2)//[对角线 + 横向] 更大
				{
					x2 = temp_x2;
				}
				else//[对角线 + 纵向] 更大
				{
					y2 = temp_y2;
				}
			}
			else
			{

				if(DIRpriority == ROW_FIRST)//行优先
				{
					while(x2<img->width && IsHomogeneousBlock(img, ps, epsilon) == true && canF(F, ps))
					{
						x2++;
						setPS(ps, x1, y1, x2, y2);
					}
					x2--;
					setPS(ps, x1, y1, x2, y2);
					while(y2<img->height && IsHomogeneousBlock(img, ps, epsilon) == true && canF(F, ps))
					{
						y2++;
						setPS(ps, x1, y1, x2, y2);
					}
					y2--;
				}
				else//列优先
				{
					while(y2<img->height && IsHomogeneousBlock(img, ps, epsilon) == true && canF(F, ps))
					{
						y2++;
						setPS(ps, x1, y1, x2, y2);
					}
					y2--;
					setPS(ps, x1, y1, x2, y2);
					while(x2<img->width && IsHomogeneousBlock(img, ps, epsilon) == true && canF(F, ps))
					{
						x2++;
						setPS(ps, x1, y1, x2, y2);
					}
					x2--;
				}

			}

			if(HWratio != NO_LIMIT)//有长宽比例限制
			{
				if( (x2-x1+1)/(y2-y1+1) > HWratio )
				{
					//宽度过大
					x2 = (y2-y1+1)*HWratio + x1-1;
				}
				else
				{
					if( (y2-y1+1)/(x2-x1+1) >HWratio )
					{
						//长度过大
						y2 = (x2-x1+1)*HWratio + y1-1;
					}
				}
			}

			setPS(ps, x1, y1, x2, y2);

			blks.push_back(ps);
			setF(F, ps);
			setR(R, ps);
			setP(P, img, ps);
		}
	}

	frag_num = calFragNum(P, R);

	switch (METHOD)
	{
	case METHOD_NAM:
		CompressCoordinate(R, Q);//坐标矩阵压缩
		break;
	case METHOD_FRAG_NAM:
		Fragment_CompressCoordinate(R, Q, frag_num);//分段编码压缩
		break;
	case METHOD_AC_NAM:
		AC_CompressCoordinate(R, _nsym, _count);
		break;
	case METHOD_AC_FRAG_NAM:
		AC_Fragment_CompressCoordinate(R, _nsym, _count, frag_num);
		break;
	}

	
	//
	//
	//
	//copyMat(cm1, R);
	//dispIline(R, 484);
}
コード例 #26
0
	void subtest1() {
		ButterFly *inP = getInP();
		setP(inP);
	}
コード例 #27
0
// Set from OpenSSL representation
void OSSLDHPrivateKey::setFromOSSL(const DH* dh)
{
	if (dh->p) { ByteString p = OSSL::bn2ByteString(dh->p); setP(p); }
	if (dh->g) { ByteString g = OSSL::bn2ByteString(dh->g); setG(g); }
	if (dh->priv_key) { ByteString x = OSSL::bn2ByteString(dh->priv_key); setX(x); }
}
コード例 #28
0
void draw_cfg_menu_init()
{
	setP(15, 25, 480, 249);
	clearRect(0);
	setP(16, 25, 459, 240);
	drawRect(15, true, 0x0A0000FF);

	setP(20, MENU_CFG_CPU_X, 25 + 20*8 , MENU_CFG_CPU_X+15);
	drawRect(0, false, 0);

	draw_cfg_menu_items();
	
	setP0(25, 55);
	drawString("Default Brightness :", FSHADOW);
	setP0(25, 70);
	drawString("Combo Button :", FSHADOW);
	setP0(25, 85);
	drawString("Menu Button :", FSHADOW);		
	setP0(25, 100);
	drawString("Screenshot Button :", FSHADOW);
	setP0(25, 115);
	drawString("Cpu Speed+ Button :", FSHADOW);
	setP0(25, 130);
	drawString("Cpu Speed- Button :", FSHADOW);
	setP0(25, 145);
	drawString("Brightness+ Button :", FSHADOW);
	setP0(25, 160);
	drawString("Brightness- Button :", FSHADOW);
	setP0(25, 175);
	drawString("Music Menu Button :", FSHADOW);

	setP0(25, 190);
	drawString("Music Folder :", FSHADOW);
	setP0(25, 205);
	drawString("Capture Folder :", FSHADOW);

	setP0(25, 230);
	drawString("Save Configuration", FSHADOW);

	setP0(200, 40);
	gprintf("%i", config->default_cpu_speed);
	setP0(200, 55);
	gprintf("%i", config->default_brightness);
	setP0(200, 70);
	gprintf("%s", config->button_combo);
	setP0(200, 85);
	gprintf("%s + %s", config->button_combo, config->button_menu);
	setP0(200, 100);
	gprintf("%s + %s", config->button_combo, config->button_screenshot);
	setP0(200, 115);
	gprintf("%s + %s", config->button_combo, config->button_cpu_plus);
	setP0(200, 130);
	gprintf("%s + %s", config->button_combo, config->button_cpu_minus);
	setP0(200, 145);
	gprintf("%s + %s", config->button_combo, config->button_brightness_plus);
	setP0(200, 160);
	gprintf("%s + %s", config->button_combo, config->button_brightness_minus);
	setP0(200, 175);
	gprintf("%s + %s", config->button_combo, config->button_music_menu);
	setP0(200, 190);
#ifdef LIGHT
	gprintf("Not Available");
#else
	gprintf("%s", config->music_folder);
#endif
	setP0(200, 205);
#ifdef LIGHT
	gprintf("Not Available");
#else
	gprintf("%s", config->capture_folder);
#endif
}
コード例 #29
0
void draw_cfg_menu()
{
	if(menu_item == MENU_CFG_CPU)
	{
		setP(195, 30, 195 + 4*8 , 43);
		drawRect(0, true, 0);
		setP0(200, 40);
		gprintf("%i", config->default_cpu_speed);
	}
	else if(menu_item == MENU_CFG_BRIGHTNESS)
	{
		setP(195, 45, 195 + 3*8 , 58);
		drawRect(0, true, 0);
		setP0(200, 55);
		gprintf("%i", config->default_brightness);
	}
	else if(menu_item == MENU_CFG_BT_COMBO)
	{
		setP(195, 60, 195 + 17*8 , 73);
		drawRect(0, true, 0);
		setP0(200, 70);
		gprintf("%s", config->button_combo);
	}
	else if(menu_item == MENU_CFG_BT_MENU)
	{
		setP(195, 75, 195 + 17*8 , 88);
		drawRect(0, true, 0);
		setP0(200, 85);
		gprintf("%s + %s", config->button_combo, config->button_menu);
	}
	else if(menu_item == MENU_CFG_BT_SCREENSHOT)
	{
		setP(195, 90, 195 + 20*8 , 103);
		drawRect(0, true, 0);
		setP0(200, 100);
		gprintf("%s + %s", config->button_combo, config->button_screenshot);
	}
	else if(menu_item == MENU_CFG_BT_CPU_PLUS)
	{
		setP(195, 105, 195 + 20*8 , 118);
		drawRect(0, true, 0);
		setP0(200, 115);
		gprintf("%s + %s", config->button_combo, config->button_cpu_plus);
	}
	else if(menu_item == MENU_CFG_BT_CPU_MINUS)
	{
		setP(195, 120, 195 + 20*8 , 133);
		drawRect(0, true, 0);
		setP0(200, 130);
		gprintf("%s + %s", config->button_combo, config->button_cpu_minus);
	}
	else if(menu_item == MENU_CFG_BT_BRIGHTNESS_PLUS)
	{
		setP(195, 135, 195 + 20*8 , 148);
		drawRect(0, true, 0);
		setP0(200, 145);
		gprintf("%s + %s", config->button_combo, config->button_brightness_plus);
	}
	else if(menu_item == MENU_CFG_BT_BRIGHTNESS_MINUS)
	{
		setP(195, 150, 195 + 20*8 , 163);
		drawRect(0, true, 0);
		setP0(200, 160);
		gprintf("%s + %s", config->button_combo, config->button_brightness_minus);
	}
	else if(menu_item == MENU_CFG_BT_MUSIC_MENU)
	{
		setP(195, 165, 195 + 20*8 , 178);
		drawRect(0, true, 0);
		setP0(200, 175);
		gprintf("%s + %s", config->button_combo, config->button_music_menu);
	}
	else if(menu_item == MENU_CFG_MUSIC_FOLDER)
	{
		setP(195, 180, 195 + 17*8 , 193);
		drawRect(0, true, 0);
		setP0(200, 190);
#ifdef LIGHT
		gprintf("Not Available");
#else
		gprintf("%s", config->music_folder);
#endif
	}
	else if(menu_item == MENU_CFG_CAPTURE_FOLDER)
	{
		setP(195, 195, 195 + 17*8 , 208);
		drawRect(0, true, 0);
		setP0(200, 205);
#ifdef LIGHT
		gprintf("Not Available");
#else
		gprintf("%s", config->capture_folder);
#endif
	}
}