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); }