bool TestTransformerExpr::TestDynamicVariable() {
VT("<?php $a = $$a;",
"Variant gv_a;\n"
"\n"
"gv_a = variables->get(toString(gv_a));\n");
return true;
VT("<?php $a = ${$a + $b};",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"gv_a = variables->get(toString(gv_a + gv_b));\n");
VT("<?php $a = $$a;",
"Variant gv_a;\n"
"\n"
"gv_a = variables->get(toString(gv_a));\n");
VT("<?php $a = ${$a};",
"Variant gv_a;\n"
"\n"
"gv_a = variables->get(toString(gv_a));\n");
VT("<?php $a = $$$a;",
"Variant gv_a;\n"
"\n"
"gv_a = variables->get(toString(variables->get(toString(gv_a))));\n");
return true;
}
bool TestTransformerExpr::TestStaticMemberExpression() {
VT("<?php $a = Test::a;",
"Variant gv_a;\n"
"\n"
"gv_a = throw_fatal(\"unknown class constant test::a\");\n");
VT("<?php class Test { static $a; } $a = Test::a;",
"Variant gv_a;\n"
"\n"
"class c_test : public ObjectData {\n"
" void c_test::init();\n"
" public: static Variant s_a;\n"
"};\n"
"c_test::c_test() {\n"
"}\n"
"void c_test::init() {\n"
"}\n"
"Variant c_test::s_a;\n"
"gv_a = throw_fatal(\"unknown class constant test::a\");\n");
VT("<?php class Test { static $a; } $a = Test::$a;",
"Variant gv_a;\n"
"\n"
"class c_test : public ObjectData {\n"
" void c_test::init();\n"
" public: static Variant s_a;\n"
"};\n"
"c_test::c_test() {\n"
"}\n"
"void c_test::init() {\n"
"}\n"
"Variant c_test::s_a;\n"
"gv_a = c_test::s_a;\n");
return true;
}
bool TestTransformerExpr::TestClassConstantExpression() {
VT("<?php class A { const b = 2;} function a() { static $a = A::b;}",
"extern const int64 q_a_b;\n"
"void f_a();\n"
"class c_a : public ObjectData {\n"
" void c_a::init();\n"
"};\n"
"const int64 q_a_b = 2;\n"
"c_a::c_a() {\n"
"}\n"
"void c_a::init() {\n"
"}\n"
"void f_a() {\n"
" static bool inited_a = false; static int64 sv_a;\n"
" \n"
" if (!inited_a) {\n"
" sv_a = q_a_b;\n"
" inited_a = true;\n"
" }\n"
"}\n");
VT("<?php function a() { static $a = A::b;}",
"void f_a();\n"
"void f_a() {\n"
" static bool inited_a = false; static Variant sv_a;\n"
" \n"
" if (!inited_a) {\n"
" sv_a = throw_fatal(\"unknown class constant a::b\");\n"
" inited_a = true;\n"
" }\n"
"}\n");
return true;
}
bool TestTransformerExpr::TestConstant() {
VT("<?php class a { const A = 1;}",
"extern const int64 q_a_A;\n"
"class c_a : public ObjectData {\n"
" void c_a::init();\n"
"};\n"
"const int64 q_a_A = 1;\n"
"c_a::c_a() {\n"
"}\n"
"void c_a::init() {\n"
"}\n"
);
VT("<?php class a { const A=1,B=2;}",
"extern const int64 q_a_A;\n"
"extern const int64 q_a_B;\n"
"class c_a : public ObjectData {\n"
" void c_a::init();\n"
"};\n"
"const int64 q_a_A = 1;\n"
"const int64 q_a_B = 2;\n"
"c_a::c_a() {\n"
"}\n"
"void c_a::init() {\n"
"}\n"
);
return true;
}
bool TestTransformerExpr::TestArrayElementExpression() {
VT("<?php $a = $b[$a + $b];",
"Variant gv_b;\n"
"Variant gv_a;\n"
"\n"
"gv_a = ((Variant)gv_b.rvalAt(gv_a + gv_b));\n");
VT("<?php $a = $b[];",
"Variant gv_b;\n"
"Variant gv_a;\n"
"\n"
"gv_a = ((Variant)toArray(gv_b).lvalAt());\n");
return true;
}
bool TestTransformerExpr::TestListAssignment() {
VT("<?php list() = 1;",
"list_assign(toArray(1), (ListAssignmentElement *)NULL);\n");
VT("<?php list(,) = 1;",
"list_assign(toArray(1), (ListAssignmentElement *)NULL);\n");
VT("<?php list($a,) = 1;",
"Variant gv_a;\n"
"\n"
"list_assign(toArray(1), new ListAssignmentElement(gv_a, 0, -1), (ListAssignmentElement *)NULL);\n");
VT("<?php list(,$b) = 1;",
"Variant gv_b;\n"
"\n"
"list_assign(toArray(1), new ListAssignmentElement(gv_b, 1, -1), (ListAssignmentElement *)NULL);\n");
VT("<?php list($b) = 1;",
"Variant gv_b;\n"
"\n"
"list_assign(toArray(1), new ListAssignmentElement(gv_b, 0, -1), (ListAssignmentElement *)NULL);\n");
VT("<?php list($a,$b) = 1;",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"list_assign(toArray(1), new ListAssignmentElement(gv_a, 0, -1), new ListAssignmentElement(gv_b, 1, -1), (ListAssignmentElement *)NULL);\n");
VT("<?php list($a,list($c),$b) = 1;",
"Variant gv_a;\n"
"Variant gv_c;\n"
"Variant gv_b;\n"
"\n"
"list_assign(toArray(1), new ListAssignmentElement(gv_a, 0, -1), new ListAssignmentElement(gv_c, 1, 0, -1), new ListAssignmentElement(gv_b, 2, -1), (ListAssignmentElement *)NULL);\n");
VT("<?php list($a,list(),$b) = 1;",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"list_assign(toArray(1), new ListAssignmentElement(gv_a, 0, -1), new ListAssignmentElement(gv_b, 2, -1), (ListAssignmentElement *)NULL);\n");
return true;
}
void getEdgeNeighborsList(const Mesh& m, uintA& EV, uintA& Et, intA& ET) {
intA Vt, VT;
getVertexNeighorsList(m, Vt, VT);
uint A=0, B=0, t, tt, i, r, k;
//build edge list
EV.resize(m.T.d0*3, 2); EV=0; //edge vert neighbors
ET.resize(m.T.d0*3, 10); ET=-1; //edge tri neighbors
Et.resize(m.T.d0*3); Et.setZero(); //#edge tri neighbors
boolA done(m.T.d0); done=false;
for(t=0, k=0; t<m.T.d0; t++) {
for(r=0; r<3; r++) {
if(r==0) { A=m.T(t, 0); B=m.T(t, 1); }
if(r==1) { A=m.T(t, 1); B=m.T(t, 2); }
if(r==2) { A=m.T(t, 2); B=m.T(t, 0); }
//has AB already been taken care of?
bool yes=false;
for(i=0; i<(uint)Vt(A); i++) {
tt=VT(A, i);
if(m.T(tt, 0)==B || m.T(tt, 1)==B || m.T(tt, 2)==B) {
if(done(tt)) yes=true;
}
}
if(yes) continue;
//if not, then do it
EV(k, 0)=A;
EV(k, 1)=B;
for(i=0; i<(uint)Vt(A); i++) {
tt=VT(A, i);
if(m.T(tt, 0)==B || m.T(tt, 1)==B || m.T(tt, 2)==B) {
ET(k, Et(k))=tt;
Et(k)++;
}
}
k++;
}
done(t)=true;
}
EV.resizeCopy(k, 2);
ET.resizeCopy(k, 10);
Et.resizeCopy(k);
cout <<"\n#edges=" <<k
<<"\nedge=\n" <<EV
<<"\n@neighs=\n" <<Et
<<"\nneighs=\n" <<ET <<endl;
}
void getTriNeighborsList(const Mesh& m, uintA& Tt, intA& TT) {
intA Vt, VT;
getVertexNeighorsList(m, Vt, VT);
uint A=0, B=0, t, tt, r, i;
Tt.resize(m.T.d0, 3); Tt.setZero();
TT.resize(m.T.d0, 3, 100); TT=-1;
for(t=0; t<m.T.d0; t++) {
for(r=0; r<3; r++) {
if(r==0) { A=m.T(t, 0); B=m.T(t, 1); }
if(r==1) { A=m.T(t, 1); B=m.T(t, 2); }
if(r==2) { A=m.T(t, 2); B=m.T(t, 0); }
for(i=0; i<(uint)Vt(A); i++) {
tt=VT(A, i);
if(tt!=t && (m.T(tt, 0)==B || m.T(tt, 1)==B || m.T(tt, 2)==B)) {
TT(t, r, Tt(t, r))=tt;
Tt(t, r)++;
}
}
}
}
//cout <<Tt <<TT <<endl;
}
bool TestTransformerExpr::TestAssignmentExpression() {
VT("<?php $a = 1;",
"Variant gv_a;\n"
"\n"
"gv_a = 1;\n");
VT("<?php $a = &$b;",
"Variant gv_b;\n"
"Variant gv_a;\n"
"\n"
"gv_a = ref(gv_b);\n");
VT("<?php class Test {} $a = &new Test();",
"Variant gv_a;\n"
"\n"
"class c_test : public ObjectData {\n"
" void c_test::init();\n"
"};\n"
"c_test::c_test() {\n"
"}\n"
"void c_test::init() {\n"
"}\n"
"gv_a = sp_test(sp_test(NEW(c_test)())->create());\n");
VT("<?php $a = &new $b();",
"Variant gv_b;\n"
"Variant gv_a;\n"
"\n"
"gv_a = create_object(toString(gv_b), Array());\n");
VT("<?php $a = &new $$b();",
"Variant gv_b;\n"
"Variant gv_a;\n"
"\n"
"gv_a = create_object((toString(variables->get(toString(gv_b)))), Array());\n");
VT("<?php class Test { static $b;} $a = &new Test::$b();",
"Variant gv_a;\n"
"\n"
"class c_test : public ObjectData {\n"
" void c_test::init();\n"
" public: static Variant s_b;\n"
"};\n"
"c_test::c_test() {\n"
"}\n"
"void c_test::init() {\n"
"}\n"
"Variant c_test::s_b;\n"
"gv_a = create_object((toString(c_test::s_b)), Array());\n");
VT("<?php $a = &new $b->c();",
"Variant gv_b;\n"
"Variant gv_a;\n"
"\n"
"gv_a = create_object((toString(toObject(gv_b).o_get(\"c\", 0x000000000002B608LL))), Array());\n");
VT("<?php $a = &new $b->c->d();",
"Variant gv_b;\n"
"Variant gv_a;\n"
"\n"
"gv_a = create_object((toString(toObject(toObject(gv_b).o_get(\"c\", 0x000000000002B608LL)).o_get(\"d\", 0x000000000002B609LL))), Array());\n");
return true;
}
bool TestTransformerExpr::TestStringOffsetExpression() {
VT("<?php $a = $b{$a + $b};",
"Variant gv_b;\n"
"Variant gv_a;\n"
"\n"
"gv_a = ((Variant)gv_b.rvalAt(gv_a + gv_b));\n");
return true;
}
bool TestTransformerExpr::TestQOpExpression() {
VT("<?php $a ? $b : $c;",
"Variant gv_a;\n"
"Variant gv_b;\n"
"Variant gv_c;\n"
"\n"
"toBoolean(gv_a) ? ((Variant)gv_b) : ((Variant)gv_c);\n");
return true;
}
bool TestTransformerExpr::TestDynamicFunctionCall() {
VT("<?php $test();",
"Variant gv_test;\n"
"\n"
"invoke(toString(gv_test), Array(), -1);\n");
VT("<?php class Test {} Test::$test();",
"Variant gv_test;\n"
"\n"
"class c_test : public ObjectData {\n"
" void c_test::init();\n"
"};\n"
"c_test::c_test() {\n"
"}\n"
"void c_test::init() {\n"
"}\n"
"c_test::os_invoke(toString(gv_test), Array(), -1);\n");
VT("<?php Test::$test();",
"Variant gv_test;\n"
"\n"
"throw_fatal(\"unknown class test\");\n");
return true;
}
Point Vertex::getNormal() const
{
List *vt = VT();
Node *n;
Triangle *t;
double pa;
Point tnor, ttn;
FOREACHVTTRIANGLE(vt, t, n)
{
pa = t->getAngle(this);
ttn = t->getNormal();
if (!ttn.isNull()) tnor = tnor+(ttn*pa);
}
bool TestTransformerExpr::TestScalarExpression() {
VT("<?php 12;", "12;\n"); // T_LNUMBER
VT("<?php 0xFF;", "0xFF;\n"); // T_LNUMBER
VT("<?php 1.2;", "1.2;\n"); // T_DNUMBER
VT("<?php \"A\";", "\"A\";\n"); // T_CONSTANT_ENCAPSED_STRING
VT("<?php 'A';", "\"A\";\n"); // T_CONSTANT_ENCAPSED_STRING
VT("<?php '\"';", "\"\\\"\";\n"); // T_CONSTANT_ENCAPSED_STRING
VT("<?php \"$a[0xFF]\";", // T_NUM_STRING
"Variant gv_a;\n"
"\n"
"toString(((Variant)gv_a.rvalAt(0xFF, 0x77CFA1EEF01BCA90LL)));\n");
VT("<?php A;", // T_STRING
"const String k_A = \"A\";\n"
"\n"
"k_A;\n");
VT("<?php \"${a}\";", // T_STRING_VARNAME
"Variant gv_a;\n"
"\n"
"toString(gv_a);\n");
return true;
}
bool fullMatrix<double>::svd(fullMatrix<double> &V, fullVector<double> &S)
{
fullMatrix<double> VT(V.size2(), V.size1());
int M = size1(), N = size2(), LDA = size1(), LDVT = VT.size1(), info;
int lwork = std::max(3 * std::min(M, N) + std::max(M, N), 5 * std::min(M, N));
fullVector<double> WORK(lwork);
F77NAME(dgesvd)("O", "A", &M, &N, _data, &LDA, S._data, _data, &LDA,
VT._data, &LDVT, WORK._data, &lwork, &info);
V = VT.transpose();
if(info == 0) return true;
if(info > 0)
Msg::Error("SVD did not converge");
else
Msg::Error("Wrong %d-th argument in SVD decomposition", -info);
return false;
}
/*!
Evaluate PCR quality metric as described in 'Contact and Grasp
Robustness Measures: Analysis and Experiment' (1997) by
Prattichizzo et al. Care must be taken to pass the show=false
flag when calling from multiple threads as displayContactWrenches()
and drawObjectWrench() are not thread safe
*/
double
QualPCR::evaluatePCR(Grasp *g, const Matrix &wrench, double maxForce,
std::vector<int> states /*=empty*/, bool show /*=true*/)
{
//use the pre-set list of contacts. This includes contacts on the palm, but
//not contacts with other objects or obstacles
int numContacts = g->getNumContacts();
std::list<Contact*> contacts;
for (int i=0; i<numContacts; i++) contacts.push_back(g->getContact(i));
//if there are no contacts we are done
if (contacts.empty()) {
DBGA("No contacts");
return -1;
}
//check if G is full rank
Matrix H(g->contactModelMatrix(contacts.size(), states));
Matrix R(Contact::localToWorldWrenchBlockMatrix(contacts));
Matrix G(matrixMultiply(g->graspMapMatrix(R), H.transposed()));
if (G.rank() < 6) {
DBGA("G not full rank");
return -1;
}
//get only the joints on chains that make contact;
std::list<Joint*> joints = g->getJointsOnContactChains();
Matrix contactWrenches(6*contacts.size(), 1);
double dmin = g->findOptimalContactForces(wrench, maxForce, contactWrenches, joints, contacts, states);
if (dmin!=dmin) return -1;
Matrix GRK(g->KweightedGinverse(joints, contacts, states));
Matrix S(std::min(GRK.rows(), GRK.cols()), 1);
Matrix U(GRK.rows(), GRK.rows());
Matrix VT(GRK.cols(), GRK.cols());
GRK.SVD(S,U,VT);
Matrix GKGTInv(g->graspStiffness(joints, contacts));
/*if (show) {
displayContactWrenches(&contacts, contactWrenches);
drawObjectWrench(wrench.negative());
}
drawObjectMovement(matrixMultiply(GKGTInv, wrench));*/
return dmin/S.elem(0,0);
}
bool CSPrimPolygon::Write2XML(TiXmlElement &elem, bool parameterised)
{
CSPrimitives::Write2XML(elem,parameterised);
WriteTerm(Elevation,elem,"Elevation",parameterised);
elem.SetAttribute("NormDir",m_NormDir);
elem.SetAttribute("QtyVertices",(int)vCoords.size()/2);
for (size_t i=0;i<vCoords.size()/2;++i)
{
TiXmlElement VT("Vertex");
WriteTerm(vCoords.at(i*2),VT,"X1",parameterised);
WriteTerm(vCoords.at(i*2+1),VT,"X2",parameterised);
elem.InsertEndChild(VT);
}
return true;
}
void RigidBodyShape::EvaluateNonsingularity3D(std::vector<double>& s, std::vector<double>& coords)
{
long num_points(coords.size() / 3);
s.resize(3);
#ifndef OPEN3DMOTION_LINEAR_ALGEBRA_EIGEN
long three(3);
long lwork(256);
double work[256];
long info(0);
std::vector<double> U(9);
std::vector<double> VT(num_points*num_points);
// use lapack routine
// note coords must be column-major so first 3 elements correspond to first coord
dgesvd_(
"N", // don't actually need U
"N", // don't actually need VT
&three, // rows
&num_points, // cols
&coords[0], // input/output matrix
&three, // leading dimension of Acpy
&s[0], // singular values
&U[0], // left orthonormal matrix
&three, // leading dimension of left
&VT[0], // right orthonormal matrix
&num_points, // leading dimension of right
work, // workspace
&lwork, // size of workspace
&info); // returned error codes
#else
Eigen::Map< Eigen::Matrix<double, Eigen::Dynamic, 3, Eigen::RowMajor> >
_coords(&coords[0], (int)num_points, 3);
Eigen::Map< Eigen::Matrix<double, 3, 1> > _s(&s[0], 3, 1);
Eigen::JacobiSVD< Eigen::Matrix<double, Eigen::Dynamic, 3, Eigen::RowMajor> > svd(_coords);
_s = svd.singularValues();
#endif // OPEN3DMOTION_LINEAR_ALGEBRA_EIGEN
}
bool TestTransformerExpr::TestNewObjectExpression() {
VT("<?php class Test {} new Test;",
"class c_test : public ObjectData {\n"
" void c_test::init();\n"
"};\n"
"c_test::c_test() {\n"
"}\n"
"void c_test::init() {\n"
"}\n"
"sp_test(sp_test(NEW(c_test)())->create());\n");
VT("<?php new Test;",
"throw_fatal_object(\"unknown class test\", ((void*)NULL));\n");
VT("<?php new $b();",
"Variant gv_b;\n"
"\n"
"create_object(toString(gv_b), Array());\n");
VT("<?php new $b;",
"Variant gv_b;\n"
"\n"
"create_object(toString(gv_b), Array());\n");
VT("<?php class Test {} new Test($a);",
"Variant gv_a;\n"
"\n"
"class c_test : public ObjectData {\n"
" void c_test::init();\n"
"};\n"
"c_test::c_test() {\n"
"}\n"
"void c_test::init() {\n"
"}\n"
"throw_fatal_object(\"unknown class test\", ((void*)NULL));\n");
VT("<?php new $b($a);",
"Variant gv_b;\n"
"Variant gv_a;\n"
"\n"
"create_object(toString(gv_b), Array(NEW(ArrayElement)(ref(gv_a)), NULL));\n");
return true;
}
bool TestTransformerExpr::TestEncapsListExpression() {
VT("<?php print '\"';", "print(\"\\\"\");\n");
VT("<?php print '\\'\\\\\"';", "print(\"'\\\\\\\"\");\n");
VT("<?php print '$a$b';", "print(\"$a$b\");\n");
VT("<?php print \"$a$b\";",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"print(toString(gv_a) + toString(gv_b));\n");
VT("<?php print <<<EOM\n"
"$a$b\n"
"EOM;\n",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"print(toString(gv_a) + toString(gv_b) + toString(\"\\n\"));\n");
VT("<?php `$a$b`;",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"shell_exec(toString(gv_a) + toString(gv_b));\n");
return true;
}
.swap = swapfmt \
}
/* vertex-only */
#define V_(pipe, fmt, rbfmt, swapfmt) \
[PIPE_FORMAT_ ## pipe] = { \
.present = 1, \
.vtx = VFMT4_ ## fmt, \
.tex = ~0, \
.rb = RB4_ ## rbfmt, \
.swap = swapfmt \
}
static struct fd4_format formats[PIPE_FORMAT_COUNT] = {
/* 8-bit */
VT(R8_UNORM, 8_UNORM, NONE, WZYX),
V_(R8_SNORM, 8_SNORM, NONE, WZYX),
V_(R8_UINT, 8_UINT, NONE, WZYX),
V_(R8_SINT, 8_SINT, NONE, WZYX),
V_(R8_USCALED, 8_UINT, NONE, WZYX),
V_(R8_SSCALED, 8_UINT, NONE, WZYX),
_T(A8_UNORM, 8_UNORM, A8_UNORM, WZYX),
_T(L8_UNORM, 8_UNORM, NONE, WZYX),
_T(I8_UNORM, 8_UNORM, NONE, WZYX),
/* 16-bit */
V_(R16_UNORM, 16_UNORM, NONE, WZYX),
V_(R16_SNORM, 16_SNORM, NONE, WZYX),
V_(R16_UINT, 16_UINT, NONE, WZYX),
V_(R16_SINT, 16_SINT, NONE, WZYX),
bool TestTransformerExpr::TestParameterExpression() {
VT("<?php function a() {}",
"void f_a();\n"
"void f_a() {\n"
"}\n");
VT("<?php function a($a) {}",
"void f_a(CVarRef v_a);\n"
"void f_a(CVarRef v_a) {\n"
"}\n");
VT("<?php function a($a,$b) {}",
"void f_a(CVarRef v_a, CVarRef v_b);\n"
"void f_a(CVarRef v_a, CVarRef v_b) {\n"
"}\n");
VT("<?php function a(&$a) {}",
"void f_a(Variant v_a);\n"
"void f_a(Variant v_a) {\n"
"}\n");
VT("<?php function a(&$a,$b) {}",
"void f_a(Variant v_a, CVarRef v_b);\n"
"void f_a(Variant v_a, CVarRef v_b) {\n"
"}\n");
VT("<?php function a($a,&$b) {}",
"void f_a(CVarRef v_a, Variant v_b);\n"
"void f_a(CVarRef v_a, Variant v_b) {\n"
"}\n");
VT("<?php class TT {} function a(TT $a) {}",
"void f_a(sp_tt v_a);\n"
"class c_tt : public ObjectData {\n"
" void c_tt::init();\n"
"};\n"
"c_tt::c_tt() {\n"
"}\n"
"void c_tt::init() {\n"
"}\n"
"void f_a(sp_tt v_a) {\n"
"}\n");
VT("<?php function a(TT $a) {}",
"void f_a(CVarRef v_a);\n"
"void f_a(CVarRef v_a) {\n"
"}\n");
VT("<?php function a(array $a) {}",
"void f_a(CArrRef v_a);\n"
"void f_a(CArrRef v_a) {\n"
"}\n");
VT("<?php function a($a=1) {}",
"void f_a(int64 v_a = 1);\n"
"void f_a(int64 v_a /* = 1 */) {\n"
"}\n");
VT("<?php function a($a=1,$b) {}",
"void f_a(int64 v_a = 1, CVarRef v_b = null);\n"
"void f_a(int64 v_a /* = 1 */, CVarRef v_b /* = null */) {\n"
"}\n");
VT("<?php function a($a,$b=1) {}",
"void f_a(CVarRef v_a, int64 v_b = 1);\n"
"void f_a(CVarRef v_a, int64 v_b /* = 1 */) {\n"
"}\n");
VT("<?php function matrix($n) {"
" $sum = 0;"
" while ($n--) {"
" $sum += $n;"
" }"
"}",
"void f_matrix(Variant v_n);\n"
"void f_matrix(Variant v_n) {\n"
" Variant v_sum;\n"
" \n"
" v_sum = 0;\n"
" {\n"
" while (toBoolean(v_n--)) {\n"
" {\n"
" v_sum += v_n;\n"
" }\n"
" goto continue1; continue1:;\n"
" }\n"
" goto break1; break1:;\n"
" }\n"
"}\n");
VT("<?php function foo($a) {"
" $a[1]++;"
"}",
"void f_foo(Sequence v_a);\n"
"void f_foo(Sequence v_a) {\n"
" lval(v_a.lvalAt(1, 0x5BCA7C69B794F8CELL))++;\n"
"}\n");
VT("<?php function foo(&$a) {"
" $a[1]++;"
"}",
"void f_foo(Variant v_a);\n"
"void f_foo(Variant v_a) {\n"
" lval(v_a.lvalAt(1, 0x5BCA7C69B794F8CELL))++;\n"
"}\n");
return true;
}
bool TestTransformerExpr::TestObjectMethodExpression() {
VT("<?php class Test { public $c; } $b = new Test(); echo $b->c();",
"Variant gv_b;\n"
"\n"
"class c_test : public ObjectData {\n"
" void c_test::init();\n"
" public: Variant m_c;\n"
"};\n"
"c_test::c_test() {\n"
"}\n"
"void c_test::init() {\n"
"}\n"
"gv_b = sp_test(sp_test(NEW(c_test)())->create());\n"
"echo(toString(toObject(gv_b)->o_invoke(\"c\", Array(), 0x000000000002B608LL)));\n"
);
VT("<?php class Test { public function c() {} } "
"$b = new Test(); echo $b->c();",
"Variant gv_b;\n"
"\n"
"class c_test : public ObjectData {\n"
" void c_test::init();\n"
" public: void t_c();\n"
"};\n"
"c_test::c_test() {\n"
"}\n"
"void c_test::init() {\n"
"}\n"
"void c_test::t_c() {\n"
"}\n"
"gv_b = sp_test(sp_test(NEW(c_test)())->create());\n"
"echo((sp_test(gv_b)->t_c(), null));\n"
);
VT("<?php echo $b->c();",
"Variant gv_b;\n"
"\n"
"echo(toString(toObject(gv_b)->o_invoke(\"c\", Array(), 0x000000000002B608LL)));\n");
VT("<?php echo ${b}->c();",
"const String k_b = \"b\";\n"
"\n"
"echo(toString(toObject(variables->get(k_b))->o_invoke(\"c\", Array(), 0x000000000002B608LL)));\n"
);
VT("<?php echo ${$b}->c();",
"Variant gv_b;\n"
"\n"
"echo(toString(toObject(variables->get(toString(gv_b)))->o_invoke(\"c\", Array(), 0x000000000002B608LL)));\n");
VT("<?php echo $b[]->c();",
"Variant gv_b;\n"
"\n"
"echo(toString(toObject(((Variant)toArray(gv_b).lvalAt()))->o_invoke(\"c\", Array(), 0x000000000002B608LL)));\n");
VT("<?php $b{$a}[$c]{$d}($p1,$p2)->c{$e}($p3,$p4)->f[]($p5,$p6);",
"Variant gv_b;\n"
"Variant gv_a;\n"
"Variant gv_c;\n"
"Variant gv_d;\n"
"Variant gv_p1;\n"
"Variant gv_p2;\n"
"Variant gv_e;\n"
"Variant gv_p3;\n"
"Variant gv_p4;\n"
"Variant gv_p5;\n"
"Variant gv_p6;\n"
"\n"
"invoke((toString(((Variant)toArray(toObject(invoke((toString(((Variant)toObject(invoke((toString(((Variant)((Variant)((Variant)gv_b.rvalAt(gv_a)).rvalAt(gv_c)).rvalAt(gv_d)))), Array(NEW(ArrayElement)(ref(gv_p1)), NEW(ArrayElement)(ref(gv_p2)), NULL), -1)).o_get(\"c\", 0x000000000002B608LL).rvalAt(gv_e)))), Array(NEW(ArrayElement)(ref(gv_p3)), NEW(ArrayElement)(ref(gv_p4)), NULL), -1)).o_get(\"f\", 0x000000000002B60BLL)).lvalAt()))), Array(NEW(ArrayElement)(ref(gv_p5)), NEW(ArrayElement)(ref(gv_p6)), NULL), -1);\n");
return true;
}
bool TestTransformerExpr::TestArrayPairExpression() {
VT("<?php array();", "Array((ArrayElement*)NULL);\n");
VT("<?php array($a);",
"Variant gv_a;\n"
"\n"
"Array(NEW(ArrayElement)(gv_a), NULL);\n");
VT("<?php array($a, $b);",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"Array(NEW(ArrayElement)(gv_a), NEW(ArrayElement)(gv_b), NULL);\n");
VT("<?php array($a, $b,);",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"Array(NEW(ArrayElement)(gv_a), NEW(ArrayElement)(gv_b), NULL);\n");
VT("<?php array($a => $b);",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"Array(NEW(ArrayElement)(gv_a, gv_b), NULL);\n");
VT("<?php array($a => $b, $c => $d);",
"Variant gv_a;\n"
"Variant gv_b;\n"
"Variant gv_c;\n"
"Variant gv_d;\n"
"\n"
"Array(NEW(ArrayElement)(gv_a, gv_b), NEW(ArrayElement)(gv_c, gv_d), NULL);\n");
VT("<?php array($a => $b, $c => $d,);",
"Variant gv_a;\n"
"Variant gv_b;\n"
"Variant gv_c;\n"
"Variant gv_d;\n"
"\n"
"Array(NEW(ArrayElement)(gv_a, gv_b), NEW(ArrayElement)(gv_c, gv_d), NULL);\n");
VT("<?php array(&$a);",
"Variant gv_a;\n"
"\n"
"Array(NEW(ArrayElement)(ref(gv_a)), NULL);\n");
VT("<?php array(&$a, &$b);",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"Array(NEW(ArrayElement)(ref(gv_a)), NEW(ArrayElement)(ref(gv_b)), NULL);\n");
VT("<?php array($a => &$b);",
"Variant gv_a;\n"
"Variant gv_b;\n"
"\n"
"Array(NEW(ArrayElement)(gv_a, ref(gv_b)), NULL);\n");
VT("<?php array($a => &$b, $c => &$d);",
"Variant gv_a;\n"
"Variant gv_b;\n"
"Variant gv_c;\n"
"Variant gv_d;\n"
"\n"
"Array(NEW(ArrayElement)(gv_a, ref(gv_b)), NEW(ArrayElement)(gv_c, ref(gv_d)), NULL);\n");
VT("<?php function a() { static $a = array();}",
"void f_a();\n"
"void f_a() {\n"
" static bool inited_a = false; static Array sv_a;\n"
" \n"
" if (!inited_a) {\n"
" sv_a = Array((ArrayElement*)NULL);\n"
" inited_a = true;\n"
" }\n"
"}\n");
VT("<?php function a() { static $a = array(a);}",
"void f_a();\n"
"const String k_a = \"a\";\n"
"\n"
"void f_a() {\n"
" static bool inited_a = false; static Array sv_a;\n"
" \n"
" if (!inited_a) {\n"
" sv_a = Array(NEW(ArrayElement)(k_a), NULL);\n"
" inited_a = true;\n"
" }\n"
"}\n");
VT("<?php function a() { static $a = array(a, b);}",
"void f_a();\n"
"const String k_a = \"a\";\n"
"const String k_b = \"b\";\n"
"\n"
"void f_a() {\n"
" static bool inited_a = false; static Array sv_a;\n"
" \n"
" if (!inited_a) {\n"
" sv_a = Array(NEW(ArrayElement)(k_a), NEW(ArrayElement)(k_b), NULL);\n"
" inited_a = true;\n"
" }\n"
"}\n");
VT("<?php function a() { static $a = array(a, b,);}",
"void f_a();\n"
"const String k_a = \"a\";\n"
"const String k_b = \"b\";\n"
"\n"
"void f_a() {\n"
" static bool inited_a = false; static Array sv_a;\n"
" \n"
" if (!inited_a) {\n"
" sv_a = Array(NEW(ArrayElement)(k_a), NEW(ArrayElement)(k_b), NULL);\n"
" inited_a = true;\n"
" }\n"
"}\n");
VT("<?php function a() { static $a = array(a => b);}",
"void f_a();\n"
"const String k_a = \"a\";\n"
"const String k_b = \"b\";\n"
"\n"
"void f_a() {\n"
" static bool inited_a = false; static Array sv_a;\n"
" \n"
" if (!inited_a) {\n"
" sv_a = Array(NEW(ArrayElement)(k_a, k_b), NULL);\n"
" inited_a = true;\n"
" }\n"
"}\n");
VT("<?php function a() { static $a = array(a => b, c => d);}",
"void f_a();\n"
"const String k_a = \"a\";\n"
"const String k_b = \"b\";\n"
"const String k_c = \"c\";\n"
"const String k_d = \"d\";\n"
"\n"
"void f_a() {\n"
" static bool inited_a = false; static Array sv_a;\n"
" \n"
" if (!inited_a) {\n"
" sv_a = Array(NEW(ArrayElement)(k_a, k_b), NEW(ArrayElement)(k_c, k_d), NULL);\n"
" inited_a = true;\n"
" }\n"
"}\n");
VT("<?php function a() { static $a = array(a => b, c => d,);}",
"void f_a();\n"
"const String k_a = \"a\";\n"
"const String k_b = \"b\";\n"
"const String k_c = \"c\";\n"
"const String k_d = \"d\";\n"
"\n"
"void f_a() {\n"
" static bool inited_a = false; static Array sv_a;\n"
" \n"
" if (!inited_a) {\n"
" sv_a = Array(NEW(ArrayElement)(k_a, k_b), NEW(ArrayElement)(k_c, k_d), NULL);\n"
" inited_a = true;\n"
" }\n"
"}\n");
return true;
}
inline void
GolubReinschUpper_FLA
( DistMatrix<F>& A, DistMatrix<BASE(F),VR,STAR>& s, DistMatrix<F>& V )
{
#ifndef RELEASE
CallStackEntry entry("svd::GolubReinschUpper_FLA");
#endif
typedef BASE(F) Real;
const Int m = A.Height();
const Int n = A.Width();
const Int k = Min( m, n );
const Int offdiagonal = ( m>=n ? 1 : -1 );
const Grid& g = A.Grid();
// Bidiagonalize A
DistMatrix<F,STAR,STAR> tP(g), tQ(g);
Bidiag( A, tP, tQ );
// Grab copies of the diagonal and sub/super-diagonal of A
DistMatrix<Real,MD,STAR> d_MD_STAR(g), e_MD_STAR(g);
A.GetRealPartOfDiagonal( d_MD_STAR );
A.GetRealPartOfDiagonal( e_MD_STAR, offdiagonal );
// In order to use serial QR kernels, we need the full bidiagonal matrix
// on each process
DistMatrix<Real,STAR,STAR> d_STAR_STAR( d_MD_STAR ),
e_STAR_STAR( e_MD_STAR );
// Initialize U and VAdj to the appropriate identity matrices
DistMatrix<F,VC,STAR> U_VC_STAR(g), V_VC_STAR(g);
U_VC_STAR.AlignWith( A );
V_VC_STAR.AlignWith( V );
Identity( U_VC_STAR, m, k );
Identity( V_VC_STAR, n, k );
FlaSVD
( k, U_VC_STAR.LocalHeight(), V_VC_STAR.LocalHeight(),
d_STAR_STAR.Buffer(), e_STAR_STAR.Buffer(),
U_VC_STAR.Buffer(), U_VC_STAR.LDim(),
V_VC_STAR.Buffer(), V_VC_STAR.LDim() );
// Make a copy of A (for the Householder vectors) and pull the necessary
// portions of U and V into a standard matrix dist.
DistMatrix<F> B( A );
if( m >= n )
{
DistMatrix<F> AT(g), AB(g);
DistMatrix<F,VC,STAR> UT_VC_STAR(g), UB_VC_STAR(g);
PartitionDown( A, AT, AB, n );
PartitionDown( U_VC_STAR, UT_VC_STAR, UB_VC_STAR, n );
AT = UT_VC_STAR;
MakeZeros( AB );
V = V_VC_STAR;
}
else
{
DistMatrix<F> VT(g), VB(g);
DistMatrix<F,VC,STAR> VT_VC_STAR(g), VB_VC_STAR(g);
PartitionDown( V, VT, VB, m );
PartitionDown( V_VC_STAR, VT_VC_STAR, VB_VC_STAR, m );
VT = VT_VC_STAR;
MakeZeros( VB );
}
// Backtransform U and V
bidiag::ApplyU( LEFT, NORMAL, B, tQ, A );
bidiag::ApplyV( LEFT, NORMAL, B, tP, V );
// Copy out the appropriate subset of the singular values
s = d_STAR_STAR;
}
bool CFitProblem::calculateStatistics(const C_FLOAT64 & factor,
const C_FLOAT64 & resolution)
{
// Set the current values to the solution values.
unsigned C_INT32 i, imax = mSolutionVariables.size();
unsigned C_INT32 j, jmax = mExperimentDependentValues.size();
unsigned C_INT32 l;
mRMS = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD.resize(imax);
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mFisher = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mGradient.resize(imax);
mGradient = std::numeric_limits<C_FLOAT64>::quiet_NaN();
// Recalcuate the best solution.
for (i = 0; i < imax; i++)
(*mUpdateMethods[i])(mSolutionVariables[i]);
mStoreResults = true;
calculate();
// Keep the results
CVector< C_FLOAT64 > DependentValues = mExperimentDependentValues;
if (mSolutionValue == mInfinity)
return false;
// The statistics need to be calculated for the result, i.e., now.
mpExperimentSet->calculateStatistics();
if (jmax)
mRMS = sqrt(mSolutionValue / jmax);
if (jmax > imax)
mSD = sqrt(mSolutionValue / (jmax - imax));
mHaveStatistics = true;
CMatrix< C_FLOAT64 > dyp;
bool CalculateFIM = true;
try
{
dyp.resize(imax, jmax);
}
catch (CCopasiException Exception)
{
CalculateFIM = false;
}
C_FLOAT64 Current;
C_FLOAT64 Delta;
// Calculate the gradient
for (i = 0; i < imax; i++)
{
Current = mSolutionVariables[i];
if (fabs(Current) > resolution)
{
(*mUpdateMethods[i])(Current *(1.0 + factor));
Delta = 1.0 / (Current * factor);
}
else
{
(*mUpdateMethods[i])(resolution);
Delta = 1.0 / resolution;
}
calculate();
mGradient[i] = (mCalculateValue - mSolutionValue) * Delta;
if (CalculateFIM)
for (j = 0; j < jmax; j++)
dyp(i, j) = (mExperimentDependentValues[j] - DependentValues[j]) * Delta;
// Restore the value
(*mUpdateMethods[i])(Current);
}
// This is necessary so that CExperiment::printResult shows the correct data.
calculate();
mStoreResults = false;
if (!CalculateFIM)
{
// Make sure the timer is acurate.
(*mCPUTime.getRefresh())();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 13);
return false;
}
// Construct the fisher information matrix
for (i = 0; i < imax; i++)
for (l = 0; l <= i; l++)
{
C_FLOAT64 & tmp = mFisher(i, l);
tmp = 0.0;
for (j = 0; j < jmax; j++)
tmp += dyp(i, j) * dyp(l, j);
tmp *= 2.0;
if (l != i)
mFisher(l, i) = tmp;
}
mCorrelation = mFisher;
#ifdef XXXX
/* int dgetrf_(integer *m,
* integer *n,
* doublereal *a,
* integer * lda,
* integer *ipiv,
* integer *info)
*
* Purpose
* =======
*
* DGETRF computes an LU factorization of a general M-by-N matrix A
* using partial pivoting with row interchanges.
*
* The factorization has the form
* A = P * L * U
* where P is a permutation matrix, L is lower triangular with unit
* diagonal elements (lower trapezoidal if m > n), and U is upper
* triangular (upper trapezoidal if m < n).
*
* This is the right-looking Level 3 BLAS version of the algorithm.
*
* Arguments
* =========
*
* m (input) INTEGER
* The number of rows of the matrix A. m >= 0.
*
* n (input) INTEGER
* The number of columns of the matrix A. n >= 0.
*
* a (input/output) DOUBLE PRECISION array, dimension (lda,n)
* On entry, the m by n matrix to be factored.
* On exit, the factors L and U from the factorization
* A = P*L*U; the unit diagonal elements of L are not stored.
*
* lda (input) INTEGER
* The leading dimension of the array A. lda >= max(1,m).
*
* ipiv (output) INTEGER array, dimension (min(m,n))
* The pivot indices; for 1 <= i <= min(m,n), row i of the
* matrix was interchanged with row ipiv(i).
*
* info (output) INTEGER
* = 0: successful exit
* < 0: if info = -k, the k-th argument had an illegal value
* > 0: if info = k, U(k,k) is exactly zero. The factorization
* has been completed, but the factor U is exactly
* singular, and division by zero will occur if it is used
* to solve a system of equations.
*/
C_INT info = 0;
C_INT N = imax;
CVector< C_INT > ipiv(imax);
dgetrf_(&N, &N, mCorrelation.array(), &N, ipiv.array(), &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
/* dgetri_(integer *n, doublereal *a, integer *lda, integer *ipiv,
* doublereal *work, integer *lwork, integer *info);
*
*
* Purpose
* =======
*
* DGETRI computes the inverse of a matrix using the LU factorization
* computed by DGETRF.
*
* This method inverts U and then computes inv(A) by solving the system
* inv(A)*L = inv(U) for inv(A).
*
* Arguments
* =========
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the factors L and U from the factorization
* A = P*L*U as computed by DGETRF.
* On exit, if INFO = 0, the inverse of the original matrix A.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
* IPIV (input) INTEGER array, dimension (N)
* The pivot indices from DGETRF; for 1<=i<=N, row i of the
* matrix was interchanged with row IPIV(i).
*
* WORK (workspace/output) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
* On exit, if INFO=0, then WORK(1) returns the optimal LWORK.
*
* LWORK (input) INTEGER
* The dimension of the array WORK. LWORK >= max(1,N).
* For optimal performance LWORK >= N*NB, where NB is
* the optimal blocksize returned by ILAENV.
*
* If LWORK = -1, then a workspace query is assumed; the routine
* only calculates the optimal size of the WORK array, returns
* this value as the first entry of the WORK array, and no error
* message related to LWORK is issued by XERBLA.
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
* > 0: if INFO = i, U(i,i) is exactly zero; the matrix is
* singular and its inverse could not be computed.
*
*/
C_INT lwork = -1; // Instruct dgesvd_ to determine work array size.
CVector< C_FLOAT64 > work;
work.resize(1);
dgetri_(&N, mCorrelation.array(), &N, ipiv.array(), work.array(), &lwork, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
lwork = (C_INT) work[0];
work.resize(lwork);
dgetri_(&N, mCorrelation.array(), &N, ipiv.array(), work.array(), &lwork, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
#endif // XXXX
// The Fisher Information matrix is a symmetric positive semidefinit matrix.
/* int dpotrf_(char *uplo, integer *n, doublereal *a,
* integer *lda, integer *info);
*
*
* Purpose
* =======
*
* DPOTRF computes the Cholesky factorization of a real symmetric
* positive definite matrix A.
*
* The factorization has the form
* A = U**T * U, if UPLO = 'U', or
* A = L * L**T, if UPLO = 'L',
* where U is an upper triangular matrix and L is lower triangular.
*
* This is the block version of the algorithm, calling Level 3 BLAS.
*
* Arguments
* =========
*
* UPLO (input) CHARACTER*1
* = 'U': Upper triangle of A is stored;
* = 'L': Lower triangle of A is stored.
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the symmetric matrix A. If UPLO = 'U', the leading
* N-by-N upper triangular part of A contains the upper
* triangular part of the matrix A, and the strictly lower
* triangular part of A is not referenced. If UPLO = 'L', the
* leading N-by-N lower triangular part of A contains the lower
* triangular part of the matrix A, and the strictly upper
* triangular part of A is not referenced.
*
* On exit, if INFO = 0, the factor U or L from the Cholesky
* factorization A = U**T*U or A = L*L**T.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
* > 0: if INFO = i, the leading minor of order i is not
* positive definite, and the factorization could not be
* completed.
*
*/
char U = 'U';
C_INT info = 0;
C_INT N = imax;
dpotrf_(&U, &N, mCorrelation.array(), &N, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 12);
return false;
}
/* int dpotri_(char *uplo, integer *n, doublereal *a,
* integer *lda, integer *info);
*
*
* Purpose
* =======
*
* DPOTRI computes the inverse of a real symmetric positive definite
* matrix A using the Cholesky factorization A = U**T*U or A = L*L**T
* computed by DPOTRF.
*
* Arguments
* =========
*
* UPLO (input) CHARACTER*1
* = 'U': Upper triangle of A is stored;
* = 'L': Lower triangle of A is stored.
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the triangular factor U or L from the Cholesky
* factorization A = U**T*U or A = L*L**T, as computed by
* DPOTRF.
* On exit, the upper or lower triangle of the (symmetric)
* inverse of A, overwriting the input factor U or L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
* > 0: if INFO = i, the (i,i) element of the factor U or L is
* zero, and the inverse could not be computed.
*
*/
dpotri_(&U, &N, mCorrelation.array(), &N, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
// Assure that the inverse is completed.
for (i = 0; i < imax; i++)
for (l = 0; l < i; l++)
mCorrelation(l, i) = mCorrelation(i, l);
CVector< C_FLOAT64 > S(imax);
#ifdef XXXX
// We invert the Fisher information matrix with the help of singular
// value decomposition.
/* int dgesvd_(char *jobu, char *jobvt, integer *m, integer *n,
* doublereal *a, integer *lda, doublereal *s, doublereal *u,
* integer *ldu, doublereal *vt, integer *ldvt,
* doublereal *work, integer *lwork, integer *info);
*
*
* Purpose
* =======
*
* DGESVD computes the singular value decomposition (SVD) of a real
* M-by-N matrix A, optionally computing the left and/or right singular
* vectors. The SVD is written
*
* A = U * SIGMA * transpose(V)
*
* where SIGMA is an M-by-N matrix which is zero except for its
* min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and
* V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA
* are the singular values of A; they are real and non-negative, and
* are returned in descending order. The first min(m,n) columns of
* U and V are the left and right singular vectors of A.
*
* Note that the routine returns V**T, not V.
*
* Arguments
* =========
*
* JOBU (input) CHARACTER*1
* Specifies options for computing all or part of the matrix U:
* = 'A': all M columns of U are returned in array U:
* = 'S': the first min(m,n) columns of U (the left singular
* vectors) are returned in the array U;
* = 'O': the first min(m,n) columns of U (the left singular
* vectors) are overwritten on the array A;
* = 'N': no columns of U (no left singular vectors) are
* computed.
*
* JOBVT (input) CHARACTER*1
* Specifies options for computing all or part of the matrix
* V**T:
* = 'A': all N rows of V**T are returned in the array VT;
* = 'S': the first min(m,n) rows of V**T (the right singular
* vectors) are returned in the array VT;
* = 'O': the first min(m,n) rows of V**T (the right singular
* vectors) are overwritten on the array A;
* = 'N': no rows of V**T (no right singular vectors) are
* computed.
*
* JOBVT and JOBU cannot both be 'O'.
*
* M (input) INTEGER
* The number of rows of the input matrix A. M >= 0.
*
* N (input) INTEGER
* The number of columns of the input matrix A. N >= 0.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the M-by-N matrix A.
* On exit,
* if JOBU = 'O', A is overwritten with the first min(m,n)
* columns of U (the left singular vectors,
* stored columnwise);
* if JOBVT = 'O', A is overwritten with the first min(m,n)
* rows of V**T (the right singular vectors,
* stored rowwise);
* if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A
* are destroyed.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,M).
*
* S (output) DOUBLE PRECISION array, dimension (min(M,N))
* The singular values of A, sorted so that S(i) >= S(i+1).
*
* U (output) DOUBLE PRECISION array, dimension (LDU,UCOL)
* (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'.
* If JOBU = 'A', U contains the M-by-M orthogonal matrix U;
* if JOBU = 'S', U contains the first min(m,n) columns of U
* (the left singular vectors, stored columnwise);
* if JOBU = 'N' or 'O', U is not referenced.
*
* LDU (input) INTEGER
* The leading dimension of the array U. LDU >= 1; if
* JOBU = 'S' or 'A', LDU >= M.
*
* VT (output) DOUBLE PRECISION array, dimension (LDVT,N)
* If JOBVT = 'A', VT contains the N-by-N orthogonal matrix
* V**T;
* if JOBVT = 'S', VT contains the first min(m,n) rows of
* V**T (the right singular vectors, stored rowwise);
* if JOBVT = 'N' or 'O', VT is not referenced.
*
* LDVT (input) INTEGER
* The leading dimension of the array VT. LDVT >= 1; if
* JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N).
*
* WORK (workspace/output) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
* On exit, if INFO = 0, WORK(1) returns the optimal LWORK;
* if INFO > 0, WORK(2:MIN(M,N)) contains the unconverged
* superdiagonal elements of an upper bidiagonal matrix B
* whose diagonal is in S (not necessarily sorted). B
* satisfies A = U * B * VT, so it has the same singular values
* as A, and singular vectors related by U and VT.
*
* LWORK (input) INTEGER
* The dimension of the array WORK.
* LWORK >= MAX(1,3*MIN(M,N)+MAX(M,N),5*MIN(M,N)).
* For good performance, LWORK should generally be larger.
*
* If LWORK = -1, then a workspace query is assumed; the routine
* only calculates the optimal size of the WORK array, returns
* this value as the first entry of the WORK array, and no error
* message related to LWORK is issued by XERBLA.
*
* INFO (output) INTEGER
* = 0: successful exit.
* < 0: if INFO = -i, the i-th argument had an illegal value.
* > 0: if DBDSQR did not converge, INFO specifies how many
* superdiagonals of an intermediate bidiagonal form B
* did not converge to zero. See the description of WORK
* above for details.
*
*/
char job = 'A';
C_INT info = 0;
C_INT N = imax;
CVector< C_FLOAT64 > S(imax);
CMatrix< C_FLOAT64 > U(imax, imax);
CMatrix< C_FLOAT64 > VT(imax, imax);
C_INT lwork = -1; // Instruct dgesvd_ to determine work array size.
CVector< C_FLOAT64 > work;
work.resize(1);
dgesvd_(&job, &job, &N, &N, mCorrelation.array(), &N, S.array(), U.array(),
&N, VT.array(), &N, work.array(), &lwork, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
lwork = (C_INT) work[0];
work.resize(lwork);
// This actually calculates the SVD of mCorrelation^T, since dgesvd uses
// fortran notation, i.e., mCorrelation = V^T * B^T * U
dgesvd_(&job, &job, &N, &N, mCorrelation.array(), &N, S.array(), U.array(),
&N, VT.array(), &N, work.array(), &lwork, &info);
// Even if info is not zero we are still able to invert
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
// Now we invert the Fisher Information Matrix. Please note,
// that we are calculating a pseudo inverse in the case that one or
// more singular values are zero.
mCorrelation = 0.0;
for (i = 0; i < imax; i++)
if (S[i] == 0.0)
mCorrelation(i, i) = 0.0;
else
mCorrelation(i, i) = 1.0 / S[i];
CMatrix< C_FLOAT64 > Tmp(imax, imax);
char opN = 'N';
C_FLOAT64 Alpha = 1.0;
C_FLOAT64 Beta = 0.0;
dgemm_(&opN, &opN, &N, &N, &N, &Alpha, U.array(), &N,
mCorrelation.array(), &N, &Beta, Tmp.array(), &N);
dgemm_(&opN, &opN, &N, &N, &N, &Alpha, Tmp.array(), &N,
VT.array(), &N, &Beta, mCorrelation.array(), &N);
#endif // XXXX
// rescale the lower bound of the covariant matrix to have unit diagonal
for (i = 0; i < imax; i++)
{
C_FLOAT64 & tmp = S[i];
if (mCorrelation(i, i) > 0.0)
{
tmp = 1.0 / sqrt(mCorrelation(i, i));
mParameterSD[i] = mSD / tmp;
}
else if (mCorrelation(i, i) < 0.0)
{
tmp = 1.0 / sqrt(- mCorrelation(i, i));
mParameterSD[i] = mSD / tmp;
}
else
{
mParameterSD[i] = mInfinity;
tmp = 1.0;
mCorrelation(i, i) = 1.0;
}
}
for (i = 0; i < imax; i++)
for (l = 0; l < imax; l++)
mCorrelation(i, l) *= S[i] * S[l];
// Make sure the timer is acurate.
(*mCPUTime.getRefresh())();
return true;
}
inline void
GolubReinschUpper
( DistMatrix<F>& A, DistMatrix<BASE(F),VR,STAR>& s, DistMatrix<F>& V )
{
#ifndef RELEASE
CallStackEntry entry("svd::GolubReinschUpper");
#endif
typedef BASE(F) Real;
const Int m = A.Height();
const Int n = A.Width();
const Int k = Min( m, n );
const Int offdiagonal = ( m>=n ? 1 : -1 );
const char uplo = ( m>=n ? 'U' : 'L' );
const Grid& g = A.Grid();
// Bidiagonalize A
DistMatrix<F,STAR,STAR> tP( g ), tQ( g );
Bidiag( A, tP, tQ );
// Grab copies of the diagonal and sub/super-diagonal of A
DistMatrix<Real,MD,STAR> d_MD_STAR(g), e_MD_STAR(g);
A.GetRealPartOfDiagonal( d_MD_STAR );
A.GetRealPartOfDiagonal( e_MD_STAR, offdiagonal );
// NOTE: lapack::BidiagQRAlg expects e to be of length k
DistMatrix<Real,STAR,STAR> d_STAR_STAR( d_MD_STAR ),
eHat_STAR_STAR( k, 1, g ),
e_STAR_STAR( g );
View( e_STAR_STAR, eHat_STAR_STAR, 0, 0, k-1, 1 );
e_STAR_STAR = e_MD_STAR;
// Initialize U and VAdj to the appropriate identity matrices
DistMatrix<F,VC,STAR> U_VC_STAR( g );
DistMatrix<F,STAR,VC> VAdj_STAR_VC( g );
U_VC_STAR.AlignWith( A );
VAdj_STAR_VC.AlignWith( V );
Identity( U_VC_STAR, m, k );
Identity( VAdj_STAR_VC, k, n );
// Compute the SVD of the bidiagonal matrix and accumulate the Givens
// rotations into our local portion of U and VAdj
Matrix<F>& ULoc = U_VC_STAR.Matrix();
Matrix<F>& VAdjLoc = VAdj_STAR_VC.Matrix();
lapack::BidiagQRAlg
( uplo, k, VAdjLoc.Width(), ULoc.Height(),
d_STAR_STAR.Buffer(), e_STAR_STAR.Buffer(),
VAdjLoc.Buffer(), VAdjLoc.LDim(),
ULoc.Buffer(), ULoc.LDim() );
// Make a copy of A (for the Householder vectors) and pull the necessary
// portions of U and VAdj into a standard matrix dist.
DistMatrix<F> B( A );
if( m >= n )
{
DistMatrix<F> AT(g), AB(g);
DistMatrix<F,VC,STAR> UT_VC_STAR(g), UB_VC_STAR(g);
PartitionDown( A, AT, AB, n );
PartitionDown( U_VC_STAR, UT_VC_STAR, UB_VC_STAR, n );
AT = UT_VC_STAR;
MakeZeros( AB );
Adjoint( VAdj_STAR_VC, V );
}
else
{
DistMatrix<F> VT(g), VB(g);
DistMatrix<F,STAR,VC> VAdjL_STAR_VC(g), VAdjR_STAR_VC(g);
PartitionDown( V, VT, VB, m );
PartitionRight( VAdj_STAR_VC, VAdjL_STAR_VC, VAdjR_STAR_VC, m );
Adjoint( VAdjL_STAR_VC, VT );
MakeZeros( VB );
}
// Backtransform U and V
bidiag::ApplyU( LEFT, NORMAL, B, tQ, A );
bidiag::ApplyV( LEFT, NORMAL, B, tP, V );
// Copy out the appropriate subset of the singular values
s = d_STAR_STAR;
}
bool TestTransformerExpr::TestUnaryOpExpression() {
VT("<?php clone $a;", "Variant gv_a;\n"
"\n"
"f_clone(toObject(gv_a));\n");
VT("<?php ++$a;", "Variant gv_a;\n"
"\n"
"++gv_a;\n");
VT("<?php --$a;", "Variant gv_a;\n"
"\n"
"--gv_a;\n");
VT("<?php $a++;", "Variant gv_a;\n"
"\n"
"gv_a++;\n");
VT("<?php $a--;", "Variant gv_a;\n"
"\n"
"gv_a--;\n");
VT("<?php +$a;", "Variant gv_a;\n"
"\n"
"+gv_a;\n");
VT("<?php -$a;", "Variant gv_a;\n"
"\n"
"-gv_a;\n");
VT("<?php !$a;", "Variant gv_a;\n"
"\n"
"!(toBoolean(gv_a));\n");
VT("<?php ~$a;", "Variant gv_a;\n"
"\n"
"~gv_a;\n");
VT("<?php ($a);", "Variant gv_a;\n"
"\n"
"(gv_a);\n");
VT("<?php (int)$a;", "Variant gv_a;\n"
"\n"
"toInt64(gv_a);\n");
VT("<?php (real)$a;", "Variant gv_a;\n"
"\n"
"toDouble(gv_a);\n");
VT("<?php (string)$a;", "Variant gv_a;\n"
"\n"
"toString(gv_a);\n");
VT("<?php (array)$a;", "Variant gv_a;\n"
"\n"
"toArray(gv_a);\n");
VT("<?php (object)$a;", "Variant gv_a;\n"
"\n"
"toObject(gv_a);\n");
VT("<?php (bool)$a;", "Variant gv_a;\n"
"\n"
"toBoolean(gv_a);\n");
VT("<?php (unset)$a;", "Variant gv_a;\n"
"\n"
"unset(gv_a);\n");
VT("<?php exit;", "f_exit();\n");
VT("<?php exit();", "f_exit();\n");
VT("<?php exit($a);", "Variant gv_a;\n"
"\n"
"f_exit(gv_a);\n");
VT("<?php @$a;",
"Variant gv_a;\n"
"\n"
"(silenceInc(), silenceDec(gv_a));\n");
VT("<?php array($a);",
"Variant gv_a;\n"
"\n"
"Array(NEW(ArrayElement)(gv_a), NULL);\n");
VT("<?php print $a;", "Variant gv_a;\n"
"\n"
"print(toString(gv_a));\n");
VT("<?php isset($a);", "Variant gv_a;\n"
"\n"
"isset(gv_a);\n");
VT("<?php empty($a);", "Variant gv_a;\n"
"\n"
"empty(gv_a);\n");
VT("<?php include $a;", "Variant gv_a;\n"
"\n"
"invokeFile(toString(gv_a), false, variables);\n");
VT("<?php include_once 1;", "invokeFile(toString(1), true, variables);\n");
VT("<?php eval($a);", "Variant gv_a;\n"
"\n"
"f_eval(toString(gv_a));\n");
VT("<?php require $a;", "Variant gv_a;\n"
"\n"
"invokeFile(toString(gv_a), false, variables);\n");
VT("<?php require_once 1;", "invokeFile(toString(1), true, variables);\n");
return true;
}
.swap = swapfmt \
}
/* vertex-only */
#define V_(pipe, fmt, rbfmt, swapfmt) \
[PIPE_FORMAT_ ## pipe] = { \
.present = 1, \
.vtx = VFMT4_ ## fmt, \
.tex = ~0, \
.rb = RB4_ ## rbfmt, \
.swap = swapfmt \
}
static struct fd4_format formats[PIPE_FORMAT_COUNT] = {
/* 8-bit */
VT(R8_UNORM, 8_UNORM, R8_UNORM, WZYX),
VT(R8_SNORM, 8_SNORM, R8_SNORM, WZYX),
VT(R8_UINT, 8_UINT, R8_UINT, WZYX),
VT(R8_SINT, 8_SINT, R8_SINT, WZYX),
V_(R8_USCALED, 8_UINT, NONE, WZYX),
V_(R8_SSCALED, 8_UINT, NONE, WZYX),
_T(A8_UNORM, 8_UNORM, A8_UNORM, WZYX),
_T(L8_UNORM, 8_UNORM, R8_UNORM, WZYX),
_T(I8_UNORM, 8_UNORM, NONE, WZYX),
_T(A8_UINT, 8_UINT, NONE, WZYX),
_T(A8_SINT, 8_SINT, NONE, WZYX),
_T(L8_UINT, 8_UINT, NONE, WZYX),
_T(L8_SINT, 8_SINT, NONE, WZYX),
_T(I8_UINT, 8_UINT, NONE, WZYX),
bool TestTransformerExpr::TestBinaryOpExpression() {
VT("<?php $a += $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a += gv_b;\n");
VT("<?php $a -= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a -= gv_b;\n");
VT("<?php $a *= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a *= gv_b;\n");
VT("<?php $a /= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a /= gv_b;\n");
VT("<?php $a .= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"concat_assign(gv_a, toString(gv_b));\n");
VT("<?php $a %= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a %= toInt64(gv_b);\n");
VT("<?php $a &= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a &= gv_b;\n");
VT("<?php $a |= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a |= gv_b;\n");
VT("<?php $a ^= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a ^= gv_b;\n");
VT("<?php $a <<= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a <<= toInt64(gv_b);\n");
VT("<?php $a >>= $b;", "Variant gv_b;\nVariant gv_a;\n\n"
"gv_a >>= toInt64(gv_b);\n");
VT("<?php $a || $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"(toBoolean(gv_a) || toBoolean(gv_b));\n");
VT("<?php $a && $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"(toBoolean(gv_a) && toBoolean(gv_b));\n");
VT("<?php $a or $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"(toBoolean(gv_a) || toBoolean(gv_b));\n");
VT("<?php $a and $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"(toBoolean(gv_a) && toBoolean(gv_b));\n");
VT("<?php $a xor $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"logical_xor(toBoolean(gv_a), toBoolean(gv_b));\n");
VT("<?php $a | $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"bitwise_or(gv_a, gv_b);\n");
VT("<?php $a & $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"bitwise_and(gv_a, gv_b);\n");
VT("<?php $a ^ $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"bitwise_xor(gv_a, gv_b);\n");
VT("<?php $a . $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"concat(toString(gv_a), toString(gv_b));\n");
VT("<?php $a + $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"gv_a + gv_b;\n");
VT("<?php $a - $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"gv_a - gv_b;\n");
VT("<?php $a * $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"multiply(gv_a, gv_b);\n");
VT("<?php $a / $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"divide(gv_a, gv_b);\n");
VT("<?php $a % $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"toInt64(gv_a) % toInt64(gv_b);\n");
VT("<?php $a << $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"toInt64(toInt64(gv_a)) << toInt64(gv_b);\n");
VT("<?php $a >> $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"toInt64(toInt64(gv_a)) >> toInt64(gv_b);\n");
VT("<?php $a === $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"same(gv_a, gv_b);\n");
VT("<?php $a !== $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"!same(gv_a, gv_b);\n");
VT("<?php $a == $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"equal(gv_a, gv_b);\n");
VT("<?php $a != $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"!equal(gv_a, gv_b);\n");
VT("<?php $a < $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"less(gv_a, gv_b);\n");
VT("<?php $a <= $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"not_more(gv_a, gv_b);\n");
VT("<?php $a > $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"more(gv_a, gv_b);\n");
VT("<?php $a >= $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"not_less(gv_a, gv_b);\n");
VT("<?php $a instanceof $b;", "Variant gv_a;\nVariant gv_b;\n\n"
"toObject(gv_a).instanceof(toString(gv_b));\n");
return true;
}
