HTMLMeterElement::GaugeRegion HTMLMeterElement::gaugeRegion() const
{
double lowValue = low();
double highValue = high();
double theValue = value();
double optimumValue = optimum();
if (optimumValue < lowValue) {
// The optimum range stays under low
if (theValue <= lowValue)
return GaugeRegionOptimum;
if (theValue <= highValue)
return GaugeRegionSuboptimal;
return GaugeRegionEvenLessGood;
}
if (highValue < optimumValue) {
// The optimum range stays over high
if (highValue <= theValue)
return GaugeRegionOptimum;
if (lowValue <= theValue)
return GaugeRegionSuboptimal;
return GaugeRegionEvenLessGood;
}
// The optimum range stays between high and low.
// According to the standard, <meter> never show GaugeRegionEvenLessGood in this case
// because the value is never less or greater than min or max.
if (lowValue <= theValue && theValue <= highValue)
return GaugeRegionOptimum;
return GaugeRegionSuboptimal;
}
HTMLMeterElement::GaugeRegion HTMLMeterElement::gaugeRegion() const
{
double lowValue = low();
double highValue = high();
double theValue = value();
double optimumValue = optimum();
if (optimumValue <= lowValue) {
// The optimum range stays under low
if (theValue <= lowValue)
return GaugeRegionOptimum;
if (theValue <= highValue)
return GaugeRegionSuboptimal;
return GaugeRegionEvenLessGood;
}
if (highValue <= optimumValue) {
// The optimum range stays over high
if (highValue <= theValue)
return GaugeRegionOptimum;
if (lowValue <= theValue)
return GaugeRegionSuboptimal;
return GaugeRegionEvenLessGood;
}
// The optimum range stays between high and low
if (lowValue < theValue && theValue < highValue)
return GaugeRegionOptimum;
if (theValue == min() || max() == theValue)
return GaugeRegionEvenLessGood;
return GaugeRegionSuboptimal;
}
SEXP Expect_matrix(SEXP S1, SEXP S, SEXP lambda, SEXP time, SEXP theta0, SEXP theta1, SEXP matdiag){
int nvar, npoints, nprotect=0;
nvar = GET_LENGTH(lambda);
npoints = GET_LENGTH(time);
PROTECT(time = coerceVector(time,REALSXP)); nprotect++;
PROTECT(theta0 = coerceVector(theta0,REALSXP)); nprotect++;
PROTECT(theta1 = coerceVector(theta1,REALSXP)); nprotect++;
// results
SEXP expectation = PROTECT(allocVector(REALSXP,nvar*npoints)); nprotect++;
if(!isComplex(lambda)){
// eigenvectors
PROTECT(S1 = coerceVector(S1,REALSXP)); nprotect++;
PROTECT(S = coerceVector(S,REALSXP)); nprotect++;
// matrix exponential
SEXP matexp = PROTECT(allocVector(REALSXP,nvar*nvar*npoints)); nprotect++;
// Compute the exponential matrix
multi_exp_matrix (&nvar, &npoints, REAL(time), REAL(lambda), REAL(S), REAL(S1), REAL(matexp));
// Compute the expectations
optimum (&nvar, &npoints, REAL(time), REAL(theta0), REAL(theta1), REAL(expectation), REAL(matexp), REAL(matdiag));
// Done.
}else{
double complex *matexp;
// complex eigenvalues & eigenvectors
PROTECT(S1 = coerceVector(S1,CPLXSXP)); nprotect++;
PROTECT(S = coerceVector(S,CPLXSXP)); nprotect++;
// alloc a complex vector in C rather than R structure...
matexp = Calloc(nvar*nvar*npoints,double complex);
// Compute the exponential matrix
multi_exp_matrix_complex (&nvar, &npoints, REAL(time), COMPLEX(lambda), COMPLEX(S), COMPLEX(S1), matexp);
// Compute the expectations
optimum_complex(&nvar, &npoints, REAL(time), REAL(theta0), REAL(theta1), REAL(expectation), matexp, REAL(matdiag));
// Done.
// Free the memory
Free(matexp);
}
UNPROTECT(nprotect);
return expectation;
}
int Simplex::simplex() {
if (SIMPLEX_DEBUG) fprintf(stderr, "Simplex step:\n");
if (SIMPLEX_DEBUG) printObjective();
if (SIMPLEX_DEBUG) printTableau();
// fprintf(stderr, "Objective = %.6f\n", optimum());
// printTableau(true);
// checkObjective2();
if (!findPivotRow()) return SIMPLEX_OPTIMAL;
// fprintf(stderr, "pivot row = %d\n", pivot_row);
regeneratePivotRow();
// checkObjective2();
// if (!findPivotCol()) {
if (!findPivotCol2()) {
mip->unboundedFailure();
return SIMPLEX_UNBOUNDED;
}
// fprintf(stderr, "pivot col = %d\n", pivot_col);
pivot();
simplexs++;
// printB();
// printTableau(true);
// checkBasis();
// printObjective();
// if (SIMPLEX_DEBUG) printTableau();
// exit(0);
// If bound is already good enough to cause failure, return
if (EARLY_TERM && (int) ceil(optimum()) > mip->objVarBound()) return SIMPLEX_GOOD_ENOUGH;
return SIMPLEX_IN_PROGRESS;
}
void LMA::reset()
{
// Read out results
alglib::minlmreport report;
alglib::minlmresults(state, xIn, report);
// Set optimum
optimum.resize(n);
for(unsigned i = 0; i < n; i++)
optimum(i) = xIn[i];
opt->setParameters(optimum);
// Log result
OPENANN_DEBUG << "Terminated:";
OPENANN_DEBUG << report.iterationscount << " iterations";
OPENANN_DEBUG << report.nfunc << " function evaluations";
OPENANN_DEBUG << report.njac << " Jacobi evaluations";
OPENANN_DEBUG << "Error = " << opt->error();
OPENANN_DEBUG << "Reason:";
switch(report.terminationtype)
{
case 1:
OPENANN_DEBUG << "Relative function improvement is below threshold.";
break;
case 2:
OPENANN_DEBUG << "Relative step is below threshold.";
break;
case 4:
OPENANN_DEBUG << "Gradient is below threshold.";
break;
case 5:
OPENANN_DEBUG << "MaxIts steps was taken";
break;
case 7:
OPENANN_DEBUG << "Stopping conditions are too stringent, "
<< "further improvement is impossible.";
break;
default:
OPENANN_DEBUG << "Unknown.";
}
iteration = -1;
}
void CG::reset()
{
alglib_impl::ae_state_clear(&envState);
alglib::mincgreport report;
alglib::mincgresults(state, xIn, report);
optimum.resize(n, 1);
for(unsigned i = 0; i < n; i++)
optimum(i) = xIn[i];
OPENANN_DEBUG << "CG terminated";
OPENANN_DEBUG << report.iterationscount << " iterations";
OPENANN_DEBUG << report.nfev << " function evaluations";
OPENANN_DEBUG << "reason: ";
switch(report.terminationtype)
{
case 1:
OPENANN_DEBUG << "Relative function improvement is no more than EpsF.";
break;
case 2:
OPENANN_DEBUG << "Relative step is no more than EpsX.";
break;
case 4:
OPENANN_DEBUG << "Gradient norm is no more than EpsG.";
break;
case 5:
OPENANN_DEBUG << "MaxIts steps was taken.";
break;
case 7:
OPENANN_DEBUG << "Stopping conditions are too stringent, further"
<< " improvement is impossible, we return the best "
<< "X found so far.";
break;
case 8:
OPENANN_DEBUG << "Terminated by user.";
break;
default:
OPENANN_DEBUG << "Unknown.";
}
iteration = -1;
}
/**
* Genera una solucion inicial, utilizando una heuristica greedy:
* si no se viola la condicion de maximo de creditos y cursos:
* - asignar el curso j al periodo i.
* - arreglar colisiones de prerequisitos moviendo al siguiente periodo
* el curso que no cumple.
* si no
* - avanzar el periodo i al i + 1
*
* repetir hasta haber asignado todos los prerequisitosk
*
* @bacp_instance :: instancia del problema bacp
*/
void initial_solution(struct bacp_instance *instance)
{
unsigned short int j;
unsigned short int i = 0;
unsigned short int cpp;
unsigned short int cred;
unsigned short int optimal_load = optimum(instance) + 1;
for (j = 0; j < instance->n_courses; j++) {
cpp = courses_per_period(instance, i) + 1;
cred = credits(instance, i) + instance->credits[j];
/* 1. Nos pasamos de los cursos maximos al agregar este? */
/* 2. Nos pasamos de los creditos maximos al agregar este? */
if ( cpp > instance->max_courses || cred > optimal_load)
i = (i + 1) % instance->n_periods;
instance->period[j] = i;
fix_collitions(instance, i);
}
}
/**
* Actual CTMDPI bounded reachability algorithm.
*
* @param unsigned num_states number of states of CTMDPI
* @param fg Poisson values by Fox-Glynn algorithm
* @param left_end use Poisson probabilities up to left limit
* @param min true for minimal probability, false for maximal one
* @param row_starts see CTMDPI documentation
* @param choice_starts see CTMDPI documentation
* @param non_zeros see CTMDPI documentation
* @param q current probability vector
* @param q_primed next probabilities vector
* @param cols see CTMDPI documentation
* @param P_s_alpha_B P(s,alpha,B) (see paper)
* @param B target states
*/
static double *ctmdpi_iter( const unsigned num_states, const FoxGlynn *fg, const unsigned left_end,
const BOOL min, const int * row_starts,
const int * choice_starts,
const double *non_zeros, double *q, double *q_primed, const unsigned *cols,
const double *P_s_alpha_B, const bitset *B) {
/* in the algorithm the main iteration is in lines 3-12. For each
* jump probability k starting from the right bound in the Fox-Glynn
* algorithm down to 1 the loop body is to be executed once. In the
* implementation here we split this loop into two parts: One for
* the non-negligible Poisson probabilities between left and right
* bound of the Fox-Glynn algorithm and one for the jump
* probabilities below left bound, if any.
*/
unsigned i;
state_index row;
bitset * not_B;
/* first part - use poisson probabilities */
/* line 3 in paper */
for (i = fg->right; i >= left_end; i--) {
unsigned ps_index = 0;
double psi = fg->weights[i-fg->left] / fg->total_weight;
/* lines 4-12 in paper */
for ( row = 0 ; (unsigned) row < num_states ; row++ ) {
BITSET_BLOCK_TYPE s_in_B;
s_in_B = get_bit_val(B, row);
if ( s_in_B == BIT_OFF ) {
/* get maximizing/minimizing decision */
/* lines 4-10 in paper (non-target state) */
double m = min ? 2.0 : -1.0;
unsigned l1 = row_starts[row];
unsigned h1 = row_starts[row+1];
unsigned j;
for (j = l1; j < h1; j++) {
double m_primed = get_choice_probability_psi
(j, choice_starts, non_zeros, cols,q, P_s_alpha_B, ps_index, psi);
m = optimum(min, m, m_primed);
ps_index++;
}
/* in case some non-target state did
* not have any possible decisions we
* set m to zero afterwards */
m = ((-1.0 == m) || (2.0 == m)) ? 0.0 : m;
/* line 9 in paper*/
q_primed[row] = m;
} else {
/* line 11 in paper (target state) */
q_primed[row] = psi + q[row];
}
}
/* swapping is done instead using a new q vector for
* each k */
swap(&q, &q_primed);
}
/* we have to set the q_primed values for target states once
* more now; they won't change afterwards, as psi =
* 0.0. We do here what would be done in the first iteration
* of the next loop. As the values for q_primed do not
* influence the first iteration of the next loop, we can do
* this beforehand to avoid having to do this in each loop. */
row = state_index_NONE;
while ( (row = get_idx_next_non_zero(B, row)) != state_index_NONE )
{ /* target states only */
q_primed[row] = q[row];
}
not_B = not(B);
/* now do part where we are below left bound of poisson probabilities */
for (; i > 0; i--) {
unsigned ps_index = 0;
/* lines 4-12 in paper */
row = state_index_NONE;
while ( (row = get_idx_next_non_zero(not_B, row))
!= state_index_NONE )
{ /* non-target state? */
/* get maximizing/minimizing decision */
/* lines 4-10 in paper (non-target state) */
double m = min ? 2 : -1.0;
unsigned l1 = row_starts[row];
unsigned h1 = row_starts[row+1];
unsigned j;
for (j = l1; j < h1; j++) {
double m_primed = get_choice_probability
(j, choice_starts, non_zeros, cols, q);
m = optimum(min, m, m_primed);
ps_index++;
}
/* in case some non-target state did
* not have any possible decisions we
* set m to zero afterwards */
m = ((-1.0 == m) || (2.0 == m)) ? 0.0 : m;
/* line 9 in paper*/
q_primed[row] = m;
}
/* swapping is done instead using a new q vector for
* each k */
swap(&q, &q_primed);
}
free_bitset(not_B);
return q;
}
/**
* Compute transient reachability probabilities in nonuniform CTMDPs.
*
* @param ctmdp CTMDP to compute probabilities for
* @param rates vector of different rates occuring in CTMDP
* @param num_rates size of rates vector
* @param choices_to_rates maps choice numbers to corresponding rate index
* @param k_bound maximal cardinality to consider
* @
*/
static double *ctmdpi_iterate
(const NDSparseMatrix *ctmdp, const double *rates, const unsigned num_rates,
const unsigned *choices_to_rates, const unsigned k_bound, const bitset *B,
const double time_bound, const BOOL min)
{
double *probs_k;
double *probs_km1;
unsigned state_nr;
double li;
unsigned prob_nr;
unsigned vec_nr;
unsigned num_k_vecs;
unsigned num_km1_vecs;
unsigned *rates_quant;
unsigned *all_k_rates_quant;
unsigned *all_km1_rates_quant;
unsigned k;
const unsigned num_states = (unsigned) ctmdp->n;
const unsigned max_entries = multiset_coeff(num_rates, k_bound);
unsigned succ_nr;
unsigned choice_nr;
double choice_prob;
double succ_prob;
unsigned succ_vec_nr;
const unsigned *row_starts = (unsigned *) ctmdp->row_counts;
const unsigned *choice_starts = (unsigned *) ctmdp->choice_counts;
unsigned rate_nr;
double *non_zeros = ctmdp->non_zeros;
hypoexp_t *hypoexp;
unsigned *rate_to_succ_vec_nr;
probs_k = malloc(max_entries * num_states * sizeof(double));
probs_km1 = malloc(max_entries * num_states * sizeof(double));
all_k_rates_quant = malloc(max_entries * num_rates * sizeof(unsigned));
all_km1_rates_quant = malloc(max_entries * num_rates * sizeof(unsigned));
enumerate_k_vectors(num_rates, k_bound, all_k_rates_quant, &num_k_vecs);
hypoexp = init_hypoexp(k_bound, rates, num_rates, time_bound);
rate_to_succ_vec_nr = malloc(num_rates * sizeof(unsigned));
compute_k_bound_probs(all_k_rates_quant, num_k_vecs, num_rates,
hypoexp, k_bound, num_states, B, probs_k);
for (k = k_bound; k > 0; k--) {
enumerate_k_vectors(num_rates, k - 1, all_km1_rates_quant, &num_km1_vecs);
prob_nr = 0;
for (vec_nr = 0; vec_nr < num_km1_vecs; vec_nr++) {
rates_quant = get_ith_vec(all_km1_rates_quant, vec_nr, num_rates);
li = hypoexp_cumulate(rates_quant, k - 1, hypoexp);
for (rate_nr = 0; rate_nr < num_rates; rate_nr++) {
rates_quant[rate_nr] += 1;
succ_vec_nr = vector_to_number
(rates_quant, all_k_rates_quant, num_rates, 0, num_k_vecs-1);
rates_quant[rate_nr] -= 1;
rate_to_succ_vec_nr[rate_nr] = succ_vec_nr;
}
for (state_nr = 0; state_nr < num_states; state_nr++) {
if (get_bit_val(B, state_nr)) {
probs_km1[prob_nr] = li;
} else {
unsigned state_start = row_starts[state_nr];
unsigned state_end = row_starts[state_nr + 1];
double opt_choice_prob = min ? 2.0 : -1.0;
for (choice_nr = state_start; choice_nr < state_end; choice_nr++) {
unsigned choice_start = choice_starts[choice_nr];
unsigned choice_end = choice_starts[choice_nr + 1];
choice_prob = 0.0;
rate_nr = choices_to_rates[choice_nr];
succ_vec_nr = rate_to_succ_vec_nr[rate_nr];
for (succ_nr = choice_start; succ_nr < choice_end; succ_nr++) {
succ_prob = probs_k[succ_vec_nr * num_states + (ctmdp->cols)[succ_nr]];
choice_prob += non_zeros[succ_nr] * succ_prob;
}
opt_choice_prob = optimum(min, choice_prob, opt_choice_prob);
}
if (state_start == state_end) {
opt_choice_prob = 0.0;
}
probs_km1[prob_nr] = opt_choice_prob;
}
prob_nr++;
}
}
swap_double(&probs_k, &probs_km1);
swap_unsigned(&all_k_rates_quant, &all_km1_rates_quant);
num_k_vecs = num_km1_vecs;
}
free_hypoexp(hypoexp);
free(probs_km1);
free(all_k_rates_quant);
free(all_km1_rates_quant);
free(rate_to_succ_vec_nr);
return probs_k;
}
