IdxData* IdxData::findChildWithBadPosition() const { IdxDataComparer<RelaxedTagValueComparer> comparer(m_order); IdxData* result = nullptr; for(size_t i = 1; i < m_children.size(); i++) if (comparer(m_children[i - 1], m_children[i]) == false) { result = m_children[i - 1]; break; } return result; }
void TestBidomainWithBathCanOutputVariables() throw(Exception) { HeartConfig::Instance()->SetSimulationDuration(0.01); //ms HeartConfig::Instance()->SetMeshFileName("mesh/test/data/1D_0_to_1_10_elements_with_two_attributes"); HeartConfig::Instance()->SetOutputDirectory("BidomainBathOutputVariables"); HeartConfig::Instance()->SetOutputFilenamePrefix("BidomainLR91_1d"); HeartConfig::Instance()->SetVisualizeWithMeshalyzer(); std::vector<std::string> output_variables; output_variables.push_back("cytosolic_calcium_concentration"); HeartConfig::Instance()->SetOutputVariables(output_variables); std::set<unsigned> tissue_ids; tissue_ids.insert(0); // Same as default value defined in HeartConfig std::set<unsigned> bath_ids; bath_ids.insert(1); HeartConfig::Instance()->SetTissueAndBathIdentifiers(tissue_ids, bath_ids); PlaneStimulusCellFactory<CellLuoRudy1991FromCellML, 1> cell_factory; BidomainWithBathProblem<1> bidomain_problem(&cell_factory); bidomain_problem.Initialise(); bidomain_problem.Solve(); FileFinder calcium_results("BidomainBathOutputVariables/output/BidomainLR91_1d_cytosolic_calcium_concentration.dat", RelativeTo::ChasteTestOutput); TS_ASSERT_EQUALS(calcium_results.IsFile(), true); FileFinder reference_results("heart/test/data/BidomainBathOutputVariables/BidomainLR91_1d_cytosolic_calcium_concentration.dat", RelativeTo::ChasteSourceRoot); NumericFileComparison comparer(calcium_results, reference_results); TS_ASSERT_EQUALS(comparer.CompareFiles(), true); }
/** * @brief Recherche un Etat dans une liste * @param[in] e l'Etat a rechercher * @param[in,out] l la Liste dans laquelle chercher * @return true si l'Etat a été trouvé, false sinon */ bool rechercher(const Etat& e, Liste& l) { for (unsigned int i = 0; i< longueur(l); ++i) { if (comparer(e.damier, lire(l, i).damier)) return true; } return false; }
/** * This tests the HDF5 to .txt converter using a 3D example * taken from a bidomain simulation. */ void TestBidomainTxtConversion3D() throw(Exception) { std::string working_directory = "TestHdf5ToTxtConverter_bidomain"; /* * Firstly, copy the .h5 file to CHASTE_TEST_OUTPUT/TestHdf5ToTxtConverter_bidomain, * as that is where the reader reads from. */ CopyToTestOutputDirectory("pde/test/data/cube_2mm_12_elements.h5", working_directory); TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_2mm_12_elements"); TetrahedralMesh<3,3> mesh; mesh.ConstructFromMeshReader(mesh_reader); // Convert Hdf5ToTxtConverter<3,3> converter(FileFinder(working_directory, RelativeTo::ChasteTestOutput), "cube_2mm_12_elements", &mesh); std::vector<std::string> files_to_compare; files_to_compare.push_back("cube_2mm_12_elements_V_0.txt"); files_to_compare.push_back("cube_2mm_12_elements_V_1.txt"); files_to_compare.push_back("cube_2mm_12_elements_Phi_e_0.txt"); files_to_compare.push_back("cube_2mm_12_elements_Phi_e_1.txt"); for (unsigned i=0; i<files_to_compare.size(); i++) { std::cout << "Comparing generated and reference " << files_to_compare[i] << std::endl; FileFinder generated_file(working_directory +"/txt_output/" + files_to_compare[i], RelativeTo::ChasteTestOutput); FileFinder reference_file("pde/test/data/" + files_to_compare[i], RelativeTo::ChasteSourceRoot); NumericFileComparison comparer(generated_file, reference_file); TS_ASSERT(comparer.CompareFiles()); } }
/** * This tests the HDF5 to XDMF converter */ void TestHdf5ToXdmfConverter() throw(Exception) { #ifndef _MSC_VER std::string working_directory = "TestHdf5Converters_TestHdf5ToXdmfConverter"; CopyToTestOutputDirectory("pde/test/data/cube_2mm_12_elements.h5", working_directory); TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/cube_2mm_12_elements"); TetrahedralMesh<3,3> mesh; mesh.ConstructFromMeshReader(mesh_reader); // Convert Hdf5ToXdmfConverter<3,3> converter(FileFinder(working_directory, RelativeTo::ChasteTestOutput), "cube_2mm_12_elements", &mesh); std::vector<std::string> files_to_compare; files_to_compare.push_back("cube_2mm_12_elements.xdmf"); files_to_compare.push_back("cube_2mm_12_elements_geometry_0.xml"); files_to_compare.push_back("cube_2mm_12_elements_topology_0.xml"); for (unsigned i=0; i<files_to_compare.size(); i++) { std::cout << "Comparing generated and reference " << files_to_compare[i] << std::endl; FileFinder generated_file(working_directory +"/xdmf_output/" + files_to_compare[i], RelativeTo::ChasteTestOutput); FileFinder reference_file("pde/test/data/xdmf_output/" + files_to_compare[i], RelativeTo::ChasteSourceRoot); FileComparison comparer(generated_file, reference_file); TS_ASSERT(comparer.CompareFiles()); } #endif // _MSC_VER }
Pokemon * Trainer::mergeLevelArrays(Pokemon * a, Pokemon * b) { if (!a || !b) { return NULL; } int numOfPokemons = idTree.getSize(); Pokemon* merged = new Pokemon[numOfPokemons]; if (!merged) { return NULL; } int aIndex = 0, bIndex = 0; pokemonCompareByLevel comparer = pokemonCompareByLevel(); for (int i = 0; i < numOfPokemons; i++) { if (comparer(a[aIndex], b[bIndex])) { merged[i] = a[aIndex]; aIndex++; } else { merged[i] = b[bIndex]; bIndex++; } } return merged; }
static TOffsetMap FindEquivalentSubtries(const TOpaqueTrie& trie, bool verbose, size_t minMergeSize) { // Tree nodes, arranged by span length. // When all nodes of a given size are considered, they pop off the queue. TPieceIndex subtries; TOffsetMap merger; // Start walking the trie from head. AddPiece(subtries, 0, trie.Length); size_t counter = 0; // Now consider all nodes with sizeable continuations for (size_t curlen = trie.Length; curlen >= minMergeSize && !subtries.empty(); curlen--) { TPieceIndex::iterator iit = subtries.find(curlen); if (iit == subtries.end()) continue; // fast forward to the next available length value TOffsetList& batch = iit->second; TPieceComparer comparer(trie.Data, curlen); Sort(batch.begin(), batch.end(), comparer); TOffsetList::iterator it = batch.begin(); while (it != batch.end()) { if (verbose) ShowProgress(++counter); size_t offset = *it; // Fill the array with the subnodes of the element TNode node(trie.Data, offset, trie.SkipFunction); size_t end = offset + curlen; if (size_t rightOffset = node.GetRightOffset()) { AddPiece(subtries, rightOffset, end - rightOffset); end = rightOffset; } if (size_t leftOffset = node.GetLeftOffset()) { AddPiece(subtries, leftOffset, end - leftOffset); end = leftOffset; } if (size_t forwardOffset = node.GetForwardOffset()) { AddPiece(subtries, forwardOffset, end - forwardOffset); } while (++it != batch.end()) { // Find next different; until then, just add the offsets to the list of merged nodes. size_t nextoffset = *it; if (memcmp(trie.Data + offset, trie.Data + nextoffset, curlen)) break; merger.Add(nextoffset, offset); } } subtries.erase(curlen); } if (verbose) { Cerr << counter << Endl; } return merger; }
SyntheticVolumeComparerPtr ReconstructionManagerTestFixture::getComparerForOutput(SyntheticReconstructInputPtr input, int index) { SyntheticVolumeComparerPtr comparer(new SyntheticVolumeComparer()); comparer->setVerbose(this->getVerbose()); comparer->setPhantom(input->getPhantom()); comparer->setTestImage(this->getOutput()[index]); return comparer; }
long IdxData::findPositionFor(const IdxData* child) const { IdxDataComparer<TagValueComparer> comparer(m_order); const auto pos = std::upper_bound(m_children.cbegin(), m_children.cend(), child, comparer); return pos - m_children.cbegin(); }
static void write_data(io::stream& e, bsdata* pd, bool(*comparer)(void* object, const bsreq* type)) { if(!pd) return; for(int index = 0; index < (int)pd->getcount(); index++) { auto object = pd->get(index); if(comparer && !comparer(object, pd->fields)) write_object(e, object); } }
bool IdxData::sortingRequired() const { IdxDataComparer<TagValueComparer> comparer(m_order); const bool sorted = std::is_sorted(m_children.cbegin(), m_children.cend(), comparer); const bool required = !sorted; return required; }
static const struct optioninfo *find1(const char **optp, const struct optioninfo *table, comparer_type *comparer) { for (;;) { if (table->type == ot_end) return 0; if (comparer(optp,table)) return table; table++; } }
bool Style::equals(const Style* style) const { // The StyleEqualComparer is dependent on the serialize method that isn't // const. But we know that we aren't changing anything so we removes the // const to make it compile. Style* rhs = const_cast<Style*>(style); Style* lhs = const_cast<Style*>(this); StyleEqualComparer comparer(lhs, rhs); rhs->serialize(comparer); return comparer.equal; }
bool areTangentialAtPoint(const Vector<T, 2>& point, Vector<T, 2> fromA, Vector<T, 2> toA, Vector<T, 2> fromB, Vector<T, 2> toB, double tolerance) { DirectionComparer2<T> comparer(point, tolerance); if (!comparer(fromA, toA)) std::swap(fromA, toA); if (!comparer(fromB, toB)) std::swap(fromB, toB); if (comparer.compare(toA, fromB) <= 0) return true; else if (comparer.compare(fromA, toB) >= 0) return true; else return std::abs(comparer.compare(fromA, fromB) + comparer.compare(toA, toB)) != 2; }
void TestWritingBinaryFormat() { //Read as ascii TrianglesMeshReader<2,2> reader("mesh/test/data/mixed_dimension_meshes/2D_0_to_1mm_200_elements"); //Write as binary TrianglesMeshWriter<2,2> writer_from_reader("TestMixedDimensionMesh", "CableMeshBinary", false); writer_from_reader.SetWriteFilesAsBinary(); writer_from_reader.WriteFilesUsingMeshReader(reader); PetscTools::Barrier(); //Read created binary file into a mesh std::string results_dir = OutputFileHandler::GetChasteTestOutputDirectory() + "TestMixedDimensionMesh/"; TrianglesMeshReader<2,2> binary_reader(results_dir + "CableMeshBinary"); MixedDimensionMesh<2,2> binary_mesh(DistributedTetrahedralMeshPartitionType::DUMB); binary_mesh.ConstructFromMeshReader(binary_reader); //Read original file into a mesh std::string mesh_base("mesh/test/data/mixed_dimension_meshes/2D_0_to_1mm_200_elements"); TrianglesMeshReader<2,2> original_reader(mesh_base); MixedDimensionMesh<2,2> original_mesh(DistributedTetrahedralMeshPartitionType::DUMB); original_mesh.ConstructFromMeshReader(original_reader); //Compare to original TS_ASSERT_EQUALS(binary_mesh.GetNumNodes(), original_mesh.GetNumNodes()); TS_ASSERT_EQUALS(binary_mesh.GetNumElements(), original_mesh.GetNumElements()); TS_ASSERT_EQUALS(binary_mesh.GetNumCableElements(), original_mesh.GetNumCableElements()); MixedDimensionMesh<2,2>::CableElementIterator original_iter = original_mesh.GetCableElementIteratorBegin(); for (MixedDimensionMesh<2,2>::CableElementIterator binary_iter = binary_mesh.GetCableElementIteratorBegin(); binary_iter != binary_mesh.GetCableElementIteratorEnd(); ++binary_iter) { TS_ASSERT_EQUALS((*binary_iter)->GetNumNodes(), (*original_iter)->GetNumNodes()); TS_ASSERT_EQUALS((*binary_iter)->GetNodeGlobalIndex(0u), (*original_iter)->GetNodeGlobalIndex(0u)); TS_ASSERT_EQUALS((*binary_iter)->GetNodeGlobalIndex(1u), (*original_iter)->GetNodeGlobalIndex(1u)); TS_ASSERT_DELTA((*binary_iter)->GetAttribute(), (*original_iter)->GetAttribute(), 1e-12); ++original_iter; } //Write a binary from the original mesh TrianglesMeshWriter<2,2> writer_from_mesh("TestMixedDimensionMesh", "CableMeshBinaryFromMesh", false); writer_from_mesh.SetWriteFilesAsBinary(); writer_from_mesh.WriteFilesUsingMesh(original_mesh); //Compare the binary written from the reader to the binary written from the mesh FileFinder generated(results_dir + "/CableMeshBinary.cable"); FileFinder reference(results_dir + "/CableMeshBinaryFromMesh.cable"); FileComparison comparer(generated,reference); TS_ASSERT(comparer.CompareFiles()); }
void* queue_buffer_find(struct queue_buffer* qb, const void *item, int (*comparer)(const void*, const void*)) { struct queue_buffer_s *i = qb->used_head; for(; i != NULL; i = i->next) { if (comparer(i->data, item)) { return i->data; } } return NULL; }
void TestWritingCableFilesUsingMeshReader() throw(Exception) { std::string mesh_base("mesh/test/data/mixed_dimension_meshes/2D_0_to_1mm_200_elements"); TrianglesMeshReader<2,2> reader(mesh_base); TrianglesMeshWriter<2,2> mesh_writer("TestMixedDimensionMesh", "CableMeshFromReader"); mesh_writer.WriteFilesUsingMeshReader(reader); PetscTools::Barrier("TestWritingCableFilesUsingMeshReader"); FileFinder generated("TestMixedDimensionMesh/CableMeshFromReader.cable",RelativeTo::ChasteTestOutput); FileFinder reference("mesh/test/data/mixed_dimension_meshes/2D_0_to_1mm_200_elements.cable", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated,reference); TS_ASSERT(comparer.CompareFiles()); }
void TestCellCycleModelOutputParameters() { std::string output_directory = "TestCellCycleModelOutputParameters"; OutputFileHandler output_file_handler(output_directory, false); // Test with Alarcon2004OxygenBasedCellCycleModel Alarcon2004OxygenBasedCellCycleModel alarcon_oxygen_based_cell_cycle_model; TS_ASSERT_EQUALS(alarcon_oxygen_based_cell_cycle_model.GetIdentifier(), "Alarcon2004OxygenBasedCellCycleModel"); out_stream alarcon_oxygen_based_parameter_file = output_file_handler.OpenOutputFile("alarcon_oxygen_based_results.parameters"); alarcon_oxygen_based_cell_cycle_model.OutputCellCycleModelParameters(alarcon_oxygen_based_parameter_file); alarcon_oxygen_based_parameter_file->close(); { FileFinder generated_file = output_file_handler.FindFile("alarcon_oxygen_based_results.parameters"); FileFinder reference_file("cell_based/test/data/TestCellCycleModels/alarcon_oxygen_based_results.parameters", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated_file,reference_file); TS_ASSERT(comparer.CompareFiles()); } // Test with TysonNovakCellCycleModel TysonNovakCellCycleModel tyson_novak_based_cell_cycle_model; TS_ASSERT_EQUALS(tyson_novak_based_cell_cycle_model.GetIdentifier(), "TysonNovakCellCycleModel"); out_stream tyson_novak_based_parameter_file = output_file_handler.OpenOutputFile("tyson_novak_based_results.parameters"); tyson_novak_based_cell_cycle_model.OutputCellCycleModelParameters(tyson_novak_based_parameter_file); tyson_novak_based_parameter_file->close(); { FileFinder generated_file = output_file_handler.FindFile("tyson_novak_based_results.parameters"); FileFinder reference_file("cell_based/test/data/TestCellCycleModels/tyson_novak_based_results.parameters", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated_file,reference_file); TS_ASSERT(comparer.CompareFiles()); } }
void TestUseInPopulationWriteResultsToFile() { EXIT_IF_PARALLEL; // Set up SimulationTime (needed if VTK is used) SimulationTime::Instance()->SetEndTimeAndNumberOfTimeSteps(1.0, 1); // Create a simple mesh-based cell population, comprising various cell types in various cell cycle phases TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_4_elements"); MutableMesh<2,2> mesh; mesh.ConstructFromMeshReader(mesh_reader); std::vector<CellPtr> cells; CellsGenerator<VanLeeuwen2009WntSwatCellCycleModelHypothesisOne, 2> cells_generator; cells_generator.GenerateBasic(cells, mesh.GetNumNodes()); MeshBasedCellPopulation<2> cell_population(mesh, cells); // Create an instance of a Wnt concentration WntConcentration<2>::Instance()->SetType(LINEAR); WntConcentration<2>::Instance()->SetCellPopulation(cell_population); WntConcentration<2>::Instance()->SetCryptLength(1.0); cell_population.InitialiseCells(); // This is where we add the writer cell_population.AddCellWriter<CellBetaCateninWriter>(); // This method is usually called by Update() cell_population.CreateVoronoiTessellation(); std::string output_directory = "TestUseInPopulationWriteResultsToFile"; OutputFileHandler output_file_handler(output_directory, false); cell_population.OpenWritersFiles(output_file_handler); cell_population.WriteResultsToFiles(output_directory); SimulationTime::Instance()->IncrementTimeOneStep(); cell_population.Update(); cell_population.WriteResultsToFiles(output_directory); cell_population.CloseWritersFiles(); // Compare output with saved file of what they should look like std::string results_dir = output_file_handler.GetOutputDirectoryFullPath(); FileComparison comparer(results_dir + "results.vizbetacatenin","crypt/test/data/TestCellBetaCateninWriter/results2.vizbetacatenin"); TS_ASSERT(comparer.CompareFiles()); }
void TestAxiWriterAscii() { FileFinder file_finder("heart/test/data/fibre_tests/SimpleAxisymmetric2.axi", RelativeTo::ChasteSourceRoot); FibreReader<3> fibre_reader(file_finder, AXISYM); std::vector< c_vector<double, 3> > fibre_vector; fibre_reader.GetAllAxi(fibre_vector); // Write ascii file FibreWriter<3> fibre_writer("TestFibreWriter", "SimpleAxisymmetric2", true); fibre_writer.WriteAllAxi(fibre_vector); std::string results_dir = OutputFileHandler::GetChasteTestOutputDirectory() + "TestFibreWriter/"; FileComparison comparer(results_dir + "/SimpleAxisymmetric2.axi","heart/test/data/fibre_tests/SimpleAxisymmetric2.axi"); TS_ASSERT(comparer.CompareFiles()); }
void TestWritingCableFiles() throw(Exception) { std::string mesh_base("mesh/test/data/mixed_dimension_meshes/2D_0_to_1mm_200_elements"); TrianglesMeshReader<2,2> reader(mesh_base); MixedDimensionMesh<2,2> mesh(DistributedTetrahedralMeshPartitionType::DUMB); mesh.ConstructFromMeshReader(reader); TrianglesMeshWriter<2,2> mesh_writer("TestMixedDimensionMesh", "CableMesh", true); mesh_writer.WriteFilesUsingMesh(mesh); FileFinder generated("TestMixedDimensionMesh/CableMesh.cable",RelativeTo::ChasteTestOutput); FileFinder reference("mesh/test/data/mixed_dimension_meshes/2D_0_to_1mm_200_elements.cable", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated,reference); TS_ASSERT(comparer.CompareFiles()); }
inline STORAGE process_chunk(const SlicingIndex& indices) { int n = indices.size(); if (n == 0 || idx > n || idx < -n) return def; int i = idx > 0 ? (idx -1) : (n+idx); typedef VectorSliceVisitor<ORDER_RTYPE> Slice; typedef OrderVectorVisitorImpl<ORDER_RTYPE,true,Slice> Visitor; typedef Compare_Single_OrderVisitor<Visitor> Comparer; Comparer comparer(Visitor(Slice(order, indices))); IntegerVector sequence = seq(0,n-1); std::nth_element(sequence.begin(), sequence.begin() + i, sequence.end(), comparer); return data[ indices[ sequence[i] ] ]; }
void TestOrthoWriterAscii() { FileFinder file_finder("heart/test/data/fibre_tests/Orthotropic3D.ortho", RelativeTo::ChasteSourceRoot); FibreReader<3> fibre_reader(file_finder, ORTHO); std::vector< c_vector<double, 3> > fibres; std::vector< c_vector<double, 3> > second; std::vector< c_vector<double, 3> > third; fibre_reader.GetAllOrtho(fibres, second, third); //Write ascii file FibreWriter<3> fibre_writer("TestFibreWriter", "Orthotropic3D", false); fibre_writer.WriteAllOrtho(fibres, second, third); std::string results_dir = OutputFileHandler::GetChasteTestOutputDirectory() + "TestFibreWriter/"; FileComparison comparer(results_dir + "/Orthotropic3D.ortho","heart/test/data/fibre_tests/Orthotropic3D.ortho"); TS_ASSERT(comparer.CompareFiles()); }
void TestSwitchingUpdateRuleOutputUpdateRuleInfo() { std::string output_directory = "TestCaSwitchingUpdateRulesOutputParameters"; OutputFileHandler output_file_handler(output_directory, false); // Test with RandomCaSwitchingUpdateRule RandomCaSwitchingUpdateRule<2> random_switching_update_rule; random_switching_update_rule.SetSwitchingParameter(1.0); TS_ASSERT_EQUALS(random_switching_update_rule.GetIdentifier(), "RandomCaSwitchingUpdateRule-2"); out_stream random_switching_update_rule_parameter_file = output_file_handler.OpenOutputFile("random_switching_update_rule_results.parameters"); random_switching_update_rule.OutputUpdateRuleInfo(random_switching_update_rule_parameter_file); random_switching_update_rule_parameter_file->close(); // Compare the generated file in test output with a reference copy in the source code. FileFinder generated = output_file_handler.FindFile("random_switching_update_rule_results.parameters"); FileFinder reference("cell_based/test/data/TestCaUpdateRules/random_switching_update_rule_results.parameters", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated, reference); TS_ASSERT(comparer.CompareFiles()); }
void TestSimpleTargetAreaModifierOutputParameters() { EXIT_IF_PARALLEL; std::string output_directory = "TestSimpleTargetAreaModifierOutputParameters"; OutputFileHandler output_file_handler(output_directory, false); MAKE_PTR(SimpleTargetAreaModifier<2>, p_modifier); TS_ASSERT_EQUALS(p_modifier->GetIdentifier(), "SimpleTargetAreaModifier-2"); out_stream modifier_parameter_file = output_file_handler.OpenOutputFile("SimpleTargetAreaModifier.parameters"); p_modifier->OutputSimulationModifierParameters(modifier_parameter_file); modifier_parameter_file->close(); { // Compare the generated file in test output with a reference copy in the source code FileFinder generated = output_file_handler.FindFile("SimpleTargetAreaModifier.parameters"); FileFinder reference("cell_based/test/data/TestSimulationModifierOutputParameters/SimpleTargetAreaModifier.parameters", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated, reference); TS_ASSERT(comparer.CompareFiles()); } }
void TestUpdateRuleOutputUpdateRuleInfo() { std::string output_directory = "TestCaUpdateRulesOutputParameters"; OutputFileHandler output_file_handler(output_directory, false); // Test with VolumeConstraintPottsUpdateRule DiffusionCaUpdateRule<2> diffusion_update_rule; diffusion_update_rule.SetDiffusionParameter(1.0); TS_ASSERT_EQUALS(diffusion_update_rule.GetIdentifier(), "DiffusionCaUpdateRule-2"); out_stream diffusion_update_rule_parameter_file = output_file_handler.OpenOutputFile("diffusion_update_rule_results.parameters"); diffusion_update_rule.OutputUpdateRuleInfo(diffusion_update_rule_parameter_file); diffusion_update_rule_parameter_file->close(); // Compare the generated file in test output with a reference copy in the source code. FileFinder generated = output_file_handler.FindFile("diffusion_update_rule_results.parameters"); FileFinder reference("cell_based/test/data/TestCaUpdateRules/diffusion_update_rule_results.parameters", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated, reference); TS_ASSERT(comparer.CompareFiles()); }
void TestCellBasedPdeHandlerOutputParameters() throw(Exception) { EXIT_IF_PARALLEL; std::string output_directory = "TestCellBasedPdeHandlerOutputParameters"; OutputFileHandler output_file_handler(output_directory, false); // Create a cell population HoneycombMeshGenerator generator(2, 2, 0); MutableMesh<2,2>* p_generating_mesh = generator.GetMesh(); NodesOnlyMesh<2> mesh; mesh.ConstructNodesWithoutMesh(*p_generating_mesh, 1.5); std::vector<CellPtr> cells; CellsGenerator<FixedDurationGenerationBasedCellCycleModel, 2> cells_generator; cells_generator.GenerateBasic(cells, mesh.GetNumNodes()); NodeBasedCellPopulation<2> cell_population(mesh, cells); // Create a PDE handler object using this cell population CellBasedPdeHandler<2> pde_handler(&cell_population); // Test output methods TS_ASSERT_EQUALS(pde_handler.GetIdentifier(), "CellBasedPdeHandler-2"); out_stream pde_handler_parameter_file = output_file_handler.OpenOutputFile("CellBasedPdeHandler.parameters"); pde_handler.OutputParameters(pde_handler_parameter_file); pde_handler_parameter_file->close(); { // Compare the generated file in test output with a reference copy in the source code. FileFinder generated = output_file_handler.FindFile("CellBasedPdeHandler.parameters"); FileFinder reference("cell_based/test/data/TestCellBasedPdeHandler/CellBasedPdeHandler.parameters", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated, reference); TS_ASSERT(comparer.CompareFiles()); } }
int main(){ int nombreutilisateur,nombreverifie,nombrealeatoire; bool victoire=false; int compteur=0,rejouer; nombrealeatoire = alea(1,10000); while(victoire==false){ nombreutilisateur = demander(); print_newline(); print_newline(); nombreverifie = verifier(nombreutilisateur); victoire = comparer(nombreverifie,nombrealeatoire); compteur = compteur+1;} print_text("Vous avez trouvé la solution en "); print_int(compteur); print_text(" coups"); print_newline(); print_newline(); print_text("Voulez vous rejouer ? : Oui ? tapez(1), Non ? tapez (2) : "); print_newline(); print_newline(); rejouer=read_int(); if(rejouer==1){main();} else{print_text("Au revoir !"); print_newline();print_newline();} return 0;}
void EnergyService::FilterCloseNeighbors() { if (maxCloseNeighborsCount <= 0) { return; } const Packing& particlesRef = *particles; closeNeighborsMask.resize(neighborsCount); VectorUtilities::InitializeWith(&closeNeighborsMask, false); sortingPermutation.resize(neighborsCount); VectorUtilities::FillLinearScale(0, &sortingPermutation); distancesToNeighborSurfaces.resize(neighborsCount); for (ParticleIndex i = 0; i < neighborsCount; ++i) { ParticleIndex neighborIndex = neighborIndexes[i]; const Particle* neighbor = &particlesRef[neighborIndex]; //No need to subtract current particle radius, as it's equal for all the entries, and won't affect sorting results distancesToNeighborSurfaces[i] = distancesToNeighbors[i] - neighbor->diameter * 0.5; } // NOTE: Here we compare distances to neighbor sphere surfaces, not normalized distances, // as we would like to treat small and large particles equally while energy minimization (to ensure isostaticity as early as possible). // TODO: this is algorithm-specific, so we may extract it later into a separate IParticleEnergyService or add IPotentialCutoffService. IndexesComparer<FLOAT_TYPE> comparer(distancesToNeighborSurfaces); StlUtilities::SortByNthElement(&sortingPermutation, maxCloseNeighborsCount - 1, comparer); for (ParticleIndex i = 0; i < maxCloseNeighborsCount; ++i) { ParticleIndex closeNeighborIndex = sortingPermutation[i]; closeNeighborsMask[closeNeighborIndex] = true; } }
void CMemSpyEngineHelperCodeSegment::GetCodeSegmentHandlesL( RArray<TAny*>& aHandles, TUint* aProcessId, TBool aRamOnly ) const { TAny* handles[ KMemSpyEngineMaxCodeSegmentCount ]; TInt count = KMemSpyEngineMaxCodeSegmentCount; TInt r = KErrNone; if ( aProcessId == NULL ) { r = iEngine.Driver().GetCodeSegs( handles, count, aRamOnly ); } else { r = iEngine.Driver().GetCodeSegs( *aProcessId, handles, count ); } if ( r == KErrNone ) { TInt index; TLinearOrder< TAny* > comparer( SortByAddress ); // Remove duplicates - since we reqested code segments for all processes, there // might be some dupes. count = Min( count, KMemSpyEngineMaxCodeSegmentCount ); for( index = 0; index < count; index++ ) { TAny* handle = handles[ index ]; const TInt error = aHandles.InsertInOrder( handle, comparer ); // if ( ! (error == KErrNone || error == KErrAlreadyExists ) ) { User::Leave( error ); } } } }