local void newrun(void) { eps = getdparam("eps"); // get input parameters dtime = getdparam("dtime"); nstatic = getiparam("nstatic"); #if !defined(QUICKSCAN) theta = getdparam("theta"); #endif usequad = getbparam("usequad"); tstop = getdparam("tstop"); dtout = getdparam("dtout"); options = getparam("options"); outputs = getparam("outputs"); if (! strnull(infile)) // if data file was given inputdata(); // then read inital data else { // else make initial data nbody = getiparam("nbody"); // get number of bodies // I added this timesteps = getiparam("timesteps"); // get number of timesteps init_random(getiparam("seed")); // set random number gen. testdata(); // and make plummer model } rsize = 1.0; // start root w/ unit cube nstep = 0; // begin counting steps tout = tnow; // schedule first output }
void test_large_dataset_write() { hdf::HDFFile<> file("test.h5", hdf::HDFFile<>::truncate); std::size_t nElements = 1ul << 31; std::vector<hsize_t> dims; dims.resize(2); dims[1] = 3; dims[0] = nElements; hdf::Slab<2> filespace(dims); auto dataset = file.createDataset<int>("/test", filespace); { std::vector<int> testdata(nElements*3); for (std::size_t i =0; i < nElements*3; ++i) { testdata[i] = 1; } dataset->writeData(testdata); } std::vector<int> readData; dataset->readData(readData); assert(readData.size() == nElements*3); assert(readData[0] == 1); assert(readData[1] == 1); assert(readData[2] == 1); assert(readData[3] == 1); }
static int CreatePack(lua_State *L, int arg, size_t alignment) { int err; char *ptr; int type = checktype(L, arg); size_t n = toflattable(L, arg+1); size_t size = n * sizeoftype(type); if(size == 0) return luaL_argerror(L, arg+1, errstring(ERR_LENGTH)); ptr = (char*)AlignedAlloc(alignment, size); if(!ptr) return luaL_error(L, "failed to allocate page aligned memory"); err = testdata(L, type, n, ptr, size); if(err) { free(ptr); return luaL_argerror(L, arg+1, errstring(err)); } CreateAllocated(L, ptr, size); return 1; }
/** * @brief Test for trivial only characters in string * @param [in] Start - Start position in string * @param [in] End - One character pass the end position of the string * @param [in] filtercommentsset - For future use to determine trivial bytes * @return Returns true if all characters are trivial */ static bool IsTrivialBytes(const char* Start, const char* End, const FilterCommentsSet& filtercommentsset) { std::string testdata(Start, End); //@TODO: Need to replace the following trivial string with a user specified string size_t pos = testdata.find_first_not_of(" \t\r\n"); return (pos == std::string::npos); }
TEST_F(Hdf5Test, WriteDataset) { { hdf::HDFFile<> file(file_name_, hdf::HDFFile<>::truncate); std::vector<hsize_t> dims; dims.resize(2); dims[0] = 3; dims[1] = 2; hdf::Slab<2> filespace(dims); auto datasetint = file.createDataset< int>("/test", filespace); } hdf::HDFFile<> file(file_name_); auto dataset = file.openDataset("/test"); std::vector<int> testdata(6); testdata[0] = 1; testdata[1] = 2; testdata[2] = 3; testdata[3] = 4; testdata[4] = 5; testdata[5] = 6; dataset->writeData(testdata); { std::vector<hsize_t> dims; dims.resize(2); dims[0] = 2; dims[1] = 3; hdf::Slab<2> filespace(dims); auto datasetint = file.createDataset< int>("/test2", filespace); datasetint->writeData(testdata); std::vector<int> readData2; datasetint->readData(readData2); ASSERT_TRUE(readData2.size() == 6); ASSERT_TRUE(readData2[0] == 1); ASSERT_TRUE(readData2[1] == 2); ASSERT_TRUE(readData2[2] == 3); ASSERT_TRUE(readData2[3] == 4); } std::vector<int> readData; dataset->readData(readData); ASSERT_TRUE(readData.size() == 6); ASSERT_TRUE(readData[0] == 1); ASSERT_TRUE(readData[1] == 2); ASSERT_TRUE(readData[2] == 3); ASSERT_TRUE(readData[3] == 4); }
static void TestFileSeek() // // Benchmark file seek method // { ClearSessionDirectory(); test.Next(_L("RFile::Seek method")); TInt increment=1789; // random number > cluster size TInt count=0; TInt pos=0; // Create test file TBuf8<1024> testdata(1024); RFile f; TInt r=f.Create(TheFs,_L("SEEKTEST"),EFileStream); test_KErrNone(r); count=64; while (count--) f.Write(testdata); TInt fileSize=count*testdata.MaxLength(); pos=0; count=0; RTimer timer; timer.CreateLocal(); TRequestStatus reqStat; timer.After(reqStat,10000000); // After 10 secs while(reqStat==KRequestPending) { TInt dum=(pos+=increment)%fileSize; f.Seek(ESeekStart,dum); count++; } test.Printf(_L("RFile::Seek operations in 10 secs == %d\n"),count); timer.Close(); f.Close(); TheFs.Delete(_L("SEEKTEST")); }
int main(int argc, char* argv[]) { if (argc != 6){ cout<< "Usuage: 5 arguments, the 1. executable followded by 2. training set, 3. training label, \ 4. test set, 5. tes label, 6. Number of Classe " << endl; exit(1); } int nC = atoi(argv[5]); cout<<"Number of Classe: " <<nC<<endl; NBC nbc; nbc.set_numClass(nC); //Start get Input data ifstream traindata(argv[1]); ifstream trainlable(argv[2]); ifstream testdata(argv[3]); ifstream testlable(argv[4]); if(trainlable.is_open() && traindata.is_open()){ string line, lable; int l =-1; while (!trainlable.eof()){ getline(traindata, line, '\n'); getline(trainlable, lable, '\n'); istringstream linestr(line); vector<int> sample; int v = 0; if (lable.size() ==0 ) break; l = atoi(lable.c_str()); //cout << "l: " <<l <<endl; nbc.ltrain.push_back(l); while(linestr >> v){ sample.push_back(v); } nbc.trainset.push_back(sample); } }
int test_Matrix::serialtest1() { fei::SharedPtr<testData> testdata(new testData(localProc_, numProcs_)); std::vector<int>& fieldIDs = testdata->fieldIDs; std::vector<int>& fieldSizes = testdata->fieldSizes; std::vector<int>& idTypes = testdata->idTypes; std::vector<int>& ids = testdata->ids; fei::SharedPtr<fei::VectorSpace> vspc(new fei::VectorSpace(comm_, "sU_Mat")); vspc->defineFields(fieldIDs.size(), &fieldIDs[0], &fieldSizes[0]); vspc->defineIDTypes(idTypes.size(), &idTypes[0]); fei::SharedPtr<fei::MatrixGraph> matgraph(new fei::MatrixGraph_Impl2(vspc, vspc, "sU_Mat")); int numIDs = ids.size(); int fieldID = fieldIDs[0]; int idType = idTypes[0]; int patternID = matgraph->definePattern(numIDs, idType, fieldID); CHK_ERR( matgraph->initConnectivityBlock(0, 1, patternID) ); CHK_ERR( matgraph->initConnectivity(0, 0, &ids[0]) ); CHK_ERR( matgraph->initComplete() ); fei::SharedPtr<fei::FillableMat> ssmat(new fei::FillableMat), ssmatT(new fei::FillableMat); int localsize = matgraph->getRowSpace()->getNumIndices_Owned(); fei::SharedPtr<fei::Matrix> matrix(new fei::Matrix_Impl<fei::FillableMat>(ssmat, matgraph, localsize)); fei::SharedPtr<fei::Matrix> matrixT(new fei::Matrix_Impl<fei::FillableMat>(ssmatT, matgraph, localsize)); std::vector<int> indices(numIDs); CHK_ERR( matgraph->getConnectivityIndices(0, 0, numIDs, &indices[0], numIDs) ); std::vector<double> data1(numIDs*numIDs); std::vector<double*> data2d(numIDs); int i; for(i=0; i<numIDs; ++i) { data2d[i] = &(data1[i*numIDs]); } for(i=0; i<numIDs*numIDs; ++i) { data1[i] = 1.0*i; } CHK_ERR( matrix->sumIn(numIDs, &indices[0], numIDs, &indices[0], &data2d[0], 0) ); CHK_ERR( matrix->sumIn(0, 0, &data2d[0], 0) ); CHK_ERR( matrixT->sumIn(numIDs, &indices[0], numIDs, &indices[0], &data2d[0], 3) ); CHK_ERR( matrixT->sumIn(0, 0, &data2d[0], 3) ); if (*ssmat != *ssmatT) { ERReturn(-1); } return(0); }
startrun() { string restfile, contfile; bool scanopt(); proc get_potential(); infile = getparam("in"); /* set I/O file names */ outfile = getparam("out"); restfile = getparam("restart"); contfile = getparam("continue"); savefile = getparam("save"); options = getparam("options"); /* set control options */ debug = getbparam("hdebug"); if (debug) dprintf(0,"hdebug is turned on"); nrigid = getiparam("nrigid"); if (*contfile) /* resume interrupted run */ restorestate(contfile); else if (*restfile) { /* resume w/ new parameters */ restorestate(restfile); /* NOTE: someday, I will have a way to tell which, if any, of these * * parameters are actually input from the command line, and only * * change them. ANY NON-DEFAULT ARGS MUST BE SPECIFIED AT RESTART. */ eps = getdparam("eps"); /* get modified params */ tol = getdparam("tol"); options = getparam("options"); /* restorestate overwrite */ fcells = getdparam("fcells"); tstop = getdparam("tstop"); freqout = getdparam("freqout"); minor_freqout = getdparam("minor_freqout"); if (scanopt(options, "new_tout")) { /* reset output times? */ tout = tnow + 1 / freqout; /* offset from present */ minor_tout = tnow + 1 / minor_freqout; } } else { /* start new calculation */ if (*infile) /* was data file given? */ inputdata(infile); /* read inital data */ else { /* make initial conds? */ nbody = getiparam("nbody"); /* get nbody parameter */ if (nbody < 1) /* is value absurd? */ error("startrun: absurd nbody\n"); init_xrandom(getparam("seed")); /* set random generator */ testdata(getbparam("cencon")); /* make test model */ } freq = getdparam("freq"); /* get various parameters */ eps = getdparam("eps"); tol = getdparam("tol"); fcells = getdparam("fcells"); tstop = getdparam("tstop"); freqout = getdparam("freqout"); minor_freqout = getdparam("minor_freqout"); nstep = 0; /* start counting steps */ minor_tout = tout = tnow; /* schedule first output */ SETVS(rmin, -2.0); /* init box scaling */ rsize = -2.0 * rmin[0]; } contfile = getparam("potname"); if (*contfile) { extpot = get_potential(contfile, getparam("potpars"),getparam("potfile")); } }
int test_LinearSystem::test2() { #ifdef HAVE_FEI_AZTECOO fei::SharedPtr<testData> testdata(new testData(localProc_, numProcs_)); std::vector<int>& fieldIDs = testdata->fieldIDs; std::vector<int>& idTypes = testdata->idTypes; std::vector<int>& ids = testdata->ids; fei::SharedPtr<LinearSystemCore> az_lsc(new fei_trilinos::Aztec_LinSysCore(comm_)); char* param = new char[64]; sprintf(param,"debugOutput ."); CHK_ERR( az_lsc->parameters(1, ¶m) ); delete [] param; fei::SharedPtr<fei::Factory> factory(new snl_fei::Factory(comm_, az_lsc)); fei::SharedPtr<fei::VectorSpace> vectorSpacePtr = test_VectorSpace::create_VectorSpace(comm_, testdata.get(), localProc_, numProcs_, false, false, "U_LS2", factory); fei::SharedPtr<fei::MatrixGraph> matrixGraphPtr = test_MatrixGraph::create_MatrixGraph(testdata.get(), localProc_, numProcs_, false, false, "U_LS2", vectorSpacePtr, factory, path_); std::vector<int> crIDTypes(2); std::vector<int> crFieldIDs(2); crIDTypes[0] = idTypes[0]; crIDTypes[1] = idTypes[0]; crFieldIDs[0] = fieldIDs[0]; crFieldIDs[1] = fieldIDs[0]; CHK_ERR( matrixGraphPtr->initLagrangeConstraint(0, idTypes[1], 2, //numIDs &crIDTypes[0], &(ids[1]), &crFieldIDs[0]) ); CHK_ERR( matrixGraphPtr->initComplete() ); fei::SharedPtr<fei::Vector> vec_lsc = factory->createVector(vectorSpacePtr); fei::SharedPtr<fei::Vector> vec_lsc2 = factory->createVector(vectorSpacePtr, true); fei::SharedPtr<fei::Matrix> mat_lsc = factory->createMatrix(matrixGraphPtr); fei::SharedPtr<fei::LinearSystem> linsys = factory->createLinearSystem(matrixGraphPtr); linsys->setMatrix(mat_lsc); linsys->setSolutionVector(vec_lsc2); linsys->setRHS(vec_lsc); int blockID=0; int numIndices = matrixGraphPtr->getConnectivityNumIndices(blockID); std::vector<int> indicesArray(numIndices); int* indicesPtr = &indicesArray[0]; int checkNumIndices = 0; CHK_ERR( matrixGraphPtr->getConnectivityIndices(blockID, 0, numIndices, indicesPtr, checkNumIndices) ); std::vector<double> data(ids.size(), 1.0); double* dptr = &data[0]; std::vector<double*> coefPtrs(ids.size()); std::vector<double> crdata(2); crdata[0] = 1.0; crdata[1] = -1.0; for(unsigned ii=0; ii<ids.size(); ++ii) coefPtrs[ii] = dptr; CHK_ERR( mat_lsc->sumIn(numIndices, indicesPtr, numIndices, indicesPtr, &coefPtrs[0]) ); CHK_ERR( vec_lsc->sumInFieldData(fieldIDs[0], idTypes[0], ids.size(), &ids[0], &data[0]) ); CHK_ERR( linsys->loadLagrangeConstraint(0, &crdata[0], 0.0) ); CHK_ERR( mat_lsc->gatherFromOverlap() ); CHK_ERR( az_lsc->matrixLoadComplete() ); CHK_ERR( linsys->loadComplete() ); std::vector<int> crindices; linsys->getConstrainedEqns(crindices); if (crindices.size() != 2) { ERReturn(-7); } CHK_ERR( az_lsc->writeSystem("U_LS2") ); MPI_Barrier(comm_); #endif return(0); }
void PlasmoidHandlerTest::cleanupTestCase() { QDir testdata(QStandardPaths::standardLocations(QStandardPaths::DataLocation).at(0)); testdata.removeRecursively(); }
int test_FEI_Impl::test2() { fei::SharedPtr<testData> testdata(new testData(localProc_, numProcs_)); fei::SharedPtr<FiniteElementData> fedata(new FEData(comm_)); fei::SharedPtr<LibraryWrapper> wrapper(new LibraryWrapper(fedata)); fei::SharedPtr<fei::FEI_Impl> fei(new fei::FEI_Impl(wrapper, comm_, 0)); std::string param0("name test1"); FEI_OSTRINGSTREAM osstr; osstr << "debugOutput "; if (path_.empty()) osstr << "."; else osstr << path_; std::string param1 = osstr.str(); int numParams = 2; char** params = new char*[numParams]; params[0] = const_cast<char*>(param0.c_str()); params[1] = const_cast<char*>(param1.c_str()); //call the parameters function a couple of times to test the fei's internal //method for merging string lists when parameters is called more than once. CHK_ERR( fei->parameters(1, ¶ms[0]) ); CHK_ERR( fei->parameters(1, ¶ms[1]) ); CHK_ERR( fei->parameters(2, params) ); delete [] params; CHK_ERR( fei->setIDLists(1, &(testdata->ids[0]), 1, &(testdata->ids[0])) ); CHK_ERR( fei->initFields(testdata->fieldIDs.size(), &(testdata->fieldSizes[0]), &(testdata->fieldIDs[0])) ); int numNodesPerElem = testdata->ids.size(); std::vector<int> numFieldsPerNode(numNodesPerElem, 1); std::vector<int*>nodalFieldIDs(numNodesPerElem, &(testdata->fieldIDs[0])); CHK_ERR( fei->initElemBlock(0, //blockID 1, //numElements numNodesPerElem, &numFieldsPerNode[0], &nodalFieldIDs[0], 0, //numElemDofFieldsPerElement NULL, //elemDofFieldIDs 0)); //interleaveStrategy CHK_ERR( fei->initElem(0, //blockID 0, //elemID &(testdata->ids[0])) ); std::vector<int*> sharingProcs2D(testdata->sharedIDs.size()); int i, offset = 0; for(i=0; i<(int)testdata->numSharingProcsPerID.size(); ++i) { sharingProcs2D[i] = &(testdata->sharingProcs[offset]); offset += testdata->numSharingProcsPerID[i]; } if (testdata->sharedIDs.size() > 0) { CHK_ERR( fei->initSharedNodes(testdata->sharedIDs.size(), &(testdata->sharedIDs[0]), &(testdata->numSharingProcsPerID[0]), &sharingProcs2D[0]) ); } CHK_ERR( fei->initComplete() ); std::vector<double> rhsData(testdata->ids.size(), 1.0); double one = 1.0; CHK_ERR( fei->setMatScalars(1, &(testdata->ids[0]), &one) ); CHK_ERR( fei->setRHSScalars(1, &(testdata->ids[0]), &one) ); CHK_ERR( fei->setCurrentMatrix(testdata->ids[0]) ); CHK_ERR( fei->setCurrentRHS(testdata->ids[0]) ); int ii; int numBCNodes = 2; GlobalID* BCNodeIDs = &(testdata->ids[0]); int BCFieldID = testdata->fieldIDs[0]; double* values = new double[numBCNodes]; int* offsetsIntoField = new int[numBCNodes]; for(ii=0; ii<numBCNodes; ++ii) { values[ii] = 1.0; offsetsIntoField[ii] = 0; } CHK_ERR( fei->loadNodeBCs(numBCNodes, BCNodeIDs, BCFieldID, offsetsIntoField, values) ); delete [] values; delete [] offsetsIntoField; CHK_ERR( fei->loadComplete() ); int numActiveNodes = 0; CHK_ERR( fei->getNumLocalNodes(numActiveNodes) ); if (numActiveNodes != (int)testdata->ids.size()) { ERReturn(-1); } GlobalID* localNodes = new GlobalID[numActiveNodes]; CHK_ERR( fei->getLocalNodeIDList(numActiveNodes, localNodes, numActiveNodes) ); int totalFieldSize = 0; for(ii=0; ii<(int)testdata->fieldSizes.size(); ++ii) { totalFieldSize += testdata->fieldSizes[ii]; } double* soln = new double[numActiveNodes*totalFieldSize]; int* offsets = new int[numActiveNodes+1]; CHK_ERR( fei->getNodalSolution(numActiveNodes, localNodes, offsets, soln) ); delete [] offsets; delete [] soln; delete [] localNodes; CHK_ERR( fei->resetInitialGuess() ); int fieldSize = 0; CHK_ERR( fei->getFieldSize(testdata->fieldIDs[0], fieldSize) ); double initTime, loadTime, solveTime, solnReturnTime; CHK_ERR( fei->cumulative_cpu_times(initTime, loadTime, solveTime, solnReturnTime) ); return(0); }