bool Compiler::OptimizeModule() {
llvm::FunctionPassManager fpm(cs_.module_.get());
fpm.add(llvm::createGVNPass()); // required by SCCP Pass
fpm.add(llvm::createPromoteMemoryToRegisterPass());
fpm.add(llvm::createSCCPPass());
fpm.add(llvm::createAggressiveDCEPass());
fpm.run(*cs_.function_);
return true;
}
char* _path_append(const char* pszBase, const char* pszAppend, MallocProc fpm, void* pMallocProcData)
{
const char* pszFormat = "%s/%s";
size_t more = 2;
if (pszBase[strlen(pszBase)] == '/')
{
more = 1;
pszFormat = "%s%s";
}
char* pszNew = (char*)fpm(pMallocProcData, strlen(pszBase) + strlen(pszAppend) + more);
sprintf(pszNew, pszFormat, pszBase, pszAppend);
return pszNew;
}
int SparseEigenSolver(
CSR3_sym_matrix<double, std::int32_t>& A,
CSR3_sym_matrix<double, std::int32_t>& B,
Matrix<double, M_PROP::GE, M_SHAPE::RE, M_ORD::COL>& Z,
Vector<double>& L,
Vector<double>& eigen_error,
double eigenv_max,
int toll_exp,
int max_iter,
std::ostream& log)
{
typedef MML3_INT_TYPE int_t;
int len=100;
char buf[100];
//MKLGetVersionString(buf, len);
mkl_get_version_string(buf, len);
log << "\tSolutore modale per matrici sparse basato su:\n"
<< "\tMKL-FEAST: " << std::string(buf,len);
log << "\n\tCaratteristiche del sistema:"
<< "\n\t\tN : " << A.nrows()
<< "\n\t\tNNZ(A) : " << A.nonzeros()
<< "\n\t\tNNZ(B) : " << B.nonzeros() << std::endl;
if (A.nrows() != B.nrows())
{
log << "LinearEigenSolver: dimensioni di A e B incompatibili \n";
return -1;
}
Vector<int_t> fpm(128);
feastinit(fpm.data());
fpm(1) = 1; // manda in output messAGGI a runtime
fpm(2) = 8; // numero di punti di quadratura (default=)8
if (toll_exp)
fpm(3) =toll_exp; // tolleranza 10^-fpm(3)
if (max_iter)
fpm(4) = max_iter;
fpm(64) = 0; // use PARDISO
int_t n = A.nrows();
double epsout = 0.;
int_t loop = 0;
double emin = 0.;
int_t subspace_dim = std::min(Z.ncols(),n); // m0 in feast routine
int_t founded_eig = 0; // feast m
int_t info = 0;
const char uplo = 'U';
log << "\n\tParmetri algoritmici:"
<< "\n\t\tintervallo autovalori : [" << emin << "," << eigenv_max << "]"
<< "\n\t\tdimensione sottospazio : " << subspace_dim
<< "\n\t\ttolleranza : 10E-" << fpm(3)
<< "\n\t\titerazioni massime : " << fpm(4)
<< std::endl;
log << "\n ................ Inizio messaggi solutore .................\n\n";
dfeast_scsrgv(&uplo, &n,
A.column_value(), A.row_pos(), A.column_index(),
B.column_value(), B.row_pos(), B.column_index(),
fpm.data(), &epsout, &loop, &emin, &eigenv_max,
&subspace_dim, L.data(), Z.data(), &founded_eig, eigen_error.data(),
&info);
log << "\n ................ Fine messaggi solutore ...................\n\n";
if (info != 0)
return info;
Vector<double> tmp_L(L.data(), founded_eig);
L.swap(tmp_L);
return info;
}
int main(){
enum{
NP = 128,
NC = 8,
NC3 = NC*NC*NC,
PFMM = 7,
ICUT = 2,
};
typedef Cell_FMM<PFMM> Cell_t;
static Particle ptcl[NP];
static Cell_t cell[NC][NC][NC];
const double clen = 1.0 / NC;
for(int k=0; k<NC; k++){
for(int j=0; j<NC; j++){
for(int i=0; i<NC; i++){
cell[k][j][i].set(ivec3(i,j,k), clen);
}
}
}
Particle::gen_rand_dist(NP, ptcl);
double msum = 0.0;
for(int i=0; i<NP; i++){
msum += ptcl[i].mass;
}
// printf("msum = %e\n", msum);
for(int i=0; i<NP; i++){
const ivec3 idx = cell_nearest(ptcl[i].pos, clen);
assert(0 <= idx.x && idx.x < NC);
assert(0 <= idx.y && idx.y < NC);
assert(0 <= idx.z && idx.z < NC);
cell[idx.z][idx.y][idx.x].plist.push_back(&ptcl[i]);
}
for(int k=0; k<NC; k++) for(int j=0; j<NC; j++) for(int i=0; i<NC; i++){
cell[k][j][i].sanity_check();
}
puts("Eval PP");
PP_interact_OBC<PFMM, ICUT, NC, NC, NC> (cell);
puts("Gen Green");
static GreenFunction_OBC<PFMM, NC, NC, NC> gf;
gf.gen_gf_r(ICUT, 1./NC);
gf.gen_gf_k();
puts("Eval PM");
Cell_t *cell1d = cell[0][0];
for(int i=0; i<NC3; i++){
cell1d[i].do_P2M();
}
M2L_convolution_OBC<PFMM, NC, NC, NC> (gf, cell);
for(int i=0; i<NC3; i++){
cell1d[i].do_L2P();
}
dvec3 fpp(0.0), fpm(0.0);
for(int i=0; i<NP; i++){
fpp += ptcl[i].mass * ptcl[i].acc_direct;
fpm += ptcl[i].mass * ptcl[i].acc_app;
}
printf("PP ftot : (%e, %e, %e)\n", fpp.x, fpp.y, fpp.z);
printf("PM ftot : (%e, %e, %e)\n", fpm.x, fpm.y, fpm.z);
for(int i=0; i<NP; i++){
ptcl[i].move_accp();
}
puts("eval dirct force");
#pragma omp parallel for
for(int i=0; i<NP; i++){
Particle &pi = ptcl[i];
for(int j=0; j<NP; j++){
const Particle pj = ptcl[j];
if(j == i) continue;
const dvec3 dr = pj.pos - pi.pos;
const double r2 = dr*dr;
const double ri2 = 1.0 / r2;
const double ri = sqrt(ri2);
const double ri3 = ri * ri2;
pi.phi_direct += pj.mass * ri;
pi.acc_direct += (pj.mass * ri3) * dr;
}
}
#if 1
std::vector<double> err(NP);
for(int i=0; i<NP; i++) err[i] = ptcl[i].adiff_rel();
std::sort(err.begin(), err.end());
print_err(err, "adiffr", ICUT, PFMM);
for(int i=0; i<NP; i++) err[i] = ptcl[i].pdiff_rel();
std::sort(err.begin(), err.end());
print_err(err, "pdiffr", ICUT, PFMM);
#endif
return 0;
}
int main() {
freopen("F.in", "r", stdin);
scanf("%d", &T);
for (int cs = 1; cs <= T; cs++) {
scanf("%d%d", &n, &m);
nColor = tot = top = nPart = 0;
std::fill(h + 1, h + n + m + 1, t = 0);
std::fill(dfn + 1, dfn + n + m + 1, 0);
std::fill(low + 1, low + n + m + 1, 0);
std::fill(cut + 1, cut + n + m + 1, false);
for (int i = 1; i <= n; i++) scanf("%d", w + i);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &r[i].x, &r[i].y);
addEdge(r[i].x, r[i].y);
}
std::fill(belong + 1, belong + n + 1, 0);
for (int i = 1; i <= n; i++) {
if (belong[i]) continue;
static int q[MAXN];
nPart++;
int left = 0, right = 0;
belong[q[++right] = i] = nPart;
while (left < right) {
left++;
for (int i = h[q[left]]; i; i = e[i].next) {
if (belong[e[i].node]) continue;
belong[q[++right] = e[i].node] = nPart;
}
}
}
std::fill(size + 1, size + n + 1, 0);
std::fill(prod + 1, prod + nPart + 1, 1);
for (int i = 1; i <= n; i++) {
prod[belong[i]] = 1ll * prod[belong[i]] * w[i] % MOD;
size[belong[i]]++;
}
std::fill(h + 1, h + n + m + 1, t = 0);
for (int i = 1; i <= m; i++) {
addEdge(r[i].x, n + i);
addEdge(r[i].y, n + i);
}
for (int i = 1; i <= n + m; i++) {
if (dfn[i]) continue;
cut[i] = tarjan(i) > 1;
}
std::vector<int> dis;
for (int i = 1; i <= n + m; i++) {
if (i <= n && size[belong[i]] == 1) {
col[i] = ++nColor;
dis.push_back(col[i]);
continue;
}
if (cut[i]) col[i] = ++nColor;
dis.push_back(col[i]);
}
std::sort(dis.begin(), dis.end());
dis.erase(std::unique(dis.begin(), dis.end()), dis.end());
for (int i = 1; i <= n + m; i++) {
col[i] = std::lower_bound(dis.begin(), dis.end(), col[i]) - dis.begin() + 1;
}
nColor = dis.size();
std::fill(prodBlock + 1, prodBlock + nColor + 1, 1);
for (int i = 1; i <= n; i++) {
prodBlock[col[i]] = 1ll * prodBlock[col[i]] * w[i] % MOD;
}
std::fill(h + 1, h + nColor + 1, t = 0);
for (int i = 1; i <= m; i++) {
if (col[r[i].x] != col[n + i]) {
addEdge(col[r[i].x], col[n + i]);
//printf("AddEdge(%d, %d)\n", col[r[i].x], col[r[i].y]);
}
if (col[r[i].y] != col[n + i]) {
addEdge(col[r[i].y], col[n + i]);
//printf("AddEdge(%d, %d)\n", col[r[i].x], col[r[i].y]);
}
}
int answer = 0, total = 0;
for (int i = 1; i <= nPart; i++) {
total = (total + prod[i]) % MOD;
}
std::fill(v + 1, v + nColor + 1, false);
for (int i = 1; i <= nColor; i++) {
if (v[i]) continue;
dfs(i);
}
for (int i = 1; i <= n; i++) {
if (size[belong[i]] == 1) {
long long tmp = (total - prod[belong[i]]) % MOD;
answer = (answer + 1ll * i * tmp % MOD) % MOD;
continue;
}
if (!cut[i]) {
long long tmp = (total - prod[belong[i]]) % MOD;
tmp = (tmp + 1ll * prod[belong[i]] * fpm(w[i], MOD - 2) % MOD) % MOD;
answer = (answer + 1ll * i * tmp % MOD) % MOD;
} else {
long long tmp = prod[belong[i]];
tmp = 1ll * tmp * fpm(subProd[col[i]], MOD - 2) % MOD;
tmp = (tmp + subSum[col[i]]) % MOD;
tmp = (tmp + total - prod[belong[i]]) % MOD;
answer = (answer + 1ll * i * tmp % MOD) % MOD;
}
}
answer = (answer % MOD + MOD) % MOD;
printf("%d\n", answer);
}
return 0;
}
