示例#1
0
int kk(int m,int n)
{
	if(m==0)
	return n+1;
	if(n==0)
	return kk(m-1,1);
	else
	return kk(m-1,kk(m,n-1));
}
示例#2
0
文件: t_list.cpp 项目: huokedu/ardb
 void Ardb::AddBlockKey(Context& ctx, const std::string& key)
 {
     DBItemKey kk(ctx.currentDB, key);
     ctx.GetBlockContext().keys.insert(kk);
     WriteLockGuard<SpinRWLock> guard(m_block_ctx_lock);
     m_block_context_table[kk].push_back(&ctx);
 }
示例#3
0
InfoHandler::InfoHandler(QWidget *parent) : QObject(parent)
{
	m_pTimer = new QTimer(this);
	connect(m_pTimer, SIGNAL(timeout()), this, SLOT(Ontimeout()));

	QString exeFileName = QApplication::applicationFilePath();
	QFileInfo kk(exeFileName);
	QString apppath = kk.canonicalPath(); 
	QString ss = QDir::currentPath();
	QDir::setCurrent(apppath);

	list = XmlUtils::ReadXml("vv.xml");
	index = 0;


	QList<QHash<QString,QString>> vd = XmlUtils::readXml("vv.xml");
// 
// 	foreach (QVariant v, list)
// 	{
// 		
// 		QString ss = v.toMap().value("info").toString();
// 		//qDebug()<<ss;
// 	}


	QDir::setCurrent(ss);
	run();
}
示例#4
0
LOCAL_C void test3(CArrayFix<TInt>& aFix)
	{

	test.Next(_L("InsertIsqL"));
	TKeyArrayFix kk(0,ECmpTInt);

	TInt pos=0;
	TInt mod=47;
	TInt inc=23;
	TInt i=0;

	FOREVER
		{
		TInt ret;
		if (i&1)
			TRAP(ret,aFix.InsertIsqL(i,kk))
		else
			{
			TRAP(ret,pos=aFix.InsertIsqL(i,kk))
			if (ret==KErrNone)
				test(aFix[pos]==i);
			}
		if (ret==KErrAlreadyExists)
			break;
		i=(i+inc)%mod;
		}

	for(i=0;i<mod;i++)
		{
		test(aFix.FindIsq(i,kk,pos)==0);
		test(pos==i);
		TRAPD(r,aFix.InsertIsqL(i,kk))
		test(r==KErrAlreadyExists);
		}
	}
示例#5
0
文件: main.c 项目: gzhang01/cs124prog
int main(int argc, char* argv[]) {
    if (argc != 2) {
        printf("Usage: ./kk inputfile\n");
        return 1;
    }

    char* file = argv[1];
    int n = 100;

    // Read numbers from file
    FILE* f = fopen(file, "r");
    if (f == NULL) {
        printf("Could not open file\n");
        return 1;
    }

    // Input numbers into array nums
    uint64_t* nums = malloc(sizeof(uint64_t) * n);
    char* line = NULL;
    size_t read, len, i = 0;
    while ((read = getline(&line, &len, f)) != -1) {
        nums[i] = strtoull(line, NULL, 10);
        i++;
    }
    
    fclose(f);

    printf("%llu\n", kk(nums, n));
    free(nums);

    // part2();
    
    
}
void IMG_CreateComplexTexture(unsigned char *texture_img, int width, int height)
{
	nmppsSet_8u(texture_img, 0, width*height);
//	snmppcRand((unsigned)time( NULL ) );

	int side=width>>2;
	int side2=side>>1;
	int side4=side>>2;
	RPoint border[4];
	int y[4];
	for(int j=0; j<height; j+=side)
		for(int i=0; i<width; i+=side)
		{
			for(int n=0; n<4; n++)
				y[n]=nmppcRand();
			border[0]=RPoint(nmppcRandMinMax(0,side4-1)+i, y[0]%side4+j);
			border[1]=RPoint(nmppcRandMinMax(0,side4-1)+i, y[1]%side4+j+side2+side4);
			border[2]=RPoint(nmppcRandMinMax(0,side4-1)+i+side2+side4, y[1]%side4+j+side2+side4);
			border[3]=RPoint(nmppcRandMinMax(0,side4-1)+i+side2+side4, y[0]%side4+j);
			int color=100+nmppcRand()%156;
			for(int l=0; l<side; l++)
				for(int k=0; k<side; k++)
				{
					RPoint kk(i+k, j+l);
					if(PointInRectangle(kk, border))
					{
						int m1 = (j+l < height-1)? j+l : height-1;
						int m2 = (i+k < width-1)? i+k : width-1;
						nmppsPut_8u(texture_img,width*m1+m2,color);
					}

				}
		}
}
示例#7
0
ResPolyRing* readRing(std::istream& infile)
{
  // Hack job.
  // Input format:
  //   <characteristic>
  //   <n:#variables>
  //   <weight_0> <weight_1> ... <weight_(n-1)>
  //   grevlex | lex | ...
  int charac;
  int nvars;
  infile >> charac;
  infile >> nvars;
  std::vector<int> wts(nvars);
  for (int i=0; i<nvars; i++)
    {
      int a;
      infile >> a;
      wts.push_back(a);
    }
  MonomialOrdering mo(nvars, wts);
  MonomialInfo M(mo);
  M2::ARingZZp kk(101);
  ResGausser G(kk);

  ResPolyRing* R = new ResPolyRing(G,M);
  return R;
}
示例#8
0
bool Kyokumen::IsLegalMove(Teban teban, Te &te) const
{
	if ((te.GetKoma() & teban) == 0) {
		return false;
	}
	if (IS_HANDPOS(te.GetFrom())) {
		if (GetHandNum(te.GetKoma()) == 0) {
			return false;
		}
	}
	else {
		if (GetBanInf(te.GetFrom()) != te.GetKoma()) {
			return false;
		}
	}
	if ((GetBanInf(te.GetTo()) & teban) != 0) {
		return false;
	}
	if (IsCorrectMove(te)) {
		Kyokumen kk(*this);
		kk.Move(teban, te, true);
		if (teban == SELF && kk.GetControlE(kk.GetKingS()) != 0) {
			return false;
		}
		if (teban == ENEMY && kk.GetControlS(kk.GetKingE()) != 0) {
			return false;
		}
		return true;
	}
	return false;
}
示例#9
0
int Kyokumen::MakeChecks(Teban teban, Te *teBuf, int *pin)
{
	Kyokumen kk(*this);			// 実際に動かしてみる局面.
	const Kiki *selfControl;	// 手番側から見て、自分の利き.
	KomaPos enemyKing;				// 手番側から見て、相手の玉の位置.
	
	if (teban == SELF) {
		selfControl = kk.GetControlSPtr();
		enemyKing = GetKingE();
	}
	else {
		selfControl = kk.GetControlEPtr();
		enemyKing = GetKingS();
	}
	int teNum = MakeLegalMoves(teban, teBuf, pin);
	// 実際に動かしてみて、王手だけを残す。
	int outeNum = 0;
	for (int i=0; i < teNum; i++) {
		kk = *this;
		kk.Move(teban, teBuf[i], true);
		// 相手の玉に利きが付いていれば王手。
		if (selfControl[enemyKing]) {
			teBuf[outeNum++] = teBuf[i];
//		printf("MakeChecks ");
//		teBuf[i].Print();
//		printf("\n");
		}
	}
//#if defined(DEBUG_PRINT)
//	printf("MakeChecks(0x%02x) return [%d]\n", teban, outeNum);
//#endif // defined(DEBUG_PRINT).
	return outeNum;
}
示例#10
0
int main(){
	
	int a;
	a=kk(2,1);
	printf("a=%d",a);
	return 0;
	
}
示例#11
0
void initStyle()  // 加载qss 
{
	QString exeFileName = QApplication::applicationFilePath();
	QFileInfo kk(exeFileName);
	QString apppath = kk.canonicalPath(); 
	QDir::setCurrent(apppath/*QDir::currentPath()*/);//QApplication::applicationDirPath()
	QFile file(":/skin.qss");
	file.open(QFile::ReadOnly);
	QString style = QString(file.readAll());
	qApp->setStyleSheet(style);
	file.close();
}
示例#12
0
int Kyokumen::CheckMate(Teban teban, int depth, int depthMax, Te *checks, Te &te)
{
	int teNum = MakeChecks(teban, checks);
	if (teNum == 0) {
		TsumeHash::Add(m_KyokumenHashVal, m_HandHashVal, m_Hand+teban, -1, 0);
//#if defined(DEBUG_PRINT)
//		printf("CheckMate(0x%02x, %d, %d, 0x%02x) return[1] [%d]\n", teban, depth, depthMax, te.GetKoma(), -1);
//#endif // defined(DEBUG_PRINT).
		return -1;	//詰まない.
	}
	
	TsumeVal *p = TsumeHash::DomSearchCheckMate(m_KyokumenHashVal, m_Hand+teban);
	if (p != nullptr) {
		te = p->te;
//#if defined(DEBUG_PRINT)
//		printf("CheckMate(0x%02x, %d, %d, 0x%02x) return[2] [%d]\n", teban, depth, depthMax, te.GetKoma(), 1);
//#endif // defined(DEBUG_PRINT).
		return 1;	// 詰んだ.
	}
	int valmax = -1;
	for (int i=0; i < teNum; i++) {
		Kyokumen kk(*this);
		kk.Move(teban, checks[i], true);
#if defined(DEBUG_PRINT_TSUMI)
if (g_bDebugPrint) {
	printf("CheckMate depth[%d]", depth);
	checks[i].Print();
	printf("\n");
}
#endif // defined(DEBUG_PRINT_TSUMI).
		int val = kk.AntiCheckMate(teban^(SELF|ENEMY), depth+1, depthMax, checks+teNum);
		if (val > valmax) {
			valmax = val;
		}
		if (valmax == 1) {
			te = checks[i];
			break; //詰んだ.
		}
	}
	if (valmax == 1) { //詰んだ.
//		ASSERT(IS_SELFKOMA(te.GetKoma()));
		TsumeHash::Add(m_KyokumenHashVal, m_HandHashVal, m_Hand+teban, 1, te);
	}
	else if (valmax == -1) { //本当に詰まなかった.
		TsumeHash::Add(m_KyokumenHashVal, m_HandHashVal, m_Hand+teban, -1, 0);
	}
//#if defined(DEBUG_PRINT)
//	printf("CheckMate(0x%02x, %d, %d, 0x%02x) return[3] [%d]\n", teban, depth, depthMax, te.GetKoma(), valmax);
//#endif // defined(DEBUG_PRINT).
	return valmax;
}
示例#13
0
    result_type operator()(A0& out, const A1& in) const
    {
      size_t n =  boost::proto::child_c<0>(in);
      value_type fn =  value_type(n);
      table<value_type> ns =  nt2::cons(of_size(1, 3), fn, fn/12, fn/20);
      table<i_type> ee(nt2::of_size(1, 3));
      table<value_type> ff(nt2::of_size(1, 3));
//      nt2::frexp(ns, ff, ee);
      nt2::frexp(ns(1), ff(1), ee(1));
      nt2::frexp(ns(2), ff(2), ee(2));
      nt2::frexp(ns(3), ff(3), ee(3));
      BOOST_AUTO_TPL(kk, nt2::find(nt2::logical_and(eq(ff, nt2::Half<value_type>()), is_gtz(ee))));
      BOOST_ASSERT_MSG(!nt2::isempty(kk), "n must be of form 2^m or  12*2^m or 20*2^m");
      size_t k =  kk(1);
      i_type e = nt2::minusone(ee(k));
      out.resize(nt2::of_size(n, n));
      table<value_type> h;
      if (k == 1) //    n = 1 * 2^e;
      {
        h = nt2::One<value_type>();
      }
      else if ( k == 2) // N = 12 * 2^e;
      {
        h = nt2::vertcat(nt2::ones(1,12,meta::as_<value_type>()),
                         nt2::horzcat(nt2::ones(11,1,meta::as_<value_type>()),
                                      nt2::toeplitz(cons<value_type>(of_size(1, 11), -1, -1,  1, -1, -1, -1,  1,  1,  1, -1,  1),
                                                    cons<value_type>(of_size(1, 11), -1,  1, -1,  1,  1,  1, -1, -1, -1,  1, -1)
                                        )
                           )
          );
      }
      else if ( k == 3) // N = 20 * 2^e;
      {
          h = vertcat(nt2::ones(1,20,meta::as_<value_type>()),
                      nt2::horzcat(nt2::ones(19,1,meta::as_<value_type>()),
                              nt2::hankel(cons<value_type>(of_size(1, 19),-1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1, 1),
                                          cons<value_type>(of_size(1, 19),1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, -1, -1)
                                )
                        )
            );
      }
      //  Kronecker product construction.
      for (i_type i = 1; i <= e; ++i)
      {
        table<value_type> h1 =  nt2::vertcat(nt2::horzcat(h, h), nt2::horzcat(h, -h));
        h =  h1;  //ALIASING
      }
      out =  h;
      return out;
    }
示例#14
0
文件: kk.c 项目: avisaraf/124-prog3
int main(int argc, char* argv[]) {
    char* inputfile = argv[1];

    FILE* fp;
    fp = fopen(inputfile, "r");

    int* nums = construct_array(fp);

    int res = kk(nums);

    printf("%d\n", res);

    return 0;
}
示例#15
0
文件: main.c 项目: gzhang01/cs124prog
// Calculates residue for a prepartition solution
uint64_t partitionResidue(uint64_t* nums, int* s, int n) {
    // Calculate new numbers based on prepartition
    uint64_t* newNums = calloc(n, sizeof(uint64_t));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (s[j] == i) {
                newNums[i] += nums[j];
            }
        }
    }

    // Get residue
    uint64_t residue = kk(newNums, n);
    free(newNums);
    return residue;
}
 int numComponents(ListNode* head, vector<int>& G) {
   int cc = 0; //count of connected components
   unordered_set<int> kk(G.begin(), G.end());
   ListNode* temp = head;
   while(temp) {
     //if we find a value in LL
     if (inG(temp->val,kk)) {
       cc += 1;
       //keep checking the next value till you do not find value in vector, that will be the end of one cc
       while(temp->next && inG(temp->next->val,kk)) {
         temp = temp->next;
       }
     } else {
       temp = temp->next;
     }
   }
   return cc;
 }
示例#17
0
void Joseki::fromJoseki(const Kyokumen &shoki, Teban shokiTeban, Kyokumen &k, int tesu, int &teNum, Te te[], int hindo[])
{
	teNum = 0;
	int i;
	for (i=0; i < m_JosekiSize; i++) {
		Kyokumen kk(shoki);
		Teban teban = shokiTeban;
		int j;
		for (j=0; j < tesu; j++) {
			if (m_JosekiData[i][j*2] == 0 || m_JosekiData[i][j*2] == 0xff) {
				break;
			}
			Te te = Te(teban, m_JosekiData[i][j*2+1], m_JosekiData[i][j*2], kk);
			kk.Move(teban, te, false);
			if (teban == ENEMY) {
				teban = SELF;
			}
			else {
				teban = ENEMY;
			}
		}
		if (j == tesu && k == kk) {
			Te ret = Te(teban, m_JosekiData[i][j*2+1], m_JosekiData[i][j*2], kk);
			if (m_JosekiData[i][j*2] == 0 || m_JosekiData[i][j*2] == 0xff) {
				continue;
			}
			int l;
			for (l=0; l < teNum; l++) {
				if (ret == te[l]) {
					hindo[l]++;
					break;
				}
			}
			if (l == teNum) {
				te[l] = ret;
				hindo[l] = 1;
				teNum++;
			}
		}
	}
	if (m_Child != NULL && teNum == 0) {
		m_Child->fromJoseki(shoki, shokiTeban, k, tesu, teNum, te, hindo);
	}
}
示例#18
0
Status get_sub_dir(const std::string& db_dir, std::vector<std::string>* sub_dir) {
    if (!is_dir(db_dir.c_str())) {
        //printf("is not dir");
        return FILE_ERROR; 
    }   
    DIR* dir = opendir(db_dir.c_str());
    if (dir == NULL) {
        return FILE_ERROR;
        //printf("opendir error");
    }   
    struct dirent* dir_ptr;
    std::vector<std::string> file_list;
    while (dir_ptr = readdir(dir)) {
        std::string kk(dir_ptr->d_name);
        if (kk[0] == '.') {
            continue;
        }   
        std::string now = db_dir + "/" + kk; 
        if (is_dir(now.c_str())) {
            sub_dir->push_back(now);
        }   
    } 
    return OK;
}
示例#19
0
void talk(const std::string& filename = "data.dat",
          const std::string& title = "CMSSM spectrum generator run-time")
{
   std::ifstream ifs(filename.c_str());
   std::string line;

   if (!ifs.good()) {
      cout << "Error: could not open file: " << filename << endl;
      return;
   }

   const int NSG = 5;
   const double range_start = 0., range_stop = 0.7;
   TH1D* combined[NSG];
   TH1D* valid[NSG];
   TH1D* invalid[NSG];

   ULong64_t integral_valid[NSG];
   ULong64_t integral_invalid[NSG];
   ULong64_t integral_combined[NSG];

   combined[0] = new TH1D("combined[0]", "Softsusy 3.6.2"        , 20, range_start, range_stop);
   combined[1] = new TH1D("combined[1]", "FlexibleSUSY-CMSSM"    , 20, range_start, range_stop);
   combined[2] = new TH1D("combined[2]", "SPheno 3.3.7"          , 20, range_start, range_stop);
   combined[3] = new TH1D("combined[3]", "SPhenoMSSM"            , 20, range_start, range_stop);
   combined[4] = new TH1D("combined[4]", "FlexibleSUSY-CMSSMNoFV", 20, range_start, range_stop);

   valid[0] = new TH1D("valid[0]", "Softsusy 3.6.2"              , 20, range_start, range_stop);
   valid[1] = new TH1D("valid[1]", "FlexibleSUSY-CMSSM 1.2.0"    , 20, range_start, range_stop);
   valid[2] = new TH1D("valid[2]", "SPheno 3.3.7"                , 20, range_start, range_stop);
   valid[3] = new TH1D("valid[3]", "SPhenoMSSM 3.3.7/4.5.8"      , 20, range_start, range_stop);
   valid[4] = new TH1D("valid[4]", "FlexibleSUSY-CMSSMNoFV 1.2.0", 20, range_start, range_stop);

   invalid[0] = new TH1D("invalid[0]", "Softsusy"              , 20, range_start, range_stop);
   invalid[1] = new TH1D("invalid[1]", "FlexibleSUSY-CMSSM"    , 20, range_start, range_stop);
   invalid[2] = new TH1D("invalid[2]", "SPheno"                , 20, range_start, range_stop);
   invalid[3] = new TH1D("invalid[3]", "SPhenoMSSM"            , 20, range_start, range_stop);
   invalid[4] = new TH1D("invalid[4]", "FlexibleSUSY-CMSSMNoFV", 20, range_start, range_stop);

   for (int i = 0; i < NSG; i++) {
      combined[i]->SetStats(0);
      valid[i]->SetStats(0);
      invalid[i]->SetStats(0);
   }

   // initialize integrals
   for (int i = 0; i < NSG; i++) {
      integral_valid[i] = 0;
      integral_invalid[i] = 0;
      integral_combined[i] = 0;
   }

   while (getline(ifs,line)) {
      std::istringstream input(line);
      std::string word;
      input >> word;
      if (word != "" && word[0] != '#') {
         std::istringstream kk(line);
         double m0, m12, tanb, sgnmu, a0;
         double time[NSG];
         int error[NSG];

         kk >> m0 >> m12 >> tanb >> sgnmu >> a0;
         for (int i = 0; i < NSG; i++) {
            try {
               kk >> time[i] >> error[i];
            } catch (...) {
               cout << "Error: time and error are not convertible for"
                  " spectrum generator " << i << endl;
            }
         }

         for (int i = 0; i < NSG; i++) {
            combined[i]->Fill(time[i]);
            integral_combined[i]++;
            if (error[i] == 0) {
               valid[i]->Fill(time[i]);
               integral_valid[i]++;
            } else {
               invalid[i]->Fill(time[i]);
               integral_invalid[i]++;
            }
         }
      }
   }
示例#20
0
returnValue ExportArithmeticStatement::exportCodeMultiply(	FILE* file,
															BooleanType transposeRhs1,
															const char* _realString,
															const char* _intString,
															int _precision
															) const
{
	if ( ( lhs == 0 ) || ( rhs1 == 0 ) || ( rhs2 == 0 ) )
		return ACADOERROR( RET_UNABLE_TO_EXPORT_STATEMENT );

	char assignString[3];
	switch ( op0 )
	{
		case ESO_ASSIGN:
			strcpy( assignString,"=" );
			break;
		
		case ESO_ADD_ASSIGN:
			strcpy( assignString,"+=" );
			break;
			
		case ESO_SUBTRACT_ASSIGN:
			strcpy( assignString,"-=" );
			break;
			
		default:
			return ACADOERROR( RET_UNABLE_TO_EXPORT_STATEMENT );
	}

	uint nRowsRhs1;
	uint nColsRhs1;
	
	if ( transposeRhs1 == BT_FALSE )
	{
		nRowsRhs1 = rhs1->getNumRows( );
		nColsRhs1 = rhs1->getNumCols( );
	}
	else
	{
		nRowsRhs1 = rhs1->getNumCols( );
		nColsRhs1 = rhs1->getNumRows( );
	}
	
	if ( ( nColsRhs1 != rhs2->getNumRows( ) ) || 
		 ( nRowsRhs1 != lhs->getNumRows( ) ) || 
		 ( rhs2->getNumCols( ) != lhs->getNumCols( ) ) )
		return ACADOERROR( RET_VECTOR_DIMENSION_MISMATCH );


	char sign[2] = "+";

	if ( op2 != ESO_UNDEFINED )
	{
		if ( ( rhs3->getNumRows( ) != lhs->getNumRows( ) ) || 
			 ( rhs3->getNumCols( ) != lhs->getNumCols( ) ) )
			return ACADOERROR( RET_VECTOR_DIMENSION_MISMATCH );
		
		if ( op2 == ESO_SUBTRACT )
			sign[0] = '-';
	}


	BooleanType allZero;
// 	uint ii, kk;
// 	uint iiRhs1, kkRhs1;

	ExportIndex ii( "run1" ), iiRhs1( "run1" );
	ExportIndex kk( "run3" ), kkRhs1( "run3" );

	uint iMax = getNumRows( );
	if ( outerLoopVariable.isGiven( ) == BT_FALSE )
		iMax = 1;
	
	for( uint i=0; i<iMax; ++i )
	{
		if ( outerLoopVariable.isGiven( ) == BT_FALSE )
			acadoFPrintf( file,"for ( %s=0; %s<%d; ++%s ){\n", ii.name,ii.name,getNumRows(),ii.name );
		else
			ii == i;
	
		for( uint j=0; j<getNumCols( ); ++j )
		{
			allZero = BT_TRUE;
			acadoFPrintf( file,"%s %s", lhs->get(ii,j),assignString );

			for( uint k=0; k<nColsRhs1; ++k )
			{
				kk == k;
				if ( transposeRhs1 == BT_FALSE )
				{
					iiRhs1 = ii;
					kkRhs1 = kk;
				}
				else
				{
					iiRhs1 = kk;
					kkRhs1 = ii;
				}
				
				if ( ( rhs1->isZero(iiRhs1,kkRhs1) == BT_FALSE ) && 
					 ( rhs2->isZero(kk,j) == BT_FALSE ) )
				{
					allZero = BT_FALSE;
					
					if ( rhs1->isOne(iiRhs1,kkRhs1) == BT_FALSE )
					{
						acadoFPrintf( file," %s %s", sign,rhs1->get(iiRhs1,kkRhs1) );
						if ( rhs2->isOne(kk,j) == BT_FALSE )
							acadoFPrintf( file,"*%s", rhs2->get(kk,j) );
					}
					else
					{
						if ( rhs2->isOne(kk,j) == BT_FALSE )
							acadoFPrintf( file," %s %s", sign,rhs2->get(kk,j) );
						else
							acadoFPrintf( file," %s 1.0", sign );
					}
				}
			}
			
			if ( ( op2 == ESO_ADD ) || ( op2 == ESO_SUBTRACT ) )
				acadoFPrintf( file," + %s;\n", rhs3->get(ii,j) );

			if ( op2 == ESO_UNDEFINED )
			{
				if ( allZero == BT_TRUE )
					acadoFPrintf( file," 0.0;\n" );
				else
					acadoFPrintf( file,";\n" );
			}
		}
	}
	
	if ( outerLoopVariable.isGiven( ) == BT_FALSE )
		acadoFPrintf( file,"}\n" );
	

	return SUCCESSFUL_RETURN;
}
示例#21
0
LOCAL_C void test2(CArrayFix<TArr<TText,4> >& aFix)
//
	{
	test(aFix.Length()==sizeof(TArr<TText,4>));
	test.Next(_L("AppendL and insert strings of length 4"));
	TPtrC des1=_L("abcd");
	TPtrC des2=_L("efgh");
	aFix.AppendL(*(const TArr<TText,4>*)des1.Ptr());
	aFix.AppendL(*(const TArr<TText,4>*)des2.Ptr());
	test(aFix.Count()==2);
	TPtrC des3(&aFix[0][0],4);
	TPtrC des4(&aFix[1][0],4);
	test(des3==_L("abcd"));
	test(des4==_L("efgh"));
	aFix.InsertL(1,*(const TArr<TText,4>*)_S("ijkl"));
	test(aFix.Count()==3);	
	TPtrC des5(&aFix[2][0],4);
	test(des3==_L("abcd"));
	test(des4==_L("ijkl"));
	test(des5==_L("efgh"));

	test.Next(_L("Reset and Compress"));
	aFix.Reset();
	TBuf<0x10> buf1=_L("abcdefgh");
	aFix.AppendL((const TArr<TText,4>*)buf1.Ptr(),2);
	aFix.Compress();
	TPtrC des6(&aFix[0][0],4);
	test(des6==_L("abcd"));
	TPtrC des7(&aFix[1][0],4);
	test(des7==_L("efgh"));
	buf1=_L("ghighhxy");
	aFix.InsertL(1,(const TArr<TText,4>*)buf1.Ptr(),2);
	aFix.Compress();
	TPtrC des8(&aFix[0][0],4);
	test(des8==_L("abcd"));
	TPtrC des9(&aFix[1][0],4);
	test(des9==_L("ghig"));
	TPtrC des10(&aFix[2][0],4);
	test(des10==_L("hhxy"));
	TPtrC des11(&aFix[3][0],4);
	test(des11==_L("efgh"));

	test.Next(_L("Sort strings"));
	TKeyArrayFix kk(0,ECmpNormal,0x04);
	aFix.Sort(kk);
	TPtrC des12(&aFix[0][0],4);
	test(des12==_L("abcd"));
	TPtrC des13(&aFix[1][0],4);
	test(des13==_L("efgh"));
	TPtrC des14(&aFix[2][0],4);
	test(des14==_L("ghig"));
	TPtrC des15(&aFix[3][0],4);
	test(des15==_L("hhxy"));
	
	test.Next(_L("Find and FindIsq"));
	aFix.Compress();
	test(aFix.InsertIsqL(*(const TArr<TText,4>*)_S("ffff"),kk)==2);
	aFix.Compress();
	test(aFix.InsertIsqAllowDuplicatesL(*(const TArr<TText,4>*)_S("ffff"),kk)==3);
	aFix.Compress();
	TRAPD(r,aFix.InsertIsqL(*(const TArr<TText,4>*)_S("ffff"),kk))
	test(r==KErrAlreadyExists);
	TInt aPos=0;
	test(aFix.Find(*(const TArr<TText,4>*)_S("xxxx"),kk,aPos)==1);
	test(aPos==6);
	test(aFix.Find(*(const TArr<TText,4>*)_S("abcd"),kk,aPos)==0);
	test(aPos==0);
	test(aFix.Find(*(const TArr<TText,4>*)_S("ghig"),kk,aPos)==0);
	test(aPos==4);
	test(aFix.Find(*(const TArr<TText,4>*)_S("ffff"),kk,aPos)==0);
	test(aPos==2);
	test(aFix.Find(*(const TArr<TText,4>*)_S("hhxy"),kk,aPos)==0);
	test(aPos==5);
	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("bbbb"),kk,aPos)!=0);
	test(aPos==1);
	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("abcd"),kk,aPos)==0);
	test(aPos==0);
	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("ghig"),kk,aPos)==0);
	test(aPos==4);
	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("ffff"),kk,aPos)==0);
	test(aPos==2);
	test(aFix.InsertIsqL(*(const TArr<TText,4>*)_S("fghz"),kk)==4);
	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("fghz"),kk,aPos)==0);
	test(aPos==4);
	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("hhxy"),kk,aPos)==0);
	test(aPos==6);
	}
示例#22
0
文件: main.c 项目: gzhang01/cs124prog
void runSample() {
    // Getting random numbers
    int n = 100;
    uint64_t* nums = malloc(sizeof(uint64_t) * n);
    for (int i = 0; i < n; i++) {
        nums[i] = getNum();
    }

    // Generate sequence and partition (same result)
    int* s = sequenceGenerate(n);
    int* p = partitionGenerate(n);

    // Results and times
    uint64_t results[9];
    struct timeval times[10];
    gettimeofday(&times[0], NULL);
    results[0] = kk(nums, n);
    gettimeofday(&times[1], NULL);
    results[1] = sequenceResidue(nums, s, n);
    gettimeofday(&times[2], NULL);
    results[2] = partitionResidue(nums, p, n);
    gettimeofday(&times[3], NULL);
    results[3] = repeatedRandom(nums, s, n, 1);
    gettimeofday(&times[4], NULL);
    results[4] = repeatedRandom(nums, p, n, 0);
    gettimeofday(&times[5], NULL);
    results[5] = hillClimbing(nums, s, n, 1);
    gettimeofday(&times[6], NULL);
    results[6] = hillClimbing(nums, p, n, 0);
    gettimeofday(&times[7], NULL);
    results[7] = simulatedAnnealing(nums, s, n, 1);
    gettimeofday(&times[8], NULL);
    results[8] = simulatedAnnealing(nums, p, n, 0);
    gettimeofday(&times[9], NULL);

    // Difference between times
    int diff[9];
    for (int i = 0; i < 9; i++) {
        diff[i] = (int) ((1000000 * (times[i + 1].tv_sec - times[i].tv_sec) + (times[i + 1].tv_usec - times[i].tv_usec)) / 1000);
    }

    // Writing data and times to file
    FILE* f = fopen("data/data.csv", "a");
    if (f == NULL) {
        printf("Error opening file\n");
        return;
    }
    fprintf(f, "%lld,%lld,%lld,%lld,%lld,%lld,%lld,%lld,%lld\n", results[0], results[1], results[2], results[3], results[4], results[5], results[6], results[7], results[8]);
    fclose(f);

    f = fopen("data/times.csv", "a");
    if (f == NULL) {
        printf("Error opening file\n");
        return;
    }
    fprintf(f, "%i,%i,%i,%i,%i,%i,%i,%i,%i\n", diff[0], diff[1], diff[2], diff[3], diff[4], diff[5], diff[6], diff[7], diff[8]);
    fclose(f);

    // Free all allocated pointers
    free(nums);
    free(s);
    free(p);
}
示例#23
0
int main(int argc, char **argv) {
  char *x, *me = argv[0];
  char *last_msg = "\\c";
  errmsg_iam(me);
  if (argc<2) {
  help:
    errmsg_iam(0);
    carp(Kill_Help);
    _exit(1);
  }
  argv++;
  x = argv[0];
  if (x[0]=='-' && x[1]=='h') goto help; /* -h... --help */

  opendevconsole();

  /* ignore next signals */
  set_sa(SIGQUIT); set_sa(SIGCHLD); set_sa(SIGHUP );
  set_sa(SIGTSTP); set_sa(SIGTTIN); set_sa(SIGTTOU);

  while (argv[0] && argv[0][0]=='-') {
    int sig=0, cfg_wall=0;
    char *y = argv[0] + 1;
    if ((unsigned int)(*y - '0') < 10) { 
      sig = x_atoi(y);
      goto again;
    }
    
    switch(*y) {
    case 'v': cfg_verbose++; if (y[1]=='v') cfg_verbose++; break;
    case 'q': set_sa(SIGINT); break;
    case 's': chk_opt(argv,x); deep_sleep(x); break;
    case 'W': ++cfg_wall;
    case 'M': chk_opt(argv,x);
      if (x[0] == '%' && x[1] == 0) x = last_msg;
      else last_msg = x;
      print_escape(x, cfg_wall); 
      break;
    case 'E':
      chk_opt(argv,x); *argv = x;
      execve(argv[0], argv, environ);
      carp("Unable to exec: ", argv[0]);
      _exit(1);
    default:
#ifdef NSVC_SIGNAL_CODED
      {
	unsigned char *S, *Sig = (unsigned char *)NSVC_SIGNAL_CODED;
	for (S=Sig; *S; S += 2)
	  if ((unsigned char)*y == *S) { sig = S[1]; goto again; }
      }
#else
#define kk(C,S) case C: sig=S; break
	kk('t',SIGTERM); kk('a',SIGALRM); kk('p',SIGSTOP); kk('c',SIGCONT);
	kk('h',SIGHUP);  kk('i',SIGINT);  kk('k',SIGKILL);
#endif
      goto help;
    }

  again:
    if (sig > 0) {
      sync();
      if (cfg_verbose) msg("Sending signal: ", y);
      if (kill(-1, sig)) carp("Unable to send signal: ", y);
    }
    argv++;
  }
  sync();
  return 0;
}
示例#24
0
LOCAL_C void testFix(CArrayFix<TBuf<0x10> >& aFix)
//
// Test all methods
//
	{
	test.Next(_L("Test all methods"));
	test(aFix.Count()==0);
	test(aFix.Length()==sizeof(TBuf<0x10>));
	aFix.Compress();
	test(TRUE);
	aFix.Reset();
	test(TRUE);
	TKeyArrayFix kk(0,ECmpNormal,0x10);
	test(TRUE);
	aFix.Sort(kk);
	test(TRUE);
	TBuf<0x10> aa(_L("aaaaa"));
	aFix.InsertL(0,aa);
	test(TRUE);
	aFix[0].Fill(' ');
	test(TRUE);
	TBuf<0x10> z(aFix[0]);
    z.Length();
	test(TRUE);
	aFix[0].Fill('a');
	test(TRUE);
	TInt pp;
	test(aFix.Find(aa,kk,pp)==0);
	test(pp==0);
	aFix.Delete(0);
	TBuf<0x10> bb(_L("bbbbb"));
	aFix.AppendL(bb);
	test(aFix.Count()==1);
	test(aFix.InsertIsqAllowDuplicatesL(aa,kk)==0);
	test(aFix.InsertIsqAllowDuplicatesL(bb,kk)==2);
	test(aFix.FindIsq(aa,kk,pp)==0);
	test(pp==0);
	aFix.Reset();
	for(TInt index=0;index<KTestGranularity*7/2;index++)
		aFix.AppendL(aa);
	const TBuf<0x10> *end=NULL;
	const TBuf<0x10> *ptr=NULL;
	for(TInt index2=0;index2<KTestGranularity*7/2;index2++)
		{
		if (end==ptr)
			{
			end=aFix.End(index2);
			ptr=&aFix[index2];
			TInt seglen=end-ptr;
			test(seglen==KTestGranularity || seglen==(aFix.Count()-index2));
			}
		test(&aFix[index2]==ptr++);
		}
	const TBuf<0x10> *bak=NULL;
	ptr=NULL;
	for(TInt index3=KTestGranularity*7/2;index3>0;index3--)
		{
		if (bak==ptr)
			{
			bak=aFix.Back(index3);
			ptr=&aFix[index3-1]+1;
			TInt seglen=ptr-bak;
			test(seglen==KTestGranularity || seglen==index3 || seglen==index3%KTestGranularity);
			}
		test(&aFix[index3-1]==--ptr);
		}
	
	//Test ExpandL
	//Expand array in slot 1
	TBuf16<0x10> exp;
	exp=_L("abc AbC");
	aFix.InsertL(0,exp);
	aFix.InsertL(1,exp);
	aFix.InsertL(2,exp);
	exp=aFix.ExpandL(1);
	test(aFix[0]==_L("abc AbC"));
	test(aFix[1]==_L(""));
	test(aFix[2]==_L("abc AbC"));
	test(aFix[3]==_L("abc AbC"));
	
	//Test ResizeL and InsertReplL
	//Resize the array to containing 20 records,
	//copying a record into any new slots.
	TBuf<0x10> res(_L("bbbbb"));
	aFix.Reset();
	aFix.ResizeL(20,res);
	for(TInt i=0;i<20;i++)
	    {
        test(aFix[1]==_L("bbbbb"));
	    }
	}
示例#25
0
void KNDdeTorusCollocation::init(const KNVector& sol, const KNVector& par)
{
  double* t1 = new double[NTAU+1];
  double* t2 = new double[NTAU+1];
  for (size_t i2 = 0; i2 < nint2; i2++)
  {
    for (size_t i1 = 0; i1 < nint1; i1++)
    {
      for (size_t j2 = 0; j2 < ndeg2; j2++)
      {
        for (size_t j1 = 0; j1 < ndeg1; j1++)
        {
          const size_t idx = idxmap(j1, j2, i1, i2); // this is a unique

          time1(idx) = ((double)i1 + col1(j1)) / nint1;
          time2(idx) = ((double)i2 + col2(j2)) / nint2;
        }
      }
    }
  }

  sys->p_tau(p_tau, time1, par);

  p_xx.clear();
  for (size_t idx = 0; idx < time1.size(); ++idx)
  {
    t1[0] = time1(idx);
    t2[0] = time2(idx);
    for (size_t k = 0; k < NTAU; k++)
    {
      t1[1+k] = (t1[0] - p_tau(k,idx) / par(0)) - floor(t1[0] - p_tau(k,idx) / par(0));
      t2[1+k] = (t2[0] - par(RHO) * p_tau(k,idx) / par(0)) - floor(t2[0] - par(RHO) * p_tau(k,idx) / par(0));
    }

    for (size_t k = 0; k < NTAU + 1; k++)
    {
      size_t i1 = static_cast<size_t>(floor(nint1 * t1[k]));
      size_t i2 = static_cast<size_t>(floor(nint2 * t2[k]));
      // some error checking
      if ((t1[k] > 1.0) || (t2[k] > 1.0) ||
          (t1[k] < 0.0) || (t2[k] < 0.0)) std::cout << "Er ";
      if ((i1 >= nint1) || (i2 >= nint2)) std::cout << "Ei ";
      // end error checking
      for (size_t j2 = 0; j2 < ndeg2 + 1; j2++)
      {
        for (size_t j1 = 0; j1 < ndeg1 + 1; j1++)
        {
          const size_t idxKK = idxkk(j1, j2, k);
          kk(idxKK,idx) = idxmap(j1, j2, i1, i2);
          ee(idxKK,idx) = idxKK;
        }
      }
    }

    // sorting
    comp aa(kk.pointer(0,idx));
    std::sort(ee.pointer(0,idx), ee.pointer(0,idx) + (NTAU + 1)*(ndeg1 + 1)*(ndeg2 + 1), aa);

    // filtering same indices
    rr(ee(0,idx),idx) = 0;
    size_t nz = 0;
    for (size_t i = 1; i < (NTAU + 1)*(ndeg1 + 1)*(ndeg2 + 1); i++)
    {
      if (kk(ee(i-1,idx),idx) != kk(ee(i,idx),idx)) nz++;
      rr(ee(i,idx),idx) = nz;
    }

    // interpolate the solution
    for (size_t k = 1; k < NTAU + 1; k++)
    {
      const double c1 = nint1 * t1[k] - floor(nint1 * t1[k]);
      const double c2 = nint2 * t2[k] - floor(nint2 * t2[k]);
      for (size_t j2 = 0; j2 < ndeg2 + 1; j2++)
      {
        for (size_t j1 = 0; j1 < ndeg1 + 1; j1++)
        {
          const size_t idxKK = idxkk(j1, j2, k);
          const double cf = poly_lgr_eval(mesh1, j1, c1) * poly_lgr_eval(mesh2, j2, c2);
          for (size_t p = 0; p < NDIM; p++)
          {
            p_xx(p, k - 1, idx) += cf * sol(p + NDIM * kk(idxKK, idx));
          }
        }
      }
    }
    // derivatives at all delays
    for (size_t k = 0; k < NTAU + 1; k++)
    {
      const double c1 = nint1 * t1[k] - floor(nint1 * t1[k]);
      const double c2 = nint2 * t2[k] - floor(nint2 * t2[k]);
      for (size_t j2 = 0; j2 < ndeg2 + 1; j2++)
      {
        for (size_t j1 = 0; j1 < ndeg1 + 1; j1++)
        {
          const size_t idxKK = idxkk(j1, j2, k);
          const double cf1 = poly_dlg_eval(mesh1, j1, c1) * nint1 * poly_lgr_eval(mesh2, j2, c2);
          const double cf2 = poly_lgr_eval(mesh1, j1, c1) * poly_dlg_eval(mesh2, j2, c2) * nint2;
          for (size_t p = 0; p < NDIM; p++)
          {
            p_xx(p, NTAU + 2*k, idx)   += cf1 * sol(p + NDIM * kk(idxKK, idx));
            p_xx(p, NTAU + 2*k + 1, idx) += cf2 * sol(p + NDIM * kk(idxKK, idx));
          }
        }
      }
    }
  }
//   for (int idx = 0; idx < time1.size(); ++idx) std::cout<<p_xx(0, NTAU, idx)<<"\t";
//   std::cout<<"\np_xx(0,...) was\n";
  delete[] t2;
  delete[] t1;
}
示例#26
0
void KNDdeTorusCollocation::jacobian(KNSparseMatrix& A, KNArray1D< KNVector* > Avar, KNVector& rhs, KNVector& par, KNVector& /*sol*/, KNArray1D<size_t>& var)
{
  A.clear();
  rhs.clear();
  for (size_t r = 0; r < var.size(); r++) Avar(r)->clear();
  // rhs doesn't need to be cleared

  // creates kk, ee, rr & interpolates p_xx & gets p_tau
//   init(sol, par);
  // builds up the structure of the sparse matrix
  for (size_t idx = 0; idx < time1.size(); ++idx)
  {
    const size_t lend = NDIM * (rr(ee((NTAU+1)*(ndeg1+1)*(ndeg2+1)-1,idx),idx) + 1);
    for (size_t p = 0; p < NDIM; p++) A.newLine(lend);
  }

  // the right-hand side
  sys->p_rhs(p_fx, time1, p_xx, par, 0);
  for (size_t idx = 0; idx < time1.size(); ++idx)
  {
    for (size_t p = 0; p < NDIM; p++) 
    {
      rhs(p + NDIM*idx) = par(0) * p_fx(p,idx) - p_xx(p, NTAU, idx) - par(RHO) * p_xx(p, NTAU + 1, idx);
    }
  }

  // derivatives w.r.t the parameters
  for (size_t r = 0; r < var.size(); r++)
  {
    KNVector& deri = *Avar(r);
    deri.clear();
//!!!!!!!!!!!!!!!!!
//!BEGIN w.r.t the period
//!!!!!!!!!!!!!!!!!
    if (var(r) == 0)
    {
      for (size_t idx = 0; idx < time1.size(); ++idx)
      {
        for (size_t p = 0; p < NDIM; p++) deri(p + NDIM*idx) = -p_fx(p,idx);
      }
      sys->p_dtau(p_dtau, time1, par, 0);
      for (size_t k = 0; k < NTAU; k++)
      {
        size_t nx = 1, vx = k, np = 0, vp = 0;
        sys->p_deri(p_dfx, time1, p_xx, par, 0, nx, &vx, np, &vp, p_dummy);
        for (size_t idx = 0; idx < time1.size(); ++idx)
        {
          for (size_t p = 0; p < NDIM; p++)
          {
            for (size_t q = 0; q < NDIM; q++)
            {
              const double d = p_tau(k,idx) / par(0) - p_dtau(k,idx);
              deri(p + NDIM*idx) -= p_dfx(p, q, idx) * d * (p_xx(q, NTAU + 2 * (k + 1), idx) + par(RHO) * p_xx(q, NTAU + 2 * (k + 1) + 1, idx));
            }
          }
        }
      }
    }
    else
//!!!!!!!!!!!!!!!!!
//!END w.r.t the period
//!!!!!!!!!!!!!!!!!
//
//!!!!!!!!!!!!!!!!!
//!BEGIN w.r.t the ordinary parameters
//!!!!!!!!!!!!!!!!!
    // derivatives w.r.t. the real parameters
    if (var(r) < NPAR)
    {
      size_t nx = 0, vx = 0, np = 1, vp = var(r);
      sys->p_deri(p_dfp, time1, p_xx, par, 0, nx, &vx, np, &vp, p_dummy);
      for (size_t idx = 0; idx < time1.size(); ++idx)
      {
        for (size_t p = 0; p < NDIM; p++) deri(p + NDIM*idx) = - par(0) * p_dfp(p, 0, idx);
      }
    }
    else
//!!!!!!!!!!!!!!!!!
//!END w.r.t the ordinary parameters
//!!!!!!!!!!!!!!!!!
//
//!!!!!!!!!!!!!!!!!
//!BEGIN w.r.t the rotation number
//!!!!!!!!!!!!!!!!!
    if (var(r) == RHO)
    {
      for (size_t idx = 0; idx < time1.size(); ++idx)
      {
        for (size_t p = 0; p < NDIM; p++) deri(p + NDIM*idx) = p_xx(p, NTAU + 1, idx);
      }
      sys->p_dtau(p_dtau, time1, par, 0);
      for (size_t k = 0; k < NTAU; k++)
      {
        const size_t nx = 1, vx = k, np = 0, vp = 0;
        sys->p_deri(p_dfx, time1, p_xx, par, 0, nx, &vx, np, &vp, p_dummy);
        for (size_t idx = 0; idx < time1.size(); ++idx)
        {
          const double d = -p_tau(k, idx);
          for (size_t p = 0; p < NDIM; p++)
          {
            for (size_t q = 0; q < NDIM; q++)
            {
              deri(p + NDIM*idx) -= p_dfx(p, q, idx) * d * p_xx(q, NTAU + 2 * (k + 1) + 1, idx);
            }
          }
        }
      }
    }
//!!!!!!!!!!!!!!!!!
//!END w.r.t the rotation number
//!!!!!!!!!!!!!!!!!
    else std::cout << "Jac:NNN\n";
  }
  // fill the matrix
  for (size_t k = 0; k < NTAU + 1; k++)
  {
    if (k != 0)
    {
      // evaluate the solution
      const size_t nx = 1, vx = k - 1, np = 0, vp = 0;
      sys->p_deri(p_dfx, time1, p_xx, par, 0, nx, &vx, np, &vp, p_dummy);
    }

    for (size_t idx = 0; idx < time1.size(); ++idx)
    {
      double tk1, tk2;
      if (k != 0)
      {
        tk1 = time1(idx) - p_tau(k-1,idx) / par(0);
        tk2 = time2(idx) - par(RHO) * p_tau(k-1,idx) / par(0);
      } else
      {
        tk1 = time1(idx);
        tk2 = time2(idx);
      }
      const double c1 = nint1 * tk1 - floor(nint1 * tk1);
      const double c2 = nint2 * tk2 - floor(nint2 * tk2);

      // the real jacobian
      for (size_t l2 = 0; l2 < ndeg2 + 1; l2++)
      {
        for (size_t l1 = 0; l1 < ndeg1 + 1; l1++)
        {
          const size_t idxK = idxkk(l1, l2, k);
          if (k != 0)
          {
            const double cf = poly_lgr_eval(mesh1, l1, c1) * poly_lgr_eval(mesh2, l2, c2);
            for (size_t p = 0; p < NDIM; p++)
            {
              for (size_t q = 0; q < NDIM; q++)
              {
                // jacobian of rhs
                A.writeIndex(p + NDIM*idx, q + NDIM*rr(idxK, idx)) = static_cast<int>(q + NDIM * kk(idxK, idx));
                A.writeData(p + NDIM*idx, q + NDIM*rr(idxK, idx)) -= cf * par(0) * p_dfx(p, q, idx);
              }
            }
          }
          else
          {
            const double cf1 = poly_dlg_eval(mesh1, l1, c1) * nint1 * poly_lgr_eval(mesh2, l2, c2);
            const double cf2 = poly_lgr_eval(mesh1, l1, c1) * poly_dlg_eval(mesh2, l2, c2) * nint2;
            for (size_t p = 0; p < NDIM; p++)
            {
              for (size_t q = 0; q < NDIM; q++)
              {
                // derivative part of the jacobian
                A.writeIndex(p + NDIM*idx, q + NDIM*rr(idxK, idx)) = static_cast<int>(q + NDIM * kk(idxK, idx));
                if (p == q)
                  A.writeData(p + NDIM*idx, q + NDIM*rr(idxK, idx)) += cf1 + par(RHO) * cf2;
              }
            }
          }
          // error check
          if (kk(idxK, idx) > (ndeg1*nint1)*(ndeg2*nint2)) std::cout << "D" << kk(idxK, idx);
        }
      }
    }
  }
}
示例#27
0
int main()
{
    struct str3 a;
    a = kk();
    write_int(a.a);
}