Slater::Slater(const int &nParticles, const string &orbitalType_):
nParticles(nParticles),
nDimensions(3),
rOld(mat(nParticles, nDimensions)),
rNew(mat(nParticles, nDimensions)),
N(nParticles/2),
slaterUPold(mat(N, N)),
slaterDOWNold(mat(N, N)),
slaterUPnew(mat(N, N)),
slaterDOWNnew(mat(N, N)),
slaterUPinvOld(mat(N, N)),
slaterDOWNinvOld(mat(N, N)),
slaterUPinvNew(mat(N, N)),
slaterDOWNinvNew(mat(N, N)),
SUP(vec(N)),
SDOWN(vec(N)),
dwavefunction(rowvec(nDimensions)),
grad(rowvec(nDimensions))
{
if (orbitalType_ == "Hydrogenic")
{
orbitals = new Hydrogenic();
}
else if (orbitalType_ == "Diatomic")
{
orbitals = new Diatomic();
}
else
{
cout << "! Orbitaltype " << orbitalType_ << " not implemented yet" << endl;
exit(1);
}
}
rowvec Connectome::richClub(const mat &W, int klevel)
{
/*
inputs: W: weighted connection matrix
optional:
k-level: max level of RC(k).
When k-level is -1, k-level is set to max of degree of W
output: rich: rich-club curve
adopted from Opsahl et al. Phys Rev Lett, 2008, 101(16)
*/
rowvec nodeDegree = degree(W);
if (klevel == -1)
klevel = nodeDegree.max();
vec wrank = sort(vectorise(W),"descend");
rowvec Rw = rowvec(1,W.n_rows).fill(datum::nan);
uvec smallNodes;
for (uint kk=0;kk<klevel;++kk) {
smallNodes = find(nodeDegree<kk+1);
if (smallNodes.is_empty())
continue;
mat cutOutW = W;
smallNodes = sort(smallNodes,"descend");
for (uint i =0;i<smallNodes.n_elem;++i) {
cutOutW.shed_row(smallNodes(i));
cutOutW.shed_col(smallNodes(i));
}
double Wr = accu(cutOutW);
uvec t = find(cutOutW != 0);
if (!t.is_empty())
Rw(kk) = Wr/ accu(wrank.subvec(0,t.n_elem-1));
}
return Rw;
}
void network::initNet(double scale)
{
//自底向上初始化
for(int i=1;i<=layer_num;i++)
{
//权值初始化
w[i]=mat(ln[i-1],ln[i]);
w[i].randu();
w[i]=1-2*w[i];
w[i]=scale*w[i];
//偏置初始化
o[i]=rowvec(ln[i]);
o[i].randu();
o[i]=1-2*o[i];
o[i]=scale*o[i];
}
initVariables();
}
bool mrpt::vision::pnp::rpnp::compute_pose(Eigen::Ref<Eigen::Matrix3d> R_, Eigen::Ref<Eigen::Vector3d> t_)
{
// selecting an edge $P_{ i1 }P_{ i2 }$ by n random sampling
int i1 = 0, i2 = 1;
double lmin = Q(0, i1)*Q(0, i2) + Q(1, i1)*Q(1, i2) + Q(2, i1)*Q(2, i2);
Eigen::MatrixXi rij (n,2);
R_=Eigen::MatrixXd::Identity(3,3);
t_=Eigen::Vector3d::Zero();
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++)
rij(i, j) = rand() % n;
for (int ii = 0; ii < n; ii++)
{
int i = rij(ii, 0), j = rij(ii,1);
if (i == j)
continue;
double l = Q(0, i)*Q(0, j) + Q(1, i)*Q(1, j) + Q(2, i)*Q(2, j);
if (l < lmin)
{
i1 = i;
i2 = j;
lmin = l;
}
}
// calculating the rotation matrix of $O_aX_aY_aZ_a$.
Eigen::Vector3d p1, p2, p0, x, y, z, dum_vec;
p1 = P.col(i1);
p2 = P.col(i2);
p0 = (p1 + p2) / 2;
x = p2 - p0; x /= x.norm();
if (abs(x(1)) < abs(x(2)) )
{
dum_vec << 0, 1, 0;
z = x.cross(dum_vec); z /= z.norm();
y = z.cross(x); y /= y.norm();
}
else
{
dum_vec << 0, 0, 1;
y = dum_vec.cross(x); y /= y.norm();
z = x.cross(y); x /= x.norm();
}
Eigen::Matrix3d R0;
R0.col(0) = x; R0.col(1) =y; R0.col(2) = z;
for (int i = 0; i < n; i++)
P.col(i) = R0.transpose() * (P.col(i) - p0);
// Dividing the n - point set into(n - 2) 3 - point subsets
// and setting up the P3P equations
Eigen::Vector3d v1 = Q.col(i1), v2 = Q.col(i2);
double cg1 = v1.dot(v2);
double sg1 = sqrt(1 - cg1*cg1);
double D1 = (P.col(i1) - P.col(i2)).norm();
Eigen::MatrixXd D4(n - 2, 5);
int j = 0;
Eigen::Vector3d vi;
Eigen::VectorXd rowvec(5);
for (int i = 0; i < n; i++)
{
if (i == i1 || i == i2)
continue;
vi = Q.col(i);
double cg2 = v1.dot(vi);
double cg3 = v2.dot(vi);
double sg2 = sqrt(1 - cg2*cg2);
double D2 = (P.col(i1) - P.col(i)).norm();
double D3 = (P.col(i) - P.col(i2)).norm();
// get the coefficients of the P3P equation from each subset.
rowvec = getp3p(cg1, cg2, cg3, sg1, sg2, D1, D2, D3);
D4.row(j) = rowvec;
j += 1;
if(j>n-3)
break;
}
Eigen::VectorXd D7(8), dumvec(8), dumvec1(5);
D7.setZero();
for (int i = 0; i < n-2; i++)
{
dumvec1 = D4.row(i);
dumvec= getpoly7(dumvec1);
D7 += dumvec;
}
Eigen::PolynomialSolver<double, 7> psolve(D7.reverse());
Eigen::VectorXcd comp_roots = psolve.roots().transpose();
Eigen::VectorXd real_comp, imag_comp;
real_comp = comp_roots.real();
imag_comp = comp_roots.imag();
Eigen::VectorXd::Index max_index;
double max_real= real_comp.cwiseAbs().maxCoeff(&max_index);
std::vector<double> act_roots_;
int cnt=0;
for (int i=0; i<imag_comp.size(); i++ )
{
if(abs(imag_comp(i))/max_real<0.001)
{
act_roots_.push_back(real_comp(i));
cnt++;
}
}
double* ptr = &act_roots_[0];
Eigen::Map<Eigen::VectorXd> act_roots(ptr, cnt);
if (cnt==0)
{
return false;
}
Eigen::VectorXd act_roots1(cnt);
act_roots1 << act_roots.segment(0,cnt);
std::vector<Eigen::Matrix3d> R_cum(cnt);
std::vector<Eigen::Vector3d> t_cum(cnt);
std::vector<double> err_cum(cnt);
for(int i=0; i<cnt; i++)
{
double root = act_roots(i);
// Compute the rotation matrix
double d2 = cg1 + root;
Eigen::Vector3d unitx, unity, unitz;
unitx << 1,0,0;
unity << 0,1,0;
unitz << 0,0,1;
x = v2*d2 -v1;
x/=x.norm();
if (abs(unity.dot(x)) < abs(unitz.dot(x)))
{
z = x.cross(unity);z/=z.norm();
y=z.cross(x); y/y.norm();
}
else
{
y=unitz.cross(x); y/=y.norm();
z = x.cross(y); z/=z.norm();
}
R.col(0)=x;
R.col(1)=y;
R.col(2)=z;
//calculating c, s, tx, ty, tz
Eigen::MatrixXd D(2 * n, 6);
D.setZero();
R0 = R.transpose();
Eigen::VectorXd r(Eigen::Map<Eigen::VectorXd>(R0.data(), R0.cols()*R0.rows()));
for (int j = 0; j<n; j++)
{
double ui = img_pts(j, 0), vi = img_pts(j, 1), xi = P(0, j), yi = P(1, j), zi = P(2, j);
D.row(2 * j) << -r(1)*yi + ui*(r(7)*yi + r(8)*zi) - r(2)*zi,
-r(2)*yi + ui*(r(8)*yi - r(7)*zi) + r(1)*zi,
-1,
0,
ui,
ui*r(6)*xi - r(0)*xi;
D.row(2 * j + 1) << -r(4)*yi + vi*(r(7)*yi + r(8)*zi) - r(5)*zi,
-r(5)*yi + vi*(r(8)*yi - r(7)*zi) + r(4)*zi,
0,
-1,
vi,
vi*r(6)*xi - r(3)*xi;
}
Eigen::MatrixXd DTD = D.transpose()*D;
Eigen::EigenSolver<Eigen::MatrixXd> es(DTD);
Eigen::VectorXd Diag = es.pseudoEigenvalueMatrix().diagonal();
Eigen::MatrixXd V_mat = es.pseudoEigenvectors();
Eigen::MatrixXd::Index min_index;
Diag.minCoeff(&min_index);
Eigen::VectorXd V = V_mat.col(min_index);
V /= V(5);
double c = V(0), s = V(1);
t << V(2), V(3), V(4);
//calculating the camera pose by 3d alignment
Eigen::VectorXd xi, yi, zi;
xi = P.row(0);
yi = P.row(1);
zi = P.row(2);
Eigen::MatrixXd XXcs(3, n), XXc(3,n);
XXc.setZero();
XXcs.row(0) = r(0)*xi + (r(1)*c + r(2)*s)*yi + (-r(1)*s + r(2)*c)*zi + t(0)*Eigen::VectorXd::Ones(n);
XXcs.row(1) = r(3)*xi + (r(4)*c + r(5)*s)*yi + (-r(4)*s + r(5)*c)*zi + t(1)*Eigen::VectorXd::Ones(n);
XXcs.row(2) = r(6)*xi + (r(7)*c + r(8)*s)*yi + (-r(7)*s + r(8)*c)*zi + t(2)*Eigen::VectorXd::Ones(n);
for (int ii = 0; ii < n; ii++)
XXc.col(ii) = Q.col(ii)*XXcs.col(ii).norm();
Eigen::Matrix3d R2;
Eigen::Vector3d t2;
Eigen::MatrixXd XXw = obj_pts.transpose();
calcampose(XXc, XXw, R2, t2);
R_cum[i] = R2;
t_cum[i] = t2;
for (int k = 0; k < n; k++)
XXc.col(k) = R2 * XXw.col(k) + t2;
Eigen::MatrixXd xxc(2, n);
xxc.row(0) = XXc.row(0).array() / XXc.row(2).array();
xxc.row(1) = XXc.row(1).array() / XXc.row(2).array();
double res = ((xxc.row(0) - img_pts.col(0).transpose()).norm() + (xxc.row(1) - img_pts.col(1).transpose()).norm()) / 2;
err_cum[i] = res;
}
int pos_cum = std::min_element(err_cum.begin(), err_cum.end()) - err_cum.begin();
R_ = R_cum[pos_cum];
t_ = t_cum[pos_cum];
return true;
}
/**
* Node betweenness centrality is the fraction of all shortest paths in
* the network that contain a given node. Nodes with high values of
* betweenness centrality participate in a large number of shortest paths.
*
* Input: G, weighted (directed/undirected) connection matrix.
* Output: BC, node betweenness centrality vector.
* EBC, edge betweenness centrality matrix.
*
* Notes:
* The input matrix must be a mapping from weight to distance. For
* instance, in a weighted correlation network, higher correlations are
* more naturally interpreted as shorter distances, and the input matrix
* should consequently be some inverse of the connectivity matrix.
* Betweenness centrality may be normalised to [0,1] via BC/[(N-1)(N-2)]
*
* Reference: Brandes (2001) J Math Sociol 25:163-177.
*/
rowvec Connectome::betweenessCentrality(const mat &G, mat &EBC)
{
uint n = G.n_rows,q = n-1,v=0,w=0;
double Duw,DPvw;
vec t;
rowvec BC = zeros(1,n),D,NP,DP;
uvec S,Q,V,tt,W;
mat G1;
umat P;
EBC = zeros<mat>(n,n);
for (uint u = 0; u<n;++u) {
D = rowvec(1,n).fill(datum::inf); D(u) = 0;
NP = zeros(1,n); NP(u) = 1;
S = linspace<uvec>(0,n-1,n);
P = zeros<umat>(n,n);
Q = zeros<uvec>(n);
q = n-1;
G1 = G;
V = uvec(1).fill(u);
while (true) {
// instead of replacing indices by 0 like S(V)=0;
// we declare all indices then remove the V indeces
// from S. Notice that it is assured that tt should
// be one element since indices don't repeat
for (int i=0;i<V.n_elem;++i) {
tt = find(S == V(i),1);
if (!tt.is_empty())
S.shed_row(tt(0));
}
G1.cols(V).fill(0);
for (uint i=0; i<V.n_elem;++i) {
v = V(i);
Q(q) = v; --q;
W = find( G1.row(v) != 0);
for (uint j = 0;j<W.n_elem;++j) {
w = W(j);
Duw = D(v)+G1(v,w);
if (Duw<D(w)) {
D(w) = Duw;
NP(w) = NP(v);
P.row(w).fill(0);
P(w,v) = 1;
}
else if (Duw == D(w)) {
NP(w) += NP(v);
P(w,v) = 1;
}
}
}
if (S.is_empty())
break;
t = D(S);
if ( !is_finite(t.min()) ){
// the number of inf elements is assumed to be always = q
Q.subvec(0,q) = find(D == datum::inf);
break;
}
V = find(D == t.min());
}
DP = zeros(1,n);
for (uint i=0; i<Q.n_elem-1;++i) {
w = Q(i);
BC(w) += DP(w);
tt = find(P.row(w) != 0);
for (uint j=0; j<tt.n_elem;++j) {
v = tt(j);
DPvw = (1+DP(w))*NP(v)/NP(w);
DP(v) += DPvw;
EBC(v,w) += DPvw;
}
}
}
return BC;
}
