template <typename F> F Cgnr<F>::iteration (csize_t nr, UNUSED std::ostream& log, UNUSED bool profilingRun, Core::ProfilingDataPtr prof) {
std::vector<ctype>& rvec = this->rvec ();
std::vector<ctype>& Avecbuffer = this->Avecbuffer ();
std::vector<ctype>& xvec = this->xvec ();
std::vector<ctype>& pvec = this->tmpVec1 ();
if (nr == 0) {
{
Core::ProfileHandle _p1 (prof, "matvec1");
this->matVec ().apply (rvec, pvec, true, prof);
}
vars.ro_new = LinAlg::norm (pvec);
} else {
{
Core::ProfileHandle _p1 (prof, "matvec1");
this->matVec ().apply (rvec, Avecbuffer, true, prof);
}
vars.ro_new = LinAlg::norm (Avecbuffer);
vars.beta = vars.ro_new / vars.ro_old;
LinAlg::linComb (pvec, vars.beta, Avecbuffer, pvec);
}
{
Core::ProfileHandle _p1 (prof, "matvec2");
this->matVec ().apply (pvec, Avecbuffer, false, prof);
}
ctype alpha = vars.ro_new / LinAlg::norm (Avecbuffer);
LinAlg::linComb (pvec, alpha, xvec, xvec);
LinAlg::linComb (Avecbuffer, -alpha, rvec, rvec);
vars.ro_old = vars.ro_new;
return LinAlg::norm (rvec);
}
template <class F> void IterativeSolverBase<F>::profilingRun (std::ostream& out, std::ostream& log, Core::ProfilingDataPtr prof) {
this->epsB = 1;
this->prev_err = 1;
this->count = 10;
this->counter = 0;
{
Core::ProfileHandle _p1 (prof, "itsolv1");
iteration (count - 1, log, true, prof);
}
const int nr = 5;
const int mid = nr / 2;
boost::tuple<uint64_t, int> res[nr];
{
Core::ProfileHandle _p1 (prof, "itsolv2");
Core::TimeSpan now = Core::getCurrentTime ();
for (int i = 0; i < nr; i++) {
iteration (count + i, log, true, prof);
res[i] = boost::make_tuple ((Core::getCurrentTime () - now).getMicroseconds (), i);
now = Core::getCurrentTime ();
}
}
std::sort (res, res + nr);
for (int i = 0; i < nr; i++)
out << "[" << res[i].get<1> () << "]" << Core::TimeSpan (res[i].get<0> ()).toString () << " ";
uint64_t diff = std::max (res[mid].get<0> () - res[0].get<0> (), res[nr - 1].get<0> () - res[mid].get<0> ());
out << std::endl;
out << std::endl;
out << Core::TimeSpan (res[mid].get<0> ()).toString () << " +- " << Core::TimeSpan (diff).toString () << std::endl;
}
/*
* V(1, 0.5, 0.7)
* Ray P = p + tV
* Plane P*N + d = 0
* t = -(p*N + d)/(V*N);
* Should T >= 0 ? Ray just in one direction.
* Return:
* 0 if ray does not intersect.
* 1 if ray intersect on the borders.
* 2 if ray intersect.
*/
int Polygon::ray_intersect(const Point &p, const Point &v)
{
double pnormal = p.x*normal.a + p.y*normal.b + p.z*normal.c;
// Right angle
if (!(normal.a*v.x + normal.b*v.y + normal.c*v.z)) {
return 0;
}
double t = -(pnormal + normal.d) / (normal.a*v.x + normal.b*v.y + normal.c*v.z);
if (t < 0)
return 0;
Point _p1(p.x + t*v.x, p.y + t*v.y, p.z + t*v.z);
if (is_point_in_polygon(_p1)) {
if (is_in_border(_p1)) {
return 1;
}
return 2;
}
return 0;
}
template <typename F> F GpuQmrCs<F>::iteration (csize_t nr, UNUSED std::ostream& log, UNUSED bool profilingRun, Core::ProfilingDataPtr prof) {
const std::vector<cl::CommandQueue>& queues = this->queues ();
const cl::CommandQueue& queue = queues[0];
INFO ("");
DipVector<ftype>& rvec = this->rvec ();
DipVector<ftype>& Avecbuffer = this->Avecbuffer ();
DipVector<ftype>& xvec = this->xvec ();
DipVector<ftype>& v = this->tmpVec1 ();
DipVector<ftype>& vtilda = this->tmpVec2 ();
DipVector<ftype>& p_old = this->tmpVec3 ();
DipVector<ftype>& p_new = this->tmpVec4 ();
ftype rtmp1 = norm ((vars + &Vars::beta).read (queue)) * this->residScale;
if (nr == 0)
ASSERT (!(rtmp1 > 1e+38f) || profilingRun); // Allow very low beta values (seen e.g. when using --load-start-dip-pol)
else
ASSERT (!(rtmp1 < 1e-10f || rtmp1 > 1e+38f) || profilingRun);
INFO (rtmp1);
{
Core::ProfileHandle _p1 (prof, "matvec");
this->matVec ().apply (queues, v, Avecbuffer, false, prof);
}
ctype alpha = vecProdConj (queues, v, Avecbuffer);
(vars + &Vars::mAlpha).write (queue, -alpha);
INFO (vtilda);
if (nr == 0)
this->linComb.linComb (queues, v, vars + &Vars::mAlpha, Avecbuffer, vtilda);
else {
this->linComb.linComb (queues, vtilda, vars + &Vars::mBeta, v, vars + &Vars::mAlpha, Avecbuffer, vtilda);
}
INFO (vars + &Vars::mAlpha); INFO (vars + &Vars::mBeta); INFO (v); INFO (Avecbuffer); INFO (vtilda);
ctype ctmp3 = vecProdConj (queues, vtilda, vtilda);
this->linComb.reduce (queues, vtilda, vars + &Vars::vtildaNorm);
ctype ctmp1 = (vars + &Vars::omega_old).read (queue) * (vars + &Vars::beta).read (queue);
ctype ctmp2 = (vars + &Vars::omega_new).read (queue) * alpha;
ctype theta = conj ((vars + &Vars::s_old).read (queue)) * ctmp1;
ctype eta = (vars + &Vars::c_old).read (queue) * (vars + &Vars::c_new).read (queue) * ctmp1 + conj ((vars + &Vars::s_new).read (queue)) * ctmp2;
ctype zetatilda = (vars + &Vars::c_new).read (queue) * ctmp2 - (vars + &Vars::c_old).read (queue) * (vars + &Vars::s_new).read (queue) * ctmp1;
(vars + &Vars::beta).write (queue, std::sqrt (ctmp3));
(vars + &Vars::mBeta).write (queue, -(vars + &Vars::beta).read (queue));
(vars + &Vars::omega_old).write (queue, (vars + &Vars::omega_new).read (queue));
(vars + &Vars::omega_new).write (queue, std::sqrt ((vars + &Vars::vtildaNorm).read (queue)) / abs ((vars + &Vars::beta).read (queue)));
ftype zetaabs = std::sqrt (norm (zetatilda) + (vars + &Vars::vtildaNorm).read (queue));
ftype rtmp3 = std::sqrt (norm (zetatilda));
ctype zeta;
if (rtmp3 < 1e-40f)
zeta = zetaabs;
else
zeta = zetaabs / rtmp3 * zetatilda;
(vars + &Vars::c_old).write (queue, (vars + &Vars::c_new).read (queue));
(vars + &Vars::c_new).write (queue, rtmp3 / zetaabs);
(vars + &Vars::s_old).write (queue, (vars + &Vars::s_new).read (queue));
(vars + &Vars::s_new).write (queue, (vars + &Vars::omega_new).read (queue) * ((vars + &Vars::beta).read (queue) / zeta));
(vars + &Vars::tau).write (queue, (vars + &Vars::c_new).read (queue) * (vars + &Vars::tautilda).read (queue));
(vars + &Vars::tautilda).write (queue, -(vars + &Vars::s_new).read (queue) * (vars + &Vars::tautilda).read (queue));
(vars + &Vars::zetaInv).write (queue, Const::one / zeta);
(vars + &Vars::mEtaZeta).write (queue, -eta / zeta);
(vars + &Vars::mThetaZeta).write (queue, -theta / zeta);
(vars + &Vars::betaInv).write (queue, Const::one / (vars + &Vars::beta).read (queue));
(vars + &Vars::normSNew).write (queue, norm ((vars + &Vars::s_new).read (queue)));
(vars + &Vars::cNewOmegaNewTautilda).write (queue, ((vars + &Vars::c_new).read (queue) / (vars + &Vars::omega_new).read (queue)) * (vars + &Vars::tautilda).read (queue));
INFO (vars + &Vars::zetaInv); INFO (vars + &Vars::mEtaZeta); INFO (vars + &Vars::mThetaZeta); INFO (vars + &Vars::betaInv); INFO (vars + &Vars::normSNew); INFO (vars + &Vars::cNewOmegaNewTautilda);
if (nr == 0) {
this->linComb.linComb (queues, v, vars + &Vars::zetaInv, p_new);
} else {
if (nr == 1)
this->linComb.linComb (queues, p_new, vars + &Vars::mEtaZeta, v, vars + &Vars::zetaInv, p_old);
else
this->linComb.linComb (queues, p_old, vars + &Vars::mThetaZeta, p_new, vars + &Vars::mEtaZeta, v, vars + &Vars::zetaInv, p_old);
swap (p_old, p_new);
}
this->linComb.linComb (queues, p_new, vars + &Vars::tau, xvec, xvec);
this->linComb.linComb (queues, vtilda, vars + &Vars::betaInv, vtilda);
swap (v, vtilda);
this->linComb.linComb (queues, rvec, vars + &Vars::normSNew, v, vars + &Vars::cNewOmegaNewTautilda, rvec);
INFO (p_new); INFO (p_old); INFO (xvec); INFO (vtilda); INFO (v); INFO (rvec);
this->linComb.reduce (queues, rvec, vars + &Vars::rvecNorm);
return (vars + &Vars::rvecNorm).read (queue);
}
void drive_operation()
{
// Uint64 tests
CQLValue a1(Uint64(10));
CQLValue a2(Uint64(15));
CQLValue a3(Uint64(25));
CQLValue a4(Uint64(30));
CQLValue a5(Uint64(150));
PEGASUS_TEST_ASSERT(a1 != a2);
PEGASUS_TEST_ASSERT(a5 == a5);
PEGASUS_TEST_ASSERT(a1 < a2);
PEGASUS_TEST_ASSERT(a2 >= a1);
PEGASUS_TEST_ASSERT(a1 <= a2);
PEGASUS_TEST_ASSERT(a2 > a1);
// Sint64 tests
CQLValue b1(Sint64(10));
CQLValue b2(Sint64(15));
CQLValue b3(Sint64(25));
CQLValue b4(Sint64(30));
CQLValue b5(Sint64(150));
PEGASUS_TEST_ASSERT(b1 != b2);
PEGASUS_TEST_ASSERT(b5 == b5);
PEGASUS_TEST_ASSERT(b1 < b2);
PEGASUS_TEST_ASSERT(b2 >= b1);
PEGASUS_TEST_ASSERT(b1 <= b2);
PEGASUS_TEST_ASSERT(b2 > b1);
// Real64 tests
CQLValue c1(Real64(10.00));
CQLValue c2(Real64(15.00));
CQLValue c3(Real64(25.00));
CQLValue c4(Real64(30.00));
CQLValue c5(Real64(150.00));
PEGASUS_TEST_ASSERT(c1 != c2);
PEGASUS_TEST_ASSERT(c5 == c5);
PEGASUS_TEST_ASSERT(c1 < c2);
PEGASUS_TEST_ASSERT(c2 >= c1);
PEGASUS_TEST_ASSERT(c1 <= c2);
PEGASUS_TEST_ASSERT(c2 > c1);
// Misc
PEGASUS_TEST_ASSERT(a1 == b1);
PEGASUS_TEST_ASSERT(a1 == c1);
PEGASUS_TEST_ASSERT(b1 == a1);
PEGASUS_TEST_ASSERT(b1 == c1);
PEGASUS_TEST_ASSERT(c1 == a1);
PEGASUS_TEST_ASSERT(c1 == b1);
PEGASUS_TEST_ASSERT(a2 != b1);
PEGASUS_TEST_ASSERT(a2 != c1);
PEGASUS_TEST_ASSERT(b2 != a1);
PEGASUS_TEST_ASSERT(b2 != c1);
PEGASUS_TEST_ASSERT(c2 != a1);
PEGASUS_TEST_ASSERT(c2 != b1);
PEGASUS_TEST_ASSERT(a2 >= b1);
PEGASUS_TEST_ASSERT(a2 >= c1);
PEGASUS_TEST_ASSERT(b2 >= a1);
PEGASUS_TEST_ASSERT(b2 >= c1);
PEGASUS_TEST_ASSERT(c2 >= a1);
PEGASUS_TEST_ASSERT(c2 >= b1);
PEGASUS_TEST_ASSERT(a2 <= b3);
PEGASUS_TEST_ASSERT(a2 <= c3);
PEGASUS_TEST_ASSERT(b2 <= a3);
PEGASUS_TEST_ASSERT(b2 <= c3);
PEGASUS_TEST_ASSERT(c2 <= a3);
PEGASUS_TEST_ASSERT(c2 <= b3);
PEGASUS_TEST_ASSERT(a2 > b1);
PEGASUS_TEST_ASSERT(a2 > c1);
PEGASUS_TEST_ASSERT(b2 > a1);
PEGASUS_TEST_ASSERT(b2 > c1);
PEGASUS_TEST_ASSERT(c2 > a1);
PEGASUS_TEST_ASSERT(c2 > b1);
PEGASUS_TEST_ASSERT(a2 < b3);
PEGASUS_TEST_ASSERT(a2 < c3);
PEGASUS_TEST_ASSERT(b2 < a3);
PEGASUS_TEST_ASSERT(b2 < c3);
PEGASUS_TEST_ASSERT(c2 < a3);
PEGASUS_TEST_ASSERT(c2 < b3);
//Overflow testing
CQLValue real1(Real64(0.00000001));
CQLValue sint1(Sint64(-1));
CQLValue uint1(Sint64(1));
CQLValue uint2(Uint64(0));
PEGASUS_TEST_ASSERT(uint1 > sint1);
PEGASUS_TEST_ASSERT(real1 > sint1);
PEGASUS_TEST_ASSERT(uint2 > sint1);
PEGASUS_TEST_ASSERT(real1 > uint2);
CQLValue real2(Real64(25.00000000000001));
CQLValue real3(Real64(24.99999999999999));
CQLValue sint2(Sint64(25));
CQLValue uint3(Uint64(25));
PEGASUS_TEST_ASSERT(real2 > real3);
PEGASUS_TEST_ASSERT(real2 > sint2);
PEGASUS_TEST_ASSERT(real2 > uint3);
PEGASUS_TEST_ASSERT(real3 < sint2);
PEGASUS_TEST_ASSERT(real3 < uint3);
// String tests
CQLValue d1(String("HELLO"));
CQLValue d2(String("HEL"));
CQLValue d3(String("LO"));
CQLValue d4(String("AHELLO"));
CQLValue d5(String("ZHELLO"));
PEGASUS_TEST_ASSERT(d1 == d2 + d3);
PEGASUS_TEST_ASSERT(d1 != d2 + d4);
PEGASUS_TEST_ASSERT(d1 <= d5);
PEGASUS_TEST_ASSERT(d1 < d5);
PEGASUS_TEST_ASSERT(d1 >= d4);
PEGASUS_TEST_ASSERT(d1 > d4);
String str1("0x10");
String str2("10");
String str3("10B");
String str4("10.10");
CQLValue e1( str1, CQLValue::Hex);
CQLValue e2( str2, CQLValue::Decimal);
CQLValue e3( str3, CQLValue::Binary);
CQLValue e4( str4, CQLValue::Real);
CQLValue e5(Uint64(16));
CQLValue e6(Uint64(10));
CQLValue e7(Uint64(2));
CQLValue e8(Real64(10.10));
PEGASUS_TEST_ASSERT(e1 == e5);
PEGASUS_TEST_ASSERT(e2 == e6);
PEGASUS_TEST_ASSERT(e3 == e7);
PEGASUS_TEST_ASSERT(e4 == e8);
Array<Uint64> array1;
array1.append(1);
array1.append(2);
array1.append(3);
array1.append(4);
array1.append(5);
array1.append(6);
array1.append(7);
array1.append(8);
array1.append(9);
array1.append(10);
Array<Sint64> array2;
array2.append(1);
array2.append(2);
array2.append(3);
array2.append(4);
array2.append(5);
array2.append(6);
array2.append(7);
array2.append(8);
array2.append(9);
array2.append(10);
array2.append(3);
Array<Real64> array3;
array3.append(1.00);
array3.append(2.00);
array3.append(3.00);
array3.append(9.00);
array3.append(10.00);
array3.append(3.00);
array3.append(4.00);
array3.append(5.00);
array3.append(6.00);
array3.append(7.00);
array3.append(8.00);
Array<Uint64> array4;
array4.append(1);
array4.append(23);
array4.append(3);
array4.append(4);
array4.append(5);
array4.append(6);
array4.append(7);
array4.append(88);
array4.append(9);
array4.append(10);
Array<Sint64> array5;
array5.append(-1);
array5.append(2);
array5.append(3);
array5.append(4);
array5.append(5);
array5.append(-6);
array5.append(7);
array5.append(8);
array5.append(9);
array5.append(10);
array5.append(-3);
Array<Real64> array6;
array6.append(1.23);
array6.append(2.00);
array6.append(3.00);
array6.append(9.00);
array6.append(10.00);
array6.append(3.00);
array6.append(4.14);
array6.append(5.00);
array6.append(6.00);
array6.append(7.00);
array6.append(8.00);
CIMValue cv1(array1);
CIMValue cv2(array2);
CIMValue cv3(array3);
CIMValue cv4(array4);
CIMValue cv5(array5);
CIMValue cv6(array6);
CQLValue vr1(cv1);
CQLValue vr2(cv1);
CQLValue vr3(cv2);
CQLValue vr4(cv3);
CQLValue vr5(cv4);
CQLValue vr6(cv5);
CQLValue vr7(cv6);
PEGASUS_TEST_ASSERT(vr1 == vr2);
PEGASUS_TEST_ASSERT(vr1 == vr3);
PEGASUS_TEST_ASSERT(vr1 == vr4);
PEGASUS_TEST_ASSERT(vr4 == vr3);
PEGASUS_TEST_ASSERT(vr1 != vr5);
PEGASUS_TEST_ASSERT(vr3 != vr6);
PEGASUS_TEST_ASSERT(vr4 != vr7);
const CIMName _cimName(String("CIM_OperatingSystem"));
CIMInstance _i1(_cimName);
CIMProperty _p1(CIMName("Description"),CIMValue(String("Dave Rules")));
CIMProperty _p2(CIMName("EnabledState"),CIMValue(Uint16(2)));
CIMProperty _p3(CIMName("CurrentTimeZone"),CIMValue(Sint16(-600)));
CIMProperty _p4(CIMName("TimeOfLastStateChange"),
CIMValue(CIMDateTime(String("20040811105625.000000-360"))));
_i1.addProperty(_p1);
_i1.addProperty(_p2);
_i1.addProperty(_p3);
_i1.addProperty(_p4);
CIMInstance _i2(_cimName);
CIMProperty _p5(CIMName("Description"),
CIMValue(String("Dave Rules Everything")));
CIMProperty _p6(CIMName("EnabledState"),CIMValue(Uint16(2)));
CIMProperty _p7(CIMName("CurrentTimeZone"),CIMValue(Sint16(-600)));
CIMProperty _p8(CIMName("TimeOfLastStateChange"),
CIMValue(CIMDateTime(String("20040811105625.000000-360"))));
_i2.addProperty(_p5);
_i2.addProperty(_p6);
_i2.addProperty(_p7);
_i2.addProperty(_p8);
CQLValue cql1(_i1);
CQLValue cql2(_i1);
CQLValue cql3(_i2);
CQLValue cql4(_i2);
//PEGASUS_TEST_ASSERT(cql1 == cql1);
return;
}
void drive_resolve_specialChars()
{
const char* env = getenv("PEGASUS_HOME");
String repositoryDir(env);
repositoryDir.append("/repository");
//String repositoryDir("c:/pegasus-cvs/pegasus/repository");
CIMNamespaceName _ns("root/cimv2");
CIMRepository *_rep = new CIMRepository(repositoryDir);
RepositoryQueryContext _query(_ns, _rep);
RepositoryQueryContext _query1(_ns, _rep);
try {
const CQLIdentifier _Id1(String("CIM_OperatingSystem"));
_query.insertClassPath(_Id1);
const CIMName _cimName(String("CIM_OperatingSystem"));
CIMInstance _i1(_cimName);
CIMProperty _p1(CIMName("OSType"),CIMValue(Uint16(11)));
CIMProperty _p2(CIMName("Status"),CIMValue(String("Degraded")));
Array<Uint16> array16;
array16.append(Uint16(0));
array16.append(Uint16(1));
array16.append(Uint16(2));
array16.append(Uint16(3));
CIMProperty _p3(CIMName("OperationalStatus"),CIMValue(array16));
_i1.addProperty(_p1);
_i1.addProperty(_p2);
_i1.addProperty(_p3);
CQLChainedIdentifier ci1(String("CIM_OperatingSystem.OSType#OS400"));
CQLChainedIdentifier ci2(String("CIM_OperatingSystem.OSType#LINUX"));
CQLChainedIdentifier ci3(String("CIM_OperatingSystem.Status#Degraded"));
CQLChainedIdentifier ci5(String("CIM_OperatingSystem.Status#BOGUS"));
CQLChainedIdentifier ci6(
String("CIM_OperatingSystem.CIM_OperatingSystem::"
"OperationalStatus[2]"));
CQLValue a1(ci1);
CQLValue a2(ci2);
CQLValue a3(ci3);
CQLValue a5(ci5);
CQLValue a6(ci6);
a1.resolve(_i1, _query);
a2.resolve(_i1, _query);
a6.resolve(_i1, _query);
try
{
a3.resolve(_i1, _query);
PEGASUS_TEST_ASSERT(0);
}
catch(...)
{
PEGASUS_TEST_ASSERT(1);
}
try
{
a5.resolve(_i1, _query);
PEGASUS_TEST_ASSERT(0);
}
catch(...)
{
PEGASUS_TEST_ASSERT(1);
}
PEGASUS_TEST_ASSERT(a1 == CQLValue(Uint64(11)));
PEGASUS_TEST_ASSERT(a2 == CQLValue(Uint64(36)));
PEGASUS_TEST_ASSERT(a6 == CQLValue(Uint64(2)));
}
catch(Exception & e)
{
cout << e.getMessage() << endl;
PEGASUS_TEST_ASSERT(0);
}
delete _rep;
return;
}
void drive_resolve_primitive()
{
const char* env = getenv("PEGASUS_HOME");
String repositoryDir(env);
repositoryDir.append("/repository");
//String repositoryDir("c:/pegasus-cvs/pegasus/repository");
CIMNamespaceName _ns("root/cimv2");
CIMRepository *_rep = new CIMRepository(repositoryDir);
RepositoryQueryContext _query(_ns, _rep);
RepositoryQueryContext _query1(_ns, _rep);
try {
const CQLIdentifier _Id1(String("CIM_OperatingSystem"));
_query.insertClassPath(_Id1);
const CIMName _cimName(String("CIM_OperatingSystem"));
CIMInstance _i1(_cimName);
CIMProperty _p1(CIMName("Description"),CIMValue(String("Dave Rules")));
CIMProperty _p2(CIMName("EnabledState"),CIMValue(Uint16(2)));
CIMProperty _p3(CIMName("CurrentTimeZone"),CIMValue(Sint16(-600)));
CIMProperty _p4(CIMName("TimeOfLastStateChange"),
CIMValue(CIMDateTime(String("20040811105625.000000-360"))));
_i1.addProperty(_p1);
_i1.addProperty(_p2);
_i1.addProperty(_p3);
_i1.addProperty(_p4);
CQLChainedIdentifier ci1(
String("CIM_OperatingSystem.CIM_OperatingSystem::Description"));
CQLChainedIdentifier
ci2(String("CIM_OperatingSystem.CIM_OperatingSystem::EnabledState"));
CQLChainedIdentifier ci3(
String("CIM_OperatingSystem.CIM_OperatingSystem::CurrentTimeZone"));
CQLChainedIdentifier ci4(
String("CIM_OperatingSystem.CIM_OperatingSystem::TimeOfLastStateChange"));
CQLChainedIdentifier
ci5(String(
"CIM_OperatingSystem.CIM_EnabledLogicalElement::TimeOfLastStateChange"));
CQLChainedIdentifier
ci7(String("CIM_OperatingSystem"));
CQLChainedIdentifier
ci9(String(
"CIM_EnabledLogicalElement.CIM_OperatingSystem::CSCreationClassName"));
CQLChainedIdentifier
ci10(String("CIM_OperatingSystem.CIM_OperatingSystem::Bubba"));
CQLValue a1(ci1);
CQLValue a2(ci2);
CQLValue a3(ci3);
CQLValue a4(ci4);
CQLValue a5(ci5);
CQLValue a7(ci7);
CQLValue a9(ci9);
CQLValue a10(ci10);
CQLValue a11(_query.getClass(CIMName("CIM_OperatingSystem")));
a1.resolve(_i1, _query);
a2.resolve(_i1, _query);
a3.resolve(_i1, _query);
a4.resolve(_i1, _query);
a5.resolve(_i1, _query);
a7.resolve(_i1, _query);
a10.resolve(_i1, _query1);
a9.resolve(_i1, _query);
PEGASUS_TEST_ASSERT(a1 == CQLValue(String("Dave Rules")));
PEGASUS_TEST_ASSERT(a2 == CQLValue(Uint64(2)));
PEGASUS_TEST_ASSERT(a3 == CQLValue(Sint64(-600)));
PEGASUS_TEST_ASSERT(a4 == CQLValue(
CIMDateTime(String("20040811105625.000000-360"))));
PEGASUS_TEST_ASSERT(a5 == CQLValue(
CIMDateTime(String("20040811105625.000000-360"))));
//PEGASUS_TEST_ASSERT(a7 == CQLValue(_i1));
PEGASUS_TEST_ASSERT(a9.isNull());
PEGASUS_TEST_ASSERT(a10.isNull());
}
catch(Exception & e)
{
cout << e.getMessage() << endl;
PEGASUS_TEST_ASSERT(0);
}
delete _rep;
return;
}
bool urdf_traverser::helpers::getCommonParentPath(const std::string& p1, const std::string& p2, std::string& result)
{
if (p1.empty() || p2.empty())
{
ROS_ERROR("Both p1 and p2 have to be set in getCommonParentPath()");
return false;
}
boost::filesystem::path __p1(p1);
boost::filesystem::path __p2(p2);
bool correctAbsolute = __p1.is_relative() || __p2.is_relative();
boost::filesystem::path _p1(boost::filesystem::absolute(__p1));
boost::filesystem::path _p2(boost::filesystem::absolute(__p2));
boost::filesystem::path buildPath;
boost::filesystem::path::iterator it1(_p1.begin());
boost::filesystem::path::iterator it1_end(_p1.end());
boost::filesystem::path::iterator it2(_p2.begin());
boost::filesystem::path::iterator it2_end(_p2.end());
int p1Len = numDirectories(p1);
int p2Len = numDirectories(p2);
// ROS_INFO_STREAM("p1: "<<p1<<", p2: "<<p2);
// ROS_INFO_STREAM("p1: "<<p1Len<<", p2: "<<p2Len);
if (p2Len > p1Len)
{
//swap around paths
boost::filesystem::path::iterator tmp(it2);
it2 = it1;
it1 = tmp;
tmp = it2_end;
it2_end = it1_end;
it1_end = tmp;
}
--it1_end; // make sure the iteration goes only until the previous-last
// entry, because the last entry is either '.' or a filename
for (; it1 != it1_end; ++it1, ++it2)
{
// ROS_INFO_STREAM("Comp "<<it1->string()<<", 2 "<<it2->string());
if ((it2 == it2_end)
|| (*it1 != *it2))
{
break;
}
// append the directory
buildPath /= *it1;
// std::cout << buildPath.string() << std::endl;
}
if (!buildPath.empty())
{
result = buildPath.string();
// make sure notation ends with separator.
// Last element *will* be directory as no files
// have been added in the loop.
enforceDirectory(result, false);
// If the current directory was used to build an absolute path, remove it again.
if (correctAbsolute)
{
std::string currDir = boost::filesystem::current_path().string();
urdf_traverser::helpers::enforceDirectory(currDir, false);
if (!urdf_traverser::helpers::getSubdirPath(currDir, result, result))
{
ROS_ERROR_STREAM("Could not remove temporarily created current directory for absolute path");
return false;
}
}
return true;
}
return false;
}
template <class F> boost::shared_ptr<std::vector<std::complex<F> > > IterativeSolverBase<F>::getPolVec (const std::vector<ctype>& einc, ftype eps, std::ostream& log, const std::vector<ctype>& start, Core::ProfilingDataPtr prof) {
this->inprodR_ = initGeneral (einc, log, start, prof);
log << "inprodR = " << this->inprodR_ << std::endl;
this->epsB = eps * eps / this->residScale;
this->prev_err = std::sqrt (this->residScale * this->inprodR_);
this->count = 0;
this->counter = 0;
this->inprodRInit = this->inprodR_;
this->needNewline = false;
this->initTime = Core::getCurrentTime ();
{
Core::ProfileHandle _p1 (prof, "itsolv");
init (log, prof);
while (inprodR_ >= epsB /* && count + 1 <= maxIter && counter <= maxResIncrease */) {
if (this->count >= maxIter) {
ABORT_MSG ("Too many iterations");
} else if (this->counter > this->maxResIncrease) {
ABORT_MSG ("Too many iterations w/o increase");
}
ftype inprodRplus1 = iteration (count, log, false, prof);
count++;
{ // LoopUpdate
if (inprodRplus1 <= inprodR_) {
inprodR_ = inprodRplus1;
counter = 0;
} else {
counter++;
}
ftype err = std::sqrt (residScale * inprodRplus1);
ftype progr = 1 - err / prev_err;
std::stringstream progStr;
ftype prog = (std::log (this->inprodR_) - std::log (this->inprodRInit)) / (std::log (epsB) - std::log (this->inprodRInit));
Core::TimeSpan now = Core::getCurrentTime ();
Core::TimeSpan remain = (now - this->initTime) * static_cast<double> ((1 - prog) / prog);
progStr << "RE_" << std::setfill ('0') << std::setw (5) << count << " = " << std::scientific << std::setfill (' ') << std::setw (12) << err << " ";
if (counter == 0)
progStr << "+ ";
else if (progr > 0)
progStr << "-+";
else
progStr << "- ";
progStr << " [" << std::fixed << std::setprecision (2) << std::setw (6) << prog * 100 << "%] [" << std::setfill (' ') << std::setw (12) << remain.toString () << "]";
if (this->needNewline)
Core::OStream::getStderr () << "\n";
Core::OStream::getStderr () << progStr.str ();
/*
this->needNewline = count <= 1
|| (count < 100 && count % 10 == 0)
|| (count <= 1000 && count % 100 == 0);
*/
this->needNewline = false;
Core::OStream::getStderr () << "\r" << std::flush;
log << progStr.str () << std::endl;
prev_err = err;
}
}
Core::OStream::getStderr () << std::endl;
}
return getResult (log, prof);
}
