void bit2int::operator()(expr * m, expr_ref & result, proof_ref& p) {
flush_cache();
expr_reduce emap(*this);
for_each_ast(emap, m);
result = get_cached(m);
if (m_manager.proofs_enabled() && m != result.get()) {
// TBD: rough
p = m_manager.mk_rewrite(m, result);
}
TRACE("bit2int",
tout << mk_pp(m, m_manager) << "======>\n"
<< mk_pp(result, m_manager) << "\n";);
Z3_ast Z3_API Z3_qe_model_project_skolem (Z3_context c,
Z3_model m,
unsigned num_bounds,
Z3_app const bound[],
Z3_ast body,
Z3_ast_map map)
{
Z3_TRY;
LOG_Z3_qe_model_project_skolem (c, m, num_bounds, bound, body, map);
RESET_ERROR_CODE();
ast_manager& man = mk_c(c)->m ();
app_ref_vector vars(man);
if (!to_apps(num_bounds, bound, vars)) {
RETURN_Z3(0);
}
expr_ref result (mk_c(c)->m ());
result = to_expr (body);
model_ref model (to_model_ref (m));
expr_map emap (man);
spacer::qe_project (mk_c(c)->m (), vars, result, model, emap);
mk_c(c)->save_ast_trail (result.get ());
obj_map<ast, ast*> &map_z3 = to_ast_map_ref(map);
for (expr_map::iterator it = emap.begin(), end = emap.end(); it != end; ++it){
man.inc_ref(&(it->get_key()));
man.inc_ref(it->get_value());
map_z3.insert(&(it->get_key()), it->get_value());
}
return of_expr (result.get ());
Z3_CATCH_RETURN(0);
}
Z3_ast Z3_API Z3_qe_model_project_skolem (Z3_context c,
Z3_model mdl,
unsigned num_bounds,
Z3_app const bound[],
Z3_ast body,
Z3_ast_map map)
{
Z3_TRY;
LOG_Z3_qe_model_project_skolem (c, mdl, num_bounds, bound, body, map);
RESET_ERROR_CODE();
ast_manager& m = mk_c(c)->m();
app_ref_vector vars(m);
if (!to_apps(num_bounds, bound, vars)) {
RETURN_Z3(nullptr);
}
expr_ref result (m);
result = to_expr (body);
model_ref model (to_model_ref (mdl));
expr_map emap (m);
spacer::qe_project(m, vars, result, model, emap);
mk_c(c)->save_ast_trail(result);
obj_map<ast, ast*> &map_z3 = to_ast_map_ref(map);
for (auto& kv : emap) {
m.inc_ref(kv.m_key);
m.inc_ref(kv.m_value);
map_z3.insert(kv.m_key, kv.m_value);
}
return of_expr (result);
Z3_CATCH_RETURN(nullptr);
}
int test_azoo_conv_with_scaling(int conv_option, int scaling_option,
const Epetra_Comm& comm, bool verbose)
{
int localN = 20;
int numprocs = comm.NumProc();
int globalN = numprocs*localN;
Epetra_Map emap(globalN, 0, comm);
Epetra_CrsMatrix* Acrs = create_and_fill_crs_matrix(emap);
Epetra_Vector x_crs(emap), b_crs(emap);
x_crs.PutScalar(1.0);
Acrs->Multiply(false, x_crs, b_crs);
x_crs.PutScalar(0.0);
AztecOO azoo(Acrs, &x_crs, &b_crs);
azoo.SetAztecOption(AZ_conv, conv_option);
azoo.SetAztecOption(AZ_solver, AZ_cg);
azoo.SetAztecOption(AZ_scaling, scaling_option);
azoo.Iterate(100, 1.e-9);
//now, do the same thing with 'old-fashioned Aztec', and compare
//the solutions.
int* proc_config = new int[AZ_PROC_SIZE];
#ifdef EPETRA_MPI
AZ_set_proc_config(proc_config, MPI_COMM_WORLD);
AZ_set_comm(proc_config, MPI_COMM_WORLD);
#else
AZ_set_proc_config(proc_config, 0);
#endif
int *external, *update_index, *external_index;
int *external2, *update_index2, *external_index2;
AZ_MATRIX* Amsr = NULL;
AZ_MATRIX* Avbr = NULL;
int err = create_and_transform_simple_matrix(AZ_MSR_MATRIX, localN, 4.0,
proc_config, Amsr,
external, update_index,
external_index);
int N_update = localN+Amsr->data_org[AZ_N_border];
double* x_msr = new double[N_update];
double* b_msr = new double[N_update*2];
double* b_msr_u = b_msr+N_update;
double* x_vbr = new double[N_update];
double* b_vbr = new double[N_update*2];
double* b_vbr_u = b_vbr+N_update;
err = create_and_transform_simple_matrix(AZ_VBR_MATRIX, localN, 4.0,
proc_config, Avbr,
external2, update_index2,
external_index2);
for(int i=0; i<N_update; ++i) {
x_msr[i] = 1.0;
b_msr[i] = 0.0;
b_msr_u[i] = 0.0;
x_vbr[i] = 1.0;
b_vbr[i] = 0.0;
b_vbr_u[i] = 0.0;
}
Amsr->matvec(x_msr, b_msr, Amsr, proc_config);
Avbr->matvec(x_vbr, b_vbr, Avbr, proc_config);
for(int i=0; i<N_update; ++i) {
x_msr[i] = 0.0;
x_vbr[i] = 0.0;
}
//check that the rhs's are the same.
double max_rhs_diff1 = 0.0;
double max_rhs_diff2 = 0.0;
double* bptr_crs = b_crs.Values();
AZ_invorder_vec(b_msr, Amsr->data_org, update_index, NULL, b_msr_u);
AZ_invorder_vec(b_vbr, Avbr->data_org, update_index2, Avbr->rpntr, b_vbr_u);
for(int i=0; i<localN; ++i) {
if (std::abs(bptr_crs[i] - b_msr_u[i]) > max_rhs_diff1) {
max_rhs_diff1 = std::abs(bptr_crs[i] - b_msr_u[i]);
}
if (std::abs(bptr_crs[i] - b_vbr_u[i]) > max_rhs_diff2) {
max_rhs_diff2 = std::abs(bptr_crs[i] - b_vbr_u[i]);
}
}
if (max_rhs_diff1> 1.e-12) {
cout << "AztecOO rhs not equal to Aztec msr rhs "<<max_rhs_diff1<<endl;
return(-1);
}
if (max_rhs_diff2> 1.e-12) {
cout << "AztecOO rhs not equal to Aztec vbr rhs "<<max_rhs_diff2<<endl;
return(-1);
}
int* az_options = new int[AZ_OPTIONS_SIZE];
double* params = new double[AZ_PARAMS_SIZE];
double* status = new double[AZ_STATUS_SIZE];
AZ_defaults(az_options, params);
az_options[AZ_solver] = AZ_cg;
az_options[AZ_conv] = conv_option;
az_options[AZ_scaling] = scaling_option;
az_options[AZ_max_iter] = 100;
params[AZ_tol] = 1.e-9;
AZ_iterate(x_msr, b_msr, az_options, params, status, proc_config,
Amsr, NULL, NULL);
AZ_iterate(x_vbr, b_vbr, az_options, params, status, proc_config,
Avbr, NULL, NULL);
AZ_invorder_vec(x_msr, Amsr->data_org, update_index, NULL, b_msr_u);
AZ_invorder_vec(x_vbr, Avbr->data_org, update_index2, Avbr->rpntr, b_vbr_u);
double max_diff1 = 0.0;
double max_diff2 = 0.0;
double* xptr_crs = x_crs.Values();
for(int i=0; i<localN; ++i) {
if (std::abs(xptr_crs[i] - b_msr_u[i]) > max_diff1) {
max_diff1 = std::abs(xptr_crs[i] - b_msr_u[i]);
}
if (std::abs(xptr_crs[i] - b_vbr_u[i]) > max_diff2) {
max_diff2 = std::abs(xptr_crs[i] - b_vbr_u[i]);
}
}
if (max_diff1 > 1.e-7) {
cout << "AztecOO failed to match Aztec msr with scaling and Anorm conv."
<< endl;
return(-1);
}
if (max_diff2 > 1.e-7) {
cout << "AztecOO failed to match Aztec vbr with scaling and Anorm conv."
<< endl;
return(-1);
}
delete Acrs;
delete [] x_msr;
delete [] b_msr;
delete [] x_vbr;
delete [] b_vbr;
destroy_matrix(Amsr);
destroy_matrix(Avbr);
delete [] proc_config;
free(update_index);
free(external);
free(external_index);
free(update_index2);
free(external2);
free(external_index2);
delete [] az_options;
delete [] params;
delete [] status;
return(0);
}
int main(int argc, char *argv[])
{
#ifdef EPETRA_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm comm;
#endif
int numprocs = comm.NumProc();
int localproc = comm.MyPID();
///////////////////////////////////////////////////
//First figure out whether verbose output is on.
//(and if so, only turn it on for proc 0)
bool verbose = false;
if (localproc == 0) {
verbose = argument_is_present("-v", argc, argv);
}
///////////////////////////////////////////////////
int local_n = 30;
int global_n = numprocs*local_n;
Epetra_Map emap(global_n, 0, comm);
Epetra_CrsMatrix* A = create_and_fill_crs_matrix(emap);
Epetra_Vector x(emap), b(emap);
x.PutScalar(1.0);
A->Multiply(false, x, b);
x.PutScalar(0.0);
double initial_norm = resid2norm(*A, x, b);
if (verbose) {
cout << "Initial 2-norm of b-A*x: "<<initial_norm<<endl;
}
int err = test_azoo_as_precond_op(*A, x, b, verbose);
if (err != 0) {
cout << "test_azoo_as_precond_op err, test FAILED."<<endl;
return(err);
}
err = test_azoo_conv_anorm(*A, x, b, verbose);
if (err != 0) {
cout << "test_azoo_conv_anorm err, test FAILED."<<endl;
return(err);
}
if (verbose) {
cout << "testing AztecOO with AZ_conv = AZ_Anorm, and AZ_scaling = AZ_sym_diag" << endl;
}
err = test_azoo_conv_with_scaling(AZ_Anorm, AZ_sym_diag, A->Comm(), verbose);
if (err != 0) {
cout << "test_azoo_conv_with_scaling err, test FAILED."<<endl;
return(err);
}
if (verbose) {
cout << "testing AztecOO with AZ_conv = AZ_rhs, and AZ_scaling = AZ_sym_diag" << endl;
}
err = test_azoo_conv_with_scaling(AZ_rhs, AZ_sym_diag, A->Comm(), verbose);
if (err != 0) {
cout << "test_azoo_conv_with_scaling err, test FAILED."<<endl;
return(err);
}
err = test_azoo_with_ilut(*A, x, b, verbose);
if (err != 0) {
cout << "test_azoo_with_ilut err, test FAILED."<<endl;
return(err);
}
err = test_azoo_scaling(*A, x, b, verbose);
if (err != 0) {
cout << "test_azoo_scaling err="<<err<<", test FAILED."<<endl;
return(err);
}
delete A;
int* options = new int[AZ_OPTIONS_SIZE];
options[AZ_solver] = AZ_cg;
options[AZ_subdomain_solve] = AZ_none;
options[AZ_precond] = AZ_Jacobi;
if (verbose)
std::cout << "about to call test_AZ_iterate_AZ_pre_calc_AZ_reuse"
<<std::endl;
err = test_AZ_iterate_AZ_pre_calc_AZ_reuse(comm, options, verbose);
if (err != 0) {
cout << "test_AZ_iterate_AZ_pre_calc_AZ_reuse err, test FAILED."<<endl;
return(err);
}
options[AZ_solver] = AZ_cgs;
options[AZ_subdomain_solve] = AZ_icc;
options[AZ_precond] = AZ_dom_decomp;
err = test_AZ_iterate_AZ_pre_calc_AZ_reuse(comm, options, verbose);
if (err != 0) {
cout << "test_AZ_iterate_AZ_pre_calc_AZ_reuse err, test FAILED."<<endl;
return(err);
}
options[AZ_solver] = AZ_gmres;
options[AZ_subdomain_solve] = AZ_ilut;
err = test_AZ_iterate_AZ_pre_calc_AZ_reuse(comm, options, verbose);
if (err != 0) {
cout << "test_AZ_iterate_AZ_pre_calc_AZ_reuse err, test FAILED."<<endl;
return(err);
}
options[AZ_solver] = AZ_tfqmr;
options[AZ_subdomain_solve] = AZ_ilu;
err = test_AZ_iterate_AZ_pre_calc_AZ_reuse(comm, options, verbose);
if (err != 0) {
cout << "test_AZ_iterate_AZ_pre_calc_AZ_reuse err, test FAILED."<<endl;
return(err);
}
options[AZ_solver] = AZ_bicgstab;
options[AZ_subdomain_solve] = AZ_rilu;
err = test_AZ_iterate_AZ_pre_calc_AZ_reuse(comm, options, verbose);
if (err != 0) {
cout << "test_AZ_iterate_AZ_pre_calc_AZ_reuse err, test FAILED."<<endl;
return(err);
}
err = test_AZ_iterate_then_AZ_scale_f(comm, verbose);
if (err != 0) {
cout << "test_AZ_iterate_then_AZ_scale_f err, test FAILED."<<endl;
return(err);
}
delete [] options;
err = test_bug2554(comm, verbose);
if (err != 0) {
cout << "test_bug2554 err, test FAILED."<<endl;
return(err);
}
err = test_bug2890(comm, verbose);
if (err != 0) {
cout << "test_bug2890 err, test FAILED."<<endl;
return(err);
}
cout << "********* Test passed **********" << endl;
#ifdef EPETRA_MPI
MPI_Finalize() ;
#endif
return(0);
}
