Révision 147
| pobysoC-4.0/src/pobyso.c (revision 147) | ||
|---|---|---|
| 39 | 39 |
sollya_lib_autoprint(objSo, NULL); |
| 40 | 40 |
} /* End pobyso_autoprint. */ |
| 41 | 41 |
|
| 42 |
/* @see pobyso.h#pobyso_dirty_find_zeros */ |
|
| 43 |
mpfr_t* |
|
| 44 |
pobyso_dirty_find_zeros_bounds(pobyso_func_exp_t funcExpSo, |
|
| 45 |
mpfr_t lowerBound, |
|
| 46 |
mpfr_t upperBound, |
|
| 47 |
int* zerosCount) |
|
| 48 |
{
|
|
| 49 |
pobyso_range_t rangeSo; |
|
| 50 |
sollya_obj_t zerosListSo = NULL; |
|
| 51 |
sollya_obj_t* zerosArraySo = NULL; |
|
| 52 |
mpfr_t* zerosArrayMp = NULL; |
|
| 53 |
pobyso_precision_t prec; |
|
| 54 |
|
|
| 55 |
int endEll = 0; |
|
| 56 |
int i,j; |
|
| 57 |
|
|
| 58 |
/* Arguments check. */ |
|
| 59 |
*zerosCount = -1; |
|
| 60 |
if (funcExpSo == NULL ) |
|
| 61 |
{
|
|
| 62 |
pobyso_error_message("pobyso_dirty_find_zeros",
|
|
| 63 |
"NULL_POINTER_ARGUMENT", |
|
| 64 |
"The funcExpSo argument is a NULL pointer"); |
|
| 65 |
return NULL; |
|
| 66 |
} |
|
| 67 |
if (mpfr_cmp(lowerBound, upperBound) > 0) |
|
| 68 |
{
|
|
| 69 |
pobyso_error_message("pobyso_dirty_find_zeros",
|
|
| 70 |
"INVALID_INTERVAL_ARGUMENT", |
|
| 71 |
"The lower bound is larger than the upper bound"); |
|
| 72 |
return NULL; |
|
| 73 |
} |
|
| 74 |
/* Make a range out of the bounds. */ |
|
| 75 |
rangeSo = sollya_lib_range_from_bounds(lowerBound, upperBound); |
|
| 76 |
if (rangeSo == NULL) |
|
| 77 |
{
|
|
| 78 |
return NULL; |
|
| 79 |
} |
|
| 80 |
zerosListSo = sollya_lib_dirtyfindzeros(funcExpSo, rangeSo); |
|
| 81 |
if (zerosListSo == NULL) |
|
| 82 |
{
|
|
| 83 |
return NULL; |
|
| 84 |
} |
|
| 85 |
sollya_lib_clear_obj(rangeSo); |
|
| 86 |
/* Transform the Sollya list into an MPFR list. */ |
|
| 87 |
if (! sollya_lib_get_list_elements(&zerosArraySo, |
|
| 88 |
zerosCount, |
|
| 89 |
&endEll, |
|
| 90 |
zerosListSo)) |
|
| 91 |
{
|
|
| 92 |
sollya_lib_clear_obj(zerosListSo); |
|
| 93 |
*zerosCount = -1; |
|
| 94 |
return NULL; |
|
| 95 |
} |
|
| 96 |
sollya_lib_clear_obj(zerosListSo); |
|
| 97 |
zerosArrayMp = (mpfr_t*) malloc(*zerosCount * sizeof(mpfr_t)); |
|
| 98 |
if (zerosArrayMp == NULL) |
|
| 99 |
{
|
|
| 100 |
pobyso_error_message("pobyso_dirty_find_zeros",
|
|
| 101 |
"MEMORY_ALLOCATION_ERROR", |
|
| 102 |
"Could not allocate zeroes array"); |
|
| 103 |
*zerosCount = -1; |
|
| 104 |
return NULL; |
|
| 105 |
} |
|
| 106 |
for (i = 0 ; i < *zerosCount ; i++) |
|
| 107 |
{
|
|
| 108 |
if (! sollya_lib_get_prec_of_constant(&prec, zerosArraySo[i])) |
|
| 109 |
{
|
|
| 110 |
/* Clean up the already allocated MPFRs. */ |
|
| 111 |
for (j = 0 ; j < i ; j++) mpfr_clear(zerosArrayMp[j]); |
|
| 112 |
/* Clean up the zerosArrayMp array itself. */ |
|
| 113 |
free(zerosArrayMp); |
|
| 114 |
/* Clean up what is left in the zerosArraySo. */ |
|
| 115 |
for (j = i ; j < *zerosCount ; j++) sollya_lib_clear_obj(zerosArraySo[j]); |
|
| 116 |
/* Clean up the zerosArraySo array itself. */ |
|
| 117 |
sollya_lib_free(zerosArraySo); |
|
| 118 |
*zerosCount = -1; |
|
| 119 |
return NULL; |
|
| 120 |
} |
|
| 121 |
mpfr_init2(zerosArrayMp[i], prec); |
|
| 122 |
if (! sollya_lib_get_constant(zerosArrayMp[i], zerosArraySo[i])) |
|
| 123 |
{
|
|
| 124 |
/* Clean up the already allocated MPFRs. */ |
|
| 125 |
for (j = 0 ; j <= i ; j++) mpfr_clear(zerosArrayMp[j]); |
|
| 126 |
/* Clean up the zerosArrayMp array itself. */ |
|
| 127 |
free(zerosArrayMp); |
|
| 128 |
/* Clean up what is left in the zerosArraySo. */ |
|
| 129 |
for (j = i ; j < *zerosCount ; j++) sollya_lib_clear_obj(zerosArraySo[j]); |
|
| 130 |
/* Clean up the zerosArraySo array itself. */ |
|
| 131 |
sollya_lib_free(zerosArraySo); |
|
| 132 |
*zerosCount = -1; |
|
| 133 |
return NULL; |
|
| 134 |
} |
|
| 135 |
sollya_lib_clear_obj(zerosArraySo[i]); |
|
| 136 |
} /* End for i. */ |
|
| 137 |
sollya_lib_free(zerosArraySo); |
|
| 138 |
return zerosArrayMp; |
|
| 139 |
} /* End pobyso_dirty_find_zeros. */ |
|
| 140 |
|
|
| 42 | 141 |
/* @see pobyso.h#pobyso_evaluate_constant */ |
| 43 | 142 |
int |
| 44 | 143 |
pobyso_evaluate_constant(pobyso_func_exp_t functionSo, |
| ... | ... | |
| 69 | 168 |
/* Function evaluation and checks. */ |
| 70 | 169 |
argumentSo = sollya_lib_constant(argumentMp); |
| 71 | 170 |
evaluationSo = sollya_lib_evaluate(functionSo, argumentSo); |
| 171 |
/* Not needed any more. */ |
|
| 172 |
//pobyso_autoprint(evaluationSo); |
|
| 72 | 173 |
sollya_lib_clear_obj(argumentSo); |
| 73 | 174 |
/* The range case: we return the mean of the bounds. The result |
| 74 | 175 |
* is not faithfully rounded. */ |
| 75 | 176 |
if (sollya_lib_obj_is_range(evaluationSo)) |
| 76 | 177 |
{
|
| 178 |
//pobyso_autoprint(evaluationSo); |
|
| 77 | 179 |
if (sollya_lib_get_prec_of_range(&evalPrec, evaluationSo)) |
| 78 | 180 |
{
|
| 79 | 181 |
mpfr_init2(evaluationTmpMp1, evalPrec); |
| ... | ... | |
| 90 | 192 |
mpfr_clear(evaluationTmpMp1); |
| 91 | 193 |
mpfr_clear(evaluationTmpMp2); |
| 92 | 194 |
sollya_lib_clear_obj(evaluationSo); |
| 93 |
return POBYSO_UNFAITHFULL; |
|
| 195 |
/* It may happen, in this case, when the bounds are -Infty and |
|
| 196 |
* +Infty, that the average is NaN. */ |
|
| 197 |
if (mpfr_nan_p(evaluationMp)) |
|
| 198 |
{
|
|
| 199 |
return POBYSO_NAN; |
|
| 200 |
} |
|
| 201 |
else |
|
| 202 |
{
|
|
| 203 |
return POBYSO_UNFAITHFUL; |
|
| 204 |
} |
|
| 94 | 205 |
} |
| 95 | 206 |
else /* Could not get the values of the bounds. */ |
| 96 | 207 |
{
|
| ... | ... | |
| 105 | 216 |
} |
| 106 | 217 |
} /* End the evaluation is a range. */ |
| 107 | 218 |
/* From now on, we assume that the evaluation is constant. */ |
| 108 |
if (sollya_lib_get_prec_of_range(&evalPrec, evaluationSo))
|
|
| 219 |
if (sollya_lib_get_prec_of_constant(&evalPrec, evaluationSo))
|
|
| 109 | 220 |
{
|
| 110 | 221 |
mpfr_init2(evaluationTmpMp1, evalPrec); |
| 111 | 222 |
if (sollya_lib_get_constant(evaluationTmpMp1, evaluationSo)) |
| ... | ... | |
| 191 | 302 |
pobyso_set_verbosity_to(initial_verbosity_level); |
| 192 | 303 |
if (test) |
| 193 | 304 |
{
|
| 194 |
if(mpfr_number_p(dummy)) |
|
| 305 |
if(mpfr_number_p(dummy) || mpfr_inf_p(dummy))
|
|
| 195 | 306 |
{
|
| 196 | 307 |
mpfr_clear(dummy); |
| 197 | 308 |
return test; |
| 198 | 309 |
} |
| 199 |
else |
|
| 310 |
else /* We do not consider NaNs as constants. */
|
|
| 200 | 311 |
{
|
| 201 | 312 |
mpfr_clear(dummy); |
| 202 | 313 |
return 0; |
Formats disponibles : Unified diff