int main(int argc, char* argv[])
{
// Load the mesh.
Mesh basemesh;
H2DReader mloader;
mloader.load("domain.mesh", &basemesh);
// Initialize the meshes.
Mesh mesh_flow, mesh_concentration;
mesh_flow.copy(&basemesh);
mesh_concentration.copy(&basemesh);
for(unsigned int i = 0; i < INIT_REF_NUM_CONCENTRATION; i++)
mesh_concentration.refine_all_elements(0);
mesh_concentration.refine_towards_boundary(BDY_DIRICHLET_CONCENTRATION, INIT_REF_NUM_CONCENTRATION_BDY);
for(unsigned int i = 0; i < INIT_REF_NUM_FLOW; i++)
mesh_flow.refine_all_elements();
// Initialize boundary condition types and spaces with default shapesets.
// For the concentration.
EssentialBCs bcs_concentration;
bcs_concentration.add_boundary_condition(new DefaultEssentialBCConst(BDY_DIRICHLET_CONCENTRATION, CONCENTRATION_EXT));
L2Space space_rho(&mesh_flow, P_INIT_FLOW);
L2Space space_rho_v_x(&mesh_flow, P_INIT_FLOW);
L2Space space_rho_v_y(&mesh_flow, P_INIT_FLOW);
L2Space space_e(&mesh_flow, P_INIT_FLOW);
// Space for concentration.
H1Space space_c(&mesh_concentration, &bcs_concentration, P_INIT_CONCENTRATION);
int ndof = Space::get_num_dofs(Hermes::vector<Space*>(&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e, &space_c));
info("ndof: %d", ndof);
// Initialize solutions, set initial conditions.
InitialSolutionEulerDensity prev_rho(&mesh_flow, RHO_EXT);
InitialSolutionEulerDensityVelX prev_rho_v_x(&mesh_flow, RHO_EXT * V1_EXT);
InitialSolutionEulerDensityVelY prev_rho_v_y(&mesh_flow, RHO_EXT * V2_EXT);
InitialSolutionEulerDensityEnergy prev_e(&mesh_flow, QuantityCalculator:: calc_energy(RHO_EXT, RHO_EXT * V1_EXT, RHO_EXT * V2_EXT, P_EXT, KAPPA));
InitialSolutionConcentration prev_c(&mesh_concentration, 0.0);
// Numerical flux.
OsherSolomonNumericalFlux num_flux(KAPPA);
// Initialize weak formulation.
EulerEquationsWeakFormExplicitCoupled wf(&num_flux, KAPPA, RHO_EXT, V1_EXT, V2_EXT, P_EXT, BDY_SOLID_WALL,
BDY_INLET, BDY_OUTLET, BDY_NATURAL_CONCENTRATION, &prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e, &prev_c, EPSILON);
wf.set_time_step(time_step);
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem dp(&wf, Hermes::vector<Space*>(&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e, &space_c), is_linear);
// If the FE problem is in fact a FV problem.
//if(P_INIT == 0) dp.set_fvm();
// Filters for visualization of Mach number, pressure and entropy.
MachNumberFilter Mach_number(Hermes::vector<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), KAPPA);
PressureFilter pressure(Hermes::vector<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), KAPPA);
EntropyFilter entropy(Hermes::vector<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), KAPPA, RHO_EXT, P_EXT);
/*
ScalarView pressure_view("Pressure", new WinGeom(0, 0, 600, 300));
ScalarView Mach_number_view("Mach number", new WinGeom(700, 0, 600, 300));
ScalarView entropy_production_view("Entropy estimate", new WinGeom(0, 400, 600, 300));
ScalarView s5("Concentration", new WinGeom(700, 400, 600, 300));
*/
ScalarView s1("1", new WinGeom(0, 0, 600, 300));
ScalarView s2("2", new WinGeom(700, 0, 600, 300));
ScalarView s3("3", new WinGeom(0, 400, 600, 300));
ScalarView s4("4", new WinGeom(700, 400, 600, 300));
ScalarView s5("Concentration", new WinGeom(350, 200, 600, 300));
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Set up CFL calculation class.
CFLCalculation CFL(CFL_NUMBER, KAPPA);
// Set up Advection-Diffusion-Equation stability calculation class.
ADEStabilityCalculation ADES(ADVECTION_STABILITY_CONSTANT, DIFFUSION_STABILITY_CONSTANT, EPSILON);
int iteration = 0; double t = 0;
for(t = 0.0; t < 83.0; t += time_step) {
info("---- Time step %d, time %3.5f.", iteration++, t);
// Set the current time step.
wf.set_time_step(time_step);
bool rhs_only = (iteration == 1 ? false : true);
// Assemble stiffness matrix and rhs or just rhs.
if (rhs_only == false) {
info("Assembling the stiffness matrix and right-hand side vector.");
dp.assemble(matrix, rhs);
}
else {
info("Assembling the right-hand side vector (only).");
dp.assemble(NULL, rhs);
}
// Solve the matrix problem.
info("Solving the matrix problem.");
scalar* solution_vector = NULL;
if(solver->solve()) {
solution_vector = solver->get_solution();
Solution::vector_to_solutions(solution_vector, Hermes::vector<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e, &space_c), Hermes::vector<Solution *>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e, &prev_c));
}
else
error ("Matrix solver failed.\n");
if(SHOCK_CAPTURING) {
DiscontinuityDetector discontinuity_detector(Hermes::vector<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e), Hermes::vector<Solution *>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
std::set<int> discontinuous_elements = discontinuity_detector.get_discontinuous_element_ids(DISCONTINUITY_DETECTOR_PARAM);
FluxLimiter flux_limiter(solution_vector, Hermes::vector<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e), Hermes::vector<Solution *>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
flux_limiter.limit_according_to_detector(discontinuous_elements);
}
util_time_step = time_step;
if((iteration - 1) % CFL_CALC_FREQ == 0)
CFL.calculate(Hermes::vector<Solution *>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), &mesh_flow, util_time_step);
time_step = util_time_step;
ADES.calculate(Hermes::vector<Solution *>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y), &mesh_concentration, util_time_step);
if(util_time_step < time_step)
time_step = util_time_step;
// Visualization.
if((iteration - 1) % EVERY_NTH_STEP == 0) {
// Hermes visualization.
if(HERMES_VISUALIZATION) {
/*
Mach_number.reinit();
pressure.reinit();
entropy.reinit();
pressure_view.show(&pressure);
entropy_production_view.show(&entropy);
Mach_number_view.show(&Mach_number);
s5.show(&prev_c);
*/
s1.show(&prev_rho);
s2.show(&prev_rho_v_x);
s3.show(&prev_rho_v_y);
s4.show(&prev_e);
s5.show(&prev_c);
//s5.wait_for_close();
}
// Output solution in VTK format.
if(VTK_VISUALIZATION) {
pressure.reinit();
Mach_number.reinit();
Linearizer lin;
char filename[40];
sprintf(filename, "pressure-%i.vtk", iteration - 1);
lin.save_solution_vtk(&pressure, filename, "Pressure", false);
sprintf(filename, "pressure-3D-%i.vtk", iteration - 1);
lin.save_solution_vtk(&pressure, filename, "Pressure", true);
sprintf(filename, "Mach number-%i.vtk", iteration - 1);
lin.save_solution_vtk(&Mach_number, filename, "MachNumber", false);
sprintf(filename, "Mach number-3D-%i.vtk", iteration - 1);
lin.save_solution_vtk(&Mach_number, filename, "MachNumber", true);
sprintf(filename, "Concentration-%i.vtk", iteration - 1);
lin.save_solution_vtk(&prev_c, filename, "Concentration", true);
sprintf(filename, "Concentration-3D-%i.vtk", iteration - 1);
lin.save_solution_vtk(&prev_c, filename, "Concentration", true);
}
}
}
/*
pressure_view.close();
entropy_production_view.close();
Mach_number_view.close();
s5.close();
*/
s1.close();
s2.close();
s3.close();
s4.close();
s5.close();
return 0;
}
inline T bessel_y_derivative_small_z_series(T v, T x, const Policy& pol)
{
BOOST_MATH_STD_USING
static const char* function = "bessel_y_derivative_small_z_series<%1%>(%1%,%1%)";
T prefix;
T gam;
T p = log(x / 2);
T scale = 1;
bool need_logs = (v >= boost::math::max_factorial<T>::value) || (boost::math::tools::log_max_value<T>() / v < fabs(p));
if (!need_logs)
{
gam = boost::math::tgamma(v, pol);
p = pow(x / 2, v + 1) * 2;
if (boost::math::tools::max_value<T>() * p < gam)
{
scale /= gam;
gam = 1;
if (boost::math::tools::max_value<T>() * p < gam)
{
// This term will overflow to -INF, when combined with the series below it becomes +INF:
return boost::math::policies::raise_overflow_error<T>(function, 0, pol);
}
}
prefix = -gam / (boost::math::constants::pi<T>() * p);
}
else
{
gam = boost::math::lgamma(v, pol);
p = (v + 1) * p + constants::ln_two<T>();
prefix = gam - log(boost::math::constants::pi<T>()) - p;
if (boost::math::tools::log_max_value<T>() < prefix)
{
prefix -= log(boost::math::tools::max_value<T>() / 4);
scale /= (boost::math::tools::max_value<T>() / 4);
if (boost::math::tools::log_max_value<T>() < prefix)
{
return boost::math::policies::raise_overflow_error<T>(function, 0, pol);
}
}
prefix = -exp(prefix);
}
bessel_y_derivative_small_z_series_term_a<T, Policy> s(v, x);
boost::uintmax_t max_iter = boost::math::policies::get_max_series_iterations<Policy>();
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
T zero = 0;
T result = boost::math::tools::sum_series(s, boost::math::policies::get_epsilon<T, Policy>(), max_iter, zero);
#else
T result = boost::math::tools::sum_series(s, boost::math::policies::get_epsilon<T, Policy>(), max_iter);
#endif
boost::math::policies::check_series_iterations<T>("boost::math::bessel_y_derivative_small_z_series<%1%>(%1%,%1%)", max_iter, pol);
result *= prefix;
p = pow(x / 2, v - 1) / 2;
if (!need_logs)
{
prefix = boost::math::tgamma(-v, pol) * boost::math::cos_pi(v) * p / boost::math::constants::pi<T>();
}
else
{
int sgn;
prefix = boost::math::lgamma(-v, &sgn, pol) + (v - 1) * log(x / 2) - constants::ln_two<T>();
prefix = exp(prefix) * sgn / boost::math::constants::pi<T>();
}
bessel_y_derivative_small_z_series_term_b<T, Policy> s2(v, x);
max_iter = boost::math::policies::get_max_series_iterations<Policy>();
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
T b = boost::math::tools::sum_series(s2, boost::math::policies::get_epsilon<T, Policy>(), max_iter, zero);
#else
T b = boost::math::tools::sum_series(s2, boost::math::policies::get_epsilon<T, Policy>(), max_iter);
#endif
result += scale * prefix * b;
return result;
}
int main(int argc, char **argv)
{
PetscInitialize(&argc,&argv,PETSC_NULL,PETSC_NULL);
//PetscInitializeNoArguments();
int iter = 1;
double Re = 10;
double We = 1;
double c1 = 1.0; // lagrangian
double c2 = 0.0; // smooth vel
double c3 = 0.0; // smooth coord (fujiwara)
double d1 = 1.0; // surface tangent velocity u_n=u-u_t
double d2 = 0.0; // surface smooth cord (fujiwara)
double alpha = 1;
double mu_in = 1.0;
double mu_out = 0.1;
double rho_in = 1.0;
double rho_out = 0.01;
double cfl = 0.8;
string meshFile = "0.20.msh";
Solver *solverP = new PetscSolver(KSPGMRES,PCILU);
Solver *solverV = new PetscSolver(KSPCG,PCICC);
Solver *solverC = new PetscSolver(KSPCG,PCICC);
const char *binFolder = "./bin/";
const char *vtkFolder = "./vtk/";
const char *mshFolder = "./msh/";
const char *datFolder = "./dat/";
string meshDir = (string) getenv("DATA_DIR");
meshDir += "/gmsh/3d/torus/curvature/" + meshFile;
const char *mesh = meshDir.c_str();
Model3D m1;
Simulator3D s1;
if( *(argv+1) == NULL )
{
cout << endl;
cout << "--------------> STARTING FROM 0" << endl;
cout << endl;
const char *mesh1 = mesh;
m1.readMSH(mesh1);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBC();
s1(m1);
s1.setRe(Re);
s1.setWe(We);
s1.setC1(c1);
s1.setC2(c2);
s1.setC3(c3);
s1.setD1(d1);
s1.setD2(d2);
s1.setAlpha(alpha);
s1.setMu(mu_in,mu_out);
s1.setRho(rho_in,rho_out);
s1.setCfl(cfl);
s1.init();
s1.setDtALETwoPhase();
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
}
else
{
cout << endl;
cout << "--------------> RE-STARTING..." << endl;
cout << endl;
// load surface mesh
string aux = *(argv+2);
string file = (string) "./msh/newMesh-" + *(argv+2) + (string) ".msh";
const char *mesh2 = file.c_str();
m1.readMSH(mesh2);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D();
s1(m1);
// load 3D mesh
file = (string) "./vtk/sim-" + *(argv+2) + (string) ".vtk";
const char *vtkFile = file.c_str();
m1.readVTK(vtkFile);
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.readVTKHeaviside(vtkFile);
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBC();
s1(m1);
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
iter = s1.loadSolution("./","sim",atoi(*(argv+2)));
}
// Point's distribution
Helmholtz3D h1(m1);
h1.setBC();
h1.initRisingBubble();
h1.assemble();
h1.setk(0.2);
h1.matMountC();
h1.setUnCoupledCBC();
h1.setCRHS();
h1.unCoupledC();
//h1.saveVTK(vtkFolder,"edge");
h1.setModel3DEdgeSize();
InOut save(m1,s1); // cria objeto de gravacao
save.saveVTK(vtkFolder,"geometry");
save.saveVTKSurface(vtkFolder,"geometry");
save.saveMeshInfo(datFolder);
save.saveInfo(datFolder,"info",mesh);
int nIter = 3000;
int nReMesh = 1;
for( int i=1;i<=nIter;i++ )
{
for( int j=0;j<nReMesh;j++ )
{
cout << color(none,magenta,black);
cout << "____________________________________ Iteration: "
<< iter << endl << endl;
cout << resetColor();
s1.setDtALETwoPhase();
InOut save(m1,s1); // cria objeto de gravacao
save.printSimulationReport();
//s1.stepLagrangian();
s1.stepALE();
s1.movePoints();
s1.assemble();
s1.matMount();
s1.setUnCoupledBC();
s1.setRHS();
//s1.setGravity("-Z");
//s1.setInterface();
s1.setInterfaceGeo();
s1.unCoupled();
save.saveMSH(mshFolder,"newMesh",iter);
save.saveVTK(vtkFolder,"sim",iter);
save.saveVTKSurface(vtkFolder,"sim",iter);
save.saveSol(binFolder,"sim",iter);
save.saveBubbleInfo(datFolder);
//save.chordalPressure(datFolder,"chordalPressure",iter);
//save.crossSectionalVoidFraction(datFolder,"voidFraction",iter);
s1.saveOldData();
s1.timeStep();
cout << color(none,magenta,black);
cout << "________________________________________ END of "
<< iter << endl << endl;;
cout << resetColor();
iter++;
}
Helmholtz3D h2(m1,h1);
h2.setBC();
h2.initRisingBubble();
h2.assemble();
h2.setk(0.2);
h2.matMountC();
h2.setUnCoupledCBC();
h2.setCRHS();
h2.unCoupledC();
h2.saveVTK(vtkFolder,"edge",iter-1);
h2.saveChordalEdge(datFolder,"edge",iter-1);
h2.setModel3DEdgeSize();
Model3D mOld = m1;
/* *********** MESH TREATMENT ************* */
// set normal and kappa values
m1.setNormalAndKappa();
m1.initMeshParameters();
// 3D operations
//m1.insert3dMeshPointsByDiffusion();
m1.remove3dMeshPointsByDiffusion();
//m1.removePointByVolume();
//m1.removePointsByInterfaceDistance();
//m1.remove3dMeshPointsByDistance();
m1.remove3dMeshPointsByHeight();
m1.delete3DPoints();
// surface operations
m1.smoothPointsByCurvature();
m1.insertPointsByLength("flat");
m1.contractEdgesByLength("flat");
m1.flipTriangleEdges();
m1.removePointsByNeighbourCheck();
//m1.checkAngleBetweenPlanes();
/* **************************************** */
//m1.mesh2Dto3DOriginal();
m1.mesh3DPoints();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setGenericBC();
Simulator3D s2(m1,s1);
s2.applyLinearInterpolation(mOld);
s1 = s2;
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.printMeshReport();
saveEnd.saveMeshInfo(datFolder);
}
PetscFinalize();
return 0;
}
int main( int argc, char** argv ) {
if( argc < 6 || argc & 1) {
std::cout << "usage: " << argv[0]
<< " <threshold> <nions> <nbright> [<n> <template> ...]"
<< std::endl;
return -1;
}
size_t threshold = 0, nimages = 0, nions = 0, nbright = 0;
std::stringstream s( argv[1] );
s >> threshold;
std::stringstream s3( argv[2] );
s3 >> nions;
std::stringstream s4( argv[3] );
s4 >> nbright;
std::vector<IonDetector::result_type> res;
size_t argc_i = 4;
while( argc_i < argc ) {
std::stringstream s2( argv[argc_i++] );
s2 >> nimages;
for( size_t i = 0; i < nimages; ++i ) {
char image_name[1024];
sprintf( image_name, argv[argc_i], i );
image_type data = load_file( image_name );
if( !data.extents.first ) { // Failed to load image
return -1;
}
IonDetector det;
det.blob_threshold = threshold;
image_type result = det.hot_pixels( data );
save_file( "hot.fits", result );
IonDetector::result_type results = det( result );
res.push_back( results );
if( results.size() > nbright ) {
std::cout << "Too many ions in: " << image_name << std::endl;
} else if( results.size() < nbright ) {
std::cout << "Too few ions in: " << image_name << std::endl;
}
}
++argc_i;
}
std::vector< std::pair< size_t, IonData > > positions;
for( size_t i = 0; i < res.size(); ++i ) {
if( res[i].size() != nbright )
continue;
for( size_t ion = 0; ion < res[i].size(); ++ion ) {
size_t pos = 0;
for( ; pos < positions.size(); ++pos ) {
if( fabs( positions[pos].second.x - res[i][ion].x ) < 6 &&
fabs( positions[pos].second.y - res[i][ion].y ) < 6 ) {
++ positions[pos].first;
break;
}
}
if( pos == positions.size() )
positions.push_back( std::make_pair( 1, res[i][ion] ) );
}
}
std::sort( positions.begin(), positions.end() );
std::reverse( positions.begin(), positions.end() );
if( positions.size() > nions )
positions.resize( nions );
std::sort( positions.begin(), positions.end(), CompareSecond() );
std::cout << "Detected ion locations: " << std::endl;
for( size_t i = 0; i < positions.size(); ++i ) {
std::cout << positions[i].second.x << ", " << positions[i].second.y
<< std::endl;
}
std::cout << std::endl;
std::cout << "Ion patterns: " << std::endl;
std::vector< std::string > bits;
for( size_t i = 0; i < res.size(); ++i ) {
bits.push_back( "" );
for( size_t pos = 0; pos < positions.size(); ++pos ) {
size_t ion = 0;
for( ; ion < res[i].size(); ++ion ) {
if( fabs( positions[pos].second.x - res[i][ion].x ) < 6 &&
fabs( positions[pos].second.y - res[i][ion].y ) < 6 ) {
bits.back() += "1";
break;
}
}
if( ion == res[i].size() )
bits.back() += "0";
}
std::cout << i << ":\t" << bits.back() << std::endl;
}
size_t reorder = 0;
std::string order = bits[0];
for( size_t i = 1; i < bits.size(); ++i ) {
if( bits[i] != order ) {
++reorder;
order = bits[i];
}
}
std::cout << "Reordered " << reorder << " times." << std::endl;
std::cout << "Probability: " << (float)reorder / (nimages-1) << std::endl;
return 0;
}
int main()
{
{
boost::shared_ptr<int> sp(new int(10));
assert(sp.unique());
boost::shared_ptr<int> sp2 = sp;
assert(sp == sp2 && sp.use_count() == 2);
*sp2 = 100;
assert(*sp == 100);
sp.reset();
assert(!sp);
boost::shared_ptr<int> p(new int(100));
shared s1(p), s2(p);
s1.print();
s2.print();
*p = 20;
print_func(p);
s1.print();
}
{
//factory function
//template<class T,class... Args>
//boost::shared_ptr<T> boost::make_shared(Args && ... args);
boost::shared_ptr<std::string> sp =
boost::make_shared<std::string>("make_shared");
boost::shared_ptr<std::vector<int> > spv =
boost::make_shared<std::vector<int> >(10,2);
assert(spv->size() == 10);
}
{
typedef std::vector<boost::shared_ptr<int> > vs;
vs v(10);
int i = 0;
for(vs::iterator pos=v.begin();pos!=v.end();++pos)
{
(*pos) = boost::make_shared<int>(++i);
std::cout << *(*pos) << ", ";
}
std::cout << std::endl;
boost::shared_ptr<int> p = v[9];
*p = 100;
std::cout << *v[9] << std::endl;
for(auto& ptr : v)
{
ptr = boost::make_shared<int>(++i);
std::cout << *ptr << ", ";
}
std::cout << std::endl;
}
{
//bridge pattern
sample s;
s.print();
}
return 0;
}
int QgsStringUtils::levenshteinDistance( const QString& string1, const QString& string2, bool caseSensitive )
{
int length1 = string1.length();
int length2 = string2.length();
//empty strings? solution is trivial...
if ( string1.isEmpty() )
{
return length2;
}
else if ( string2.isEmpty() )
{
return length1;
}
//handle case sensitive flag (or not)
QString s1( caseSensitive ? string1 : string1.toLower() );
QString s2( caseSensitive ? string2 : string2.toLower() );
const QChar* s1Char = s1.constData();
const QChar* s2Char = s2.constData();
//strip out any common prefix
int commonPrefixLen = 0;
while ( length1 > 0 && length2 > 0 && *s1Char == *s2Char )
{
commonPrefixLen++;
length1--;
length2--;
s1Char++;
s2Char++;
}
//strip out any common suffix
while ( length1 > 0 && length2 > 0 && s1.at( commonPrefixLen + length1 - 1 ) == s2.at( commonPrefixLen + length2 - 1 ) )
{
length1--;
length2--;
}
//fully checked either string? if so, the answer is easy...
if ( length1 == 0 )
{
return length2;
}
else if ( length2 == 0 )
{
return length1;
}
//ensure the inner loop is longer
if ( length1 > length2 )
{
qSwap( s1, s2 );
qSwap( length1, length2 );
}
//levenshtein algorithm begins here
QVector< int > col;
col.fill( 0, length2 + 1 );
QVector< int > prevCol;
prevCol.reserve( length2 + 1 );
for ( int i = 0; i < length2 + 1; ++i )
{
prevCol << i;
}
const QChar* s2start = s2Char;
for ( int i = 0; i < length1; ++i )
{
col[0] = i + 1;
s2Char = s2start;
for ( int j = 0; j < length2; ++j )
{
col[j + 1] = qMin( qMin( 1 + col[j], 1 + prevCol[1 + j] ), prevCol[j] + (( *s1Char == *s2Char ) ? 0 : 1 ) );
s2Char++;
}
col.swap( prevCol );
s1Char++;
}
return prevCol[length2];
}
QString QgsStringUtils::longestCommonSubstring( const QString& string1, const QString& string2, bool caseSensitive )
{
if ( string1.isEmpty() || string2.isEmpty() )
{
//empty strings, solution is trivial...
return QString();
}
//handle case sensitive flag (or not)
QString s1( caseSensitive ? string1 : string1.toLower() );
QString s2( caseSensitive ? string2 : string2.toLower() );
if ( s1 == s2 )
{
//another trivial case, identical strings
return s1;
}
int* currentScores = new int [ s2.length()];
int* previousScores = new int [ s2.length()];
int maxCommonLength = 0;
int lastMaxBeginIndex = 0;
const QChar* s1Char = s1.constData();
const QChar* s2Char = s2.constData();
const QChar* s2Start = s2Char;
for ( int i = 0; i < s1.length(); ++i )
{
for ( int j = 0; j < s2.length(); ++j )
{
if ( *s1Char != *s2Char )
{
currentScores[j] = 0;
}
else
{
if ( i == 0 || j == 0 )
{
currentScores[j] = 1;
}
else
{
currentScores[j] = 1 + previousScores[j - 1];
}
if ( maxCommonLength < currentScores[j] )
{
maxCommonLength = currentScores[j];
lastMaxBeginIndex = i;
}
}
s2Char++;
}
qSwap( currentScores, previousScores );
s1Char++;
s2Char = s2Start;
}
delete [] currentScores;
delete [] previousScores;
return string1.mid( lastMaxBeginIndex - maxCommonLength + 1, maxCommonLength );
}
int main(int argc, char** argv)
{
int exitCode = 0;
/*
create a pi|engine instance and initialize it.
Initialization step loads and prepares the resources,
initializes the engine and sets up game window
unless application configuration states otherwise.
*/
application app;
gcString s = "Test_";
gcString s2("shit");
gcString s3 = gcString("coca") + "cola" + "[]";
gcString s4 = "OLD";
s4 = ">" + s + " " + s3 + " " + s4; //Test cocacola[] OLD
gcString s5 = gcString::gcFromInt(600);
gcString s6 = s + s5 + " " + s2;
s6 += " [";
s6 += gcString::gcFromInt(60) + "]";
for(int i=1;i<=100;i++)
{
s += gcString::gcFromInt(i) +",";
}
s += s + s; //selfref test
gcArray<gcString>* a = new gcArray<gcString>;
a->setSize(13);
// strings test
(*a)[0] = "2500";
(*a)[0].setw(8,"0");
(*a)[1] = "Pesho";
(*a)[1].setw(20,"[abc]");
(*a)[2] = "acbdefghijkl";
(*a)[2].setw(4);
(*a)[3] = "5300";
(*a)[3].setw(10);
(*a)[4] = "681";
(*a)[4].setw(10,""); //case that is not allowed
(*a)[5] = "123";
(*a)[5].setw(10,"-");
(*a)[6] = "Peter";
(*a)[6].setrw(10,"-");
(*a)[7] = "Peter";
(*a)[7].setrw(3);
(*a)[8] = "*-PeterSvP1870_test[100]-*X";
(*a)[10] = (*a)[8].digits();
(*a)[8] = (*a)[8].letters();
(*a)[9] = (*a)[8].toLower();
(*a)[11] = (*a)[8][0] + (*a)[8][1];
(*a)[12] = "Pes*o";
(*a)[12].setchar(3,"h");
//show them:
for(int i=0;i<a->count();i++)
{
gcString output;
output = "a[" + gcString::gcFromInt(i) + "]= " + (*a)[i] + "\n";
std::cout << output;
}
std::cout
<< "s = " << s << std::endl
<< "s2= " << s2 << std::endl
<< "s3= " << s3 << std::endl
<< "s4= " << s4 << std::endl
<< "s5= " << s5 << std::endl
<< "s6= " << s6 << std::endl
;
#define PRINTINT(gc_array_var) \
for(int i=0;i<gc_array_var.count();++i) \
std::cout << "int[" << gcString::gcFromInt(i) << "] = " << gcString::gcFromInt( gc_array_var.gcAt(i) ) << std::endl;
#define PRINTS(gc_array_var) \
for(int i=0;i<gc_array_var.count();++i) \
std::cout << "string[" << gcString::gcFromInt(i) << "] = " << gc_array_var.gcAt(i) << std::endl;
/* gcArray test */
// INT
{
gcArray<int> a;
a.setSize(5); //must add 5 zeros
a << 1 << 2 << 50 << 100; //and add 1,2,50,100 finally
std::cout << "A:\n";
PRINTINT(a);
std::cout << "B:\n";
gcArray<int>* b = a.clone();
b->removeDuplicates();
(*b) << 75;
b->sort();
PRINTINT( (*b) );
}
// STRING
{
gcArray<gcString> *a = new gcArray<gcString>, *b = new gcArray<gcString>, *c = a;
//c i s same as a?
(*c) << "1" << "2";
(*a) << "3" << "4";
(*c) << "5" << "6";
a->setSize(10);
(*c) << "5" << "Pi-Dev";
(*a).insertAfter(5,"7");
(*a).insertBefore(0,"begin");
(*a).insertAfter( (*a).count()-1, "Appended" );
//delete b; //These calls must be somehow inserted by gameScript optimizer directly;
b = a->clone(); //this will effectively invalidate b! There MUST be an memory manager
b->removeDuplicates();
c = c->clone(); //it is internally okay ;] C is now copy of a
c = c->getDuplicates(); //c will only need to show "" and 5 now ;]
b->sort();
std::cout << "A[]:\n";
PRINTS((*a));
std::cout << "B[]:\n";
PRINTS((*b));
std::cout << "C[]:\n";
PRINTS((*c));
}
{
std::cout << "POINTER TYPE sort\n";
gcArray<int*> a;
a << new int(4) << new int(2) << new int(100) << new int(3);
a.sort();
std::cout<<"Count: "<<a.count() << "\n";
for(int i=0;i<a.count();++i)
{
std::cout << *(a[i]) << std::endl;
}
}
{
gcArray<std::string>* a = new gcArray<std::string>;
(*a) << "Dimo" << "Pesho" << "Atanas";
a->sort();
for(int i=0;i<a->count();++i)
{
std::cout << (*a)[i] << std::endl;
}
}
{
//2d Array test:
gcArray2D<int> ia;
ia.setSize(3,5);
ia(0,1) = 10;
ia(1,1) = 20;
ia(2,4) = 45;
for(int y=0;y<ia.yCount();++y)
{
for(int x=0;x<ia.xCount();++x)
std::cout << gcString::gcFromInt(ia(x,y)).setw(6,".") << " ";
std::cout << "\n";
}
}
{
/* 3D Array test */
gcArray3D<gcString> a;
a.setSize(5,4,3);
for(int x=0;x<3;++x)
for(int y=0;y<3;++y)
a(x,y,2) = "Stone";
a(0,0,0) = "Cloud";
a(1,0,0) = "Cloud";
a(0,0,1) = "Player";
a(1,0,1) = "Item";
a(1,1,1) = "Item";
a(4,3,2) = "Bound";
for(int z=0;z<a.zCount();++z)
{
std::cout<<"z = "<< gcString::gcFromInt(z) << "\n";
for(int y=0;y<a.yCount();++y)
{
for(int x=0;x<a.xCount();++x)std::cout<<"["<<a(x,y,z).setw(6,"-")<<"]";
std::cout<<"\n";
}
std::cout<<"\n";
}
}
#undef PRINTS
#undef PRINTINT
if(app.init())exitCode = app.run();
else std::cout
<< "Initialization failed with following error:\n"
<< app.lastException->text
<< "\n";
std::cout<<"Application closed with exit code "<<exitCode<<"!\n\n";
return exitCode;
}
void SecureDataMgrTests::testSecureDataManager()
{
ByteString soPIN = "3132333435363738"; // "12345678"
ByteString userPIN = "4041424344454647"; // "ABCDEFGH"
ByteString newSOPIN = "3837363534333231"; // "87654321"
ByteString newUserPIN = "4746454443424140"; // "HGFEDCBA"
// Instantiate a blank secure data manager
SecureDataManager s1;
ByteString plaintext = "010203040506070809";
ByteString emptyPlaintext = "";
ByteString encrypted;
// Verify that no function other than setting the SO PIN works
CPPUNIT_ASSERT(!s1.setUserPIN(userPIN));
CPPUNIT_ASSERT(!s1.loginSO(soPIN));
CPPUNIT_ASSERT(!s1.loginUser(userPIN));
CPPUNIT_ASSERT(!s1.encrypt(plaintext, encrypted));
CPPUNIT_ASSERT(!s1.decrypt(encrypted, plaintext));
CPPUNIT_ASSERT(s1.getSOPINBlob().size() == 0);
CPPUNIT_ASSERT(s1.getUserPINBlob().size() == 0);
// Now set the SO PIN
CPPUNIT_ASSERT(s1.setSOPIN(soPIN));
// Check that it is still not possible to set the user PIN
CPPUNIT_ASSERT(!s1.setUserPIN(userPIN));
// Check that it is possible to log in with the SO PIN
CPPUNIT_ASSERT(s1.loginSO(soPIN));
// Check that it is now possible to also set the user PIN
CPPUNIT_ASSERT(s1.setUserPIN(userPIN));
// Check that is is now also possible to log in with the user PIN
CPPUNIT_ASSERT(s1.loginUser(userPIN));
// Check that it is possible to encrypt and decrypt some data
ByteString decrypted;
CPPUNIT_ASSERT(s1.encrypt(plaintext, encrypted));
CPPUNIT_ASSERT(encrypted != plaintext);
CPPUNIT_ASSERT(s1.decrypt(encrypted, decrypted));
CPPUNIT_ASSERT(decrypted == plaintext);
// Log out
s1.logout();
// Check that it is no longer possible to set the SO PIN
CPPUNIT_ASSERT(!s1.setSOPIN(soPIN));
// Check that it is no longer possible to set the user PIN
CPPUNIT_ASSERT(!s1.setUserPIN(userPIN));
// Check that encrypting/decrypting no longer works
CPPUNIT_ASSERT(!s1.encrypt(plaintext, encrypted));
CPPUNIT_ASSERT(!s1.decrypt(encrypted, plaintext));
// Export the key blobs
ByteString soPINBlob = s1.getSOPINBlob();
ByteString userPINBlob = s1.getUserPINBlob();
// Create a new instance with the exported key blobs
SecureDataManager s2(soPINBlob, userPINBlob);
// Check that the key blobs match
CPPUNIT_ASSERT(s1.getSOPINBlob() == s2.getSOPINBlob());
CPPUNIT_ASSERT(s1.getUserPINBlob() == s2.getUserPINBlob());
// Check that it is not possible to set the SO PIN
CPPUNIT_ASSERT(!s2.setSOPIN(soPIN));
// Check that it is possible to log in with the SO PIN
CPPUNIT_ASSERT(s2.loginSO(soPIN));
// Check that is is now also possible to log in with the user PIN
CPPUNIT_ASSERT(s2.loginUser(userPIN));
// Check that encrypting the data results in different ciphertext because of the random IV
ByteString encrypted2;
CPPUNIT_ASSERT(s2.encrypt(plaintext, encrypted2));
CPPUNIT_ASSERT(encrypted != encrypted2);
// Check that decrypting earlier data can be done with the recreated key
CPPUNIT_ASSERT(s2.decrypt(encrypted, decrypted));
CPPUNIT_ASSERT(decrypted == plaintext);
// Log in with the SO PIN
CPPUNIT_ASSERT(s2.loginSO(soPIN));
// Check that the SO PIN can be changed
CPPUNIT_ASSERT(s2.setSOPIN(newSOPIN));
// Check that it is no longer possible to log in with the old SO PIN
CPPUNIT_ASSERT(!s2.loginSO(soPIN));
// Check that encrypting/decrypting no longer works
CPPUNIT_ASSERT(!s2.encrypt(plaintext, encrypted));
CPPUNIT_ASSERT(!s2.decrypt(encrypted, plaintext));
// Check that the key blobs differ
CPPUNIT_ASSERT(s1.getSOPINBlob() != s2.getSOPINBlob());
// Check that it is possible to log in with the new SO PIN
CPPUNIT_ASSERT(s2.loginSO(newSOPIN));
// Log in with the user PIN
CPPUNIT_ASSERT(s2.loginUser(userPIN));
// Check that it is possible to change the user PIN
CPPUNIT_ASSERT(s2.setUserPIN(newUserPIN));
// Check that it is no longer possible to log in with the old user PIN
CPPUNIT_ASSERT(!s2.loginUser(userPIN));
// Check that encrypting/decrypting no longer works
CPPUNIT_ASSERT(!s2.encrypt(plaintext, encrypted));
CPPUNIT_ASSERT(!s2.decrypt(encrypted, plaintext));
// Check that it is possible to log in with the new user PIN
CPPUNIT_ASSERT(s2.loginUser(newUserPIN));
// Check that encrypting the data results in the different ciphertext because of the random IV
CPPUNIT_ASSERT(s2.encrypt(plaintext, encrypted2));
CPPUNIT_ASSERT(encrypted != encrypted2);
// Check that decrypting earlier data can be done with the recreated key
CPPUNIT_ASSERT(s2.decrypt(encrypted, decrypted));
CPPUNIT_ASSERT(decrypted == plaintext);
// Check that empty plaintext can be handled
CPPUNIT_ASSERT(s2.encrypt(emptyPlaintext, encrypted));
CPPUNIT_ASSERT(s2.decrypt(encrypted, decrypted));
CPPUNIT_ASSERT(decrypted == emptyPlaintext);
}
void test()
{
//Single unique_ptr
reset_counters();
{
def_constr_deleter<A> d;
bml::unique_ptr<B, def_constr_deleter<A>&> s(new B, d);
A* p = s.get();
bml::unique_ptr<A, def_constr_deleter<A>&> s2(boost::move(s));
BOOST_TEST(s2.get() == p);
BOOST_TEST(s.get() == 0);
BOOST_TEST(A::count == 1);
BOOST_TEST(B::count == 1);
d.set_state(6);
BOOST_TEST(s2.get_deleter().state() == d.state());
BOOST_TEST(s.get_deleter().state() == d.state());
}
BOOST_TEST(A::count == 0);
BOOST_TEST(B::count == 0);
//Unbounded array unique_ptr
reset_counters();
{
def_constr_deleter<volatile A[]> d;
bml::unique_ptr<A[], def_constr_deleter<volatile A[]>&> s(new A[2], d);
A* p = s.get();
bml::unique_ptr<volatile A[], def_constr_deleter<volatile A[]>&> s2(boost::move(s));
BOOST_TEST(s2.get() == p);
BOOST_TEST(s.get() == 0);
BOOST_TEST(A::count == 2);
d.set_state(6);
BOOST_TEST(s2.get_deleter().state() == d.state());
BOOST_TEST(s.get_deleter().state() == d.state());
}
BOOST_TEST(A::count == 0);
//Bounded array unique_ptr
reset_counters();
{
def_constr_deleter<volatile A[2]> d;
bml::unique_ptr<A[2], def_constr_deleter<volatile A[2]>&> s(new A[2], d);
A* p = s.get();
bml::unique_ptr<volatile A[2], def_constr_deleter<volatile A[2]>&> s2(boost::move(s));
BOOST_TEST(s2.get() == p);
BOOST_TEST(s.get() == 0);
BOOST_TEST(A::count == 2);
d.set_state(6);
BOOST_TEST(s2.get_deleter().state() == d.state());
BOOST_TEST(s.get_deleter().state() == d.state());
}
BOOST_TEST(A::count == 0);
{
def_constr_deleter<volatile A[]> d;
bml::unique_ptr<A[2], def_constr_deleter<volatile A[]>&> s(new A[2], d);
A* p = s.get();
bml::unique_ptr<volatile A[], def_constr_deleter<volatile A[]>&> s2(boost::move(s));
BOOST_TEST(s2.get() == p);
BOOST_TEST(s.get() == 0);
BOOST_TEST(A::count == 2);
d.set_state(6);
BOOST_TEST(s2.get_deleter().state() == d.state());
BOOST_TEST(s.get_deleter().state() == d.state());
}
BOOST_TEST(A::count == 0);
}