/** * @brief Print all the errors that have been recorded up to now. * This function should be called only if mps_context_has_errors() * returns true. * * @param s A pointer to the current mps_context. */ void mps_print_errors (mps_context * s) { const char *error = s->last_error; size_t length = strlen (error); if (s->logstr == NULL) s->logstr = stderr; const char *exclamation_mark = "!"; if (mps_is_a_tty (s->logstr)) exclamation_mark = "\033[31;1m!\033[0m"; if (error[length] == '\n') { fprintf (stderr, "%s %s %s", exclamation_mark, "MPSolve encountered an error:", error); } else { fprintf (stderr, "%s %s %s\n", exclamation_mark, "MPSolve encountered an error:", error); } /* Dump approximations, but only if they are present */ if (s->root && s->lastphase) mps_dump (s); }
/** * @brief Main routine of the program that implements the algorithm * in the standard polynomial version. * * The program is divided into many parts * - Check the correctness of data, scale coefficients if * needed, and select cases: the variable <code>which_case</code> is * <code>'f'</code> or <code>'d'</code> according to float or dpe case. * - Call msolve or dsolve according to the value of which_case. * - Allocate MP variables mfpc, mroot, drad (if needed). * - Start MPsolve loop * - prepare data according to the current precision * and to the data_type (density/sparsity/user) * - Call msolve with the current precision * - check for termination */ MPS_PRIVATE void mps_standard_mpsolve (mps_context * s) { int i, nzc; char which_case; mps_boolean d_after_f, computed; #ifndef DISABLE_DEBUG clock_t *my_timer = mps_start_timer (); #endif mps_allocate_data (s); if (s->DOLOG) s->debug_level |= MPS_DEBUG_TRACE; /* == 1 == Setup variables, i.e. copy coefficients into dpr, dpc and similar. */ mps_setup (s); s->lastphase = no_phase; computed = false; s->over_max = false; /* == 2 == Resume from pre-computed roots */ if (s->resume) { mps_error (s, "Resume not supported yet"); #ifndef DISABLE_DEBUG mps_stop_timer (my_timer); #endif return; } /* == 3 == Check data and get starting phase */ if (s->skip_float) which_case = 'd'; else which_case = 'f'; /* This variable is true if we need a dpe phase after the * float phase */ d_after_f = false; /* Check if a dpe phase is needed and deflate polynomial */ mps_check_data (s, &which_case); /* Check for errors in check data */ if (mps_context_has_errors (s)) { #ifndef DISABLE_DEBUG mps_stop_timer (my_timer); #endif return; } rdpe_set_2dl (s->eps_out, 1.0, -s->output_config->prec); if (s->DOLOG) fprintf (s->logstr, "Which_case = %c, skip_float= %d\n", which_case, s->skip_float); /* == 4 == Float phase */ if (which_case == 'f') { if (s->DOLOG) fprintf (s->logstr, "Float phase ...\n"); mps_fsolve (s, &d_after_f); s->lastphase = float_phase; if (s->DOLOG) mps_dump (s); computed = mps_check_stop (s); if (computed && s->output_config->goal != MPS_OUTPUT_GOAL_APPROXIMATE) goto exit_sub; /* stop for COUNT and ISOLATE goals */ } /* == 5 == DPE phase */ if (which_case == 'd' || d_after_f) { /* DPE phase */ if (s->DOLOG) fprintf (s->logstr, "DPE phase ...\n"); /* If we are arriving from a float phase copy the floating points * roots approximations in the DPE root approximations. */ if (d_after_f) for (i = 0; i < s->n; i++) { rdpe_set_d (s->root[i]->drad, s->root[i]->frad); cdpe_set_x (s->root[i]->dvalue, s->root[i]->fvalue); } s->lastphase = dpe_phase; mps_dsolve (s, d_after_f); if (s->DOLOG) mps_dump (s); computed = mps_check_stop (s); if (computed && s->output_config->goal != MPS_OUTPUT_GOAL_APPROXIMATE) goto exit_sub; } /* == 6 == Allocate MP variables mfpc, mroot, drad, mfppc, mfppc1 * (the real input case is not implemented yet ) */ MPS_DEBUG (s, "Starting MP phase"); s->lastphase = mp_phase; /* ==== 6.1 initialize mp variables */ mps_mp_set_prec (s, 2 * DBL_MANT_DIG); /* Prepare data according to the current working precision */ mps_prepare_data (s, s->mpwp); /* ==== 6.2 set initial values for mp variables */ for (i = 0; i < s->n; i++) { if (which_case == 'd' || d_after_f) mpc_set_cdpe (s->root[i]->mvalue, s->root[i]->dvalue); else { mpc_set_cplx (s->root[i]->mvalue, s->root[i]->fvalue); rdpe_set_d (s->root[i]->drad, s->root[i]->frad); } } if (computed && s->output_config->goal == MPS_OUTPUT_GOAL_APPROXIMATE) { MPS_DEBUG (s, "Exiting since the approximation are computed and the goal is MPS_OUTPUT_GOAL_APPROXIMATE"); goto exit_sub; } MPS_DEBUG (s, "s->mpwp = %ld, s->mpwp_max = %ld", s->mpwp, s->mpwp_max); MPS_DEBUG (s, "s->input_config->prec = %ld", s->active_poly->prec); /* == 7 == Start MPSolve loop */ s->mpwp = mps_context_get_minimum_precision (s); /* Poor man GMP - machine precision detection. We need that min_prec is contained * in the interval [ DBL_MANT_DIG , 2 * DBL_MANT_DIG ]. This is probably true on most * architectures with the instruction above, but we want to be sure. */ while (s->mpwp < DBL_MANT_DIG) s->mpwp <<= 1; while (s->mpwp > 2 * DBL_MANT_DIG) s->mpwp >>= 1; while (!computed && s->mpwp < s->mpwp_max) { s->mpwp *= 2; if (s->mpwp > s->mpwp_max) { s->mpwp = s->mpwp_max; s->over_max = true; } if (s->DOLOG) fprintf (s->logstr, "MAIN: mp_loop: mpwp=%ld\n", s->mpwp); /* == 7.1 == prepare data according to the current precision */ mps_mp_set_prec (s, s->mpwp); mps_prepare_data (s, s->mpwp); /* == 7.2 == Call msolve with the current precision */ if (s->DOLOG) fprintf (s->logstr, "MAIN: now call msolve nclust=%ld\n", s->clusterization->n); mps_msolve (s); s->lastphase = mp_phase; /* if (s->DOLOG) dump(logstr); */ if (s->DOLOG) { /* count isolated zeros */ nzc = 0; for (i = 0; i < s->n; i++) { if (s->root[i]->status == MPS_ROOT_STATUS_ISOLATED || s->root[i]->status == MPS_ROOT_STATUS_APPROXIMATED) nzc++; } fprintf (s->logstr, "MAIN: isolated %d roots\n", nzc); fprintf (s->logstr, "MAIN: after msolve check stop\n"); } /* == 7.3 == Check the stop condition */ computed = mps_check_stop (s); mps_mmodify (s, true); /* == 7.4 == reset the status vector */ for (i = 0; i < s->n; i++) if (s->root[i]->status == MPS_ROOT_STATUS_NEW_CLUSTERED) s->root[i]->status = MPS_ROOT_STATUS_CLUSTERED; } /* == 8 == Check for termination */ if (!computed) { if (s->over_max) { s->over_max = true; /* mps_error (s, "Reached the maximum working precision"); */ MPS_DEBUG (s, "Reached the maximum working precision"); goto exit_sub; } else { /* mps_warn (s, "Reached the input precision"); */ MPS_DEBUG (s, "Reached the input precision"); goto exit_sub; } } exit_sub: /* == 9 == Check inclusion disks */ if (computed && s->clusterization->n < s->n) if (!mps_inclusion (s)) { mps_error (s, "Unable to compute inclusion disks"); return; } /* == 10 == Refine roots */ if (computed && !s->over_max && s->output_config->goal == MPS_OUTPUT_GOAL_APPROXIMATE) { s->lastphase = mp_phase; mps_improve (s); } /* == 11 == Check inclusions */ /* This step is disabled since it cause problems with the lar* kind of polynomials. * To be re-enabled a careful check of the necessary precision to avoid NULL DERIVATIVE * warnings should be implemented. * if (s->active_poly->prec > 0) * mps_validate_inclusions (s); */ /* == 12 == Restore to highest used precision */ if (s->lastphase == mp_phase) mps_restore_data (s); #ifndef DISABLE_DEBUG { unsigned long time = mps_stop_timer (my_timer); MPS_DEBUG (s, "Total time using MPSolve: %lu ms", time); } #endif /* Finally copy the roots ready for output */ mps_copy_roots (s); }