precision of comparing double values with EPSILON in C

问题

Doing function that takes 2 arrays (column1 and column2) from struct CSV D and plots the graph from it.

Idea is to find max, min values of each array, then break range between min−EPSILON and max+EPSILON in to 600 equal regions, where EPSILON = 10^(−6)

Problem is that function does not plot the lowest line properly, I think the issue is when comparing the value from array with min-EPSILON, not sure. Please advice.

Here's my code.

void   
do_plot(CSV *D, int column1, int column2) {
#define Y_REGIONS 600
#define X_REGIONS 600
#define EPSILON 0.000001
int col1=column1-1;                     //since indexing in C language starts from 0, to be more user friendly values increased by 1
int col2=column2-1;
double  min_y = D->values[0][col1]; //min val of column
double  max_y = D->values[0][col1]; //max val of column
double  min_x = D->values[0][col2]; //min val of column
double  max_x = D->values[0][col2]; //max val of column
int     i=0,j=0,k=0;                //iteration variables
double  interval_x, interval_y;     //region
int     counter;                    //counts how many elements of "col1" and "column2" are in bucket
int     plotval;                    //plotted value
double  upper_bound_y[Y_REGIONS+1],lower_bound_y[Y_REGIONS+1];      //arrays for lower and upper bounds of regions in y (added extra 1 not to run out of regions)
double  upper_bound_x[X_REGIONS+1],lower_bound_x[X_REGIONS+1];      //arrays for lower and upper bounds of regions in x
while (i < D->number_of_rows){      
    if (D->values[i][col1] > max_y){
        max_y = D->values[i][col1];
    }
    if (D->values[i][col1] < min_y){
        min_y = D->values[i][col1];
    }
    if (D->values[i][col2] > max_x){
        max_x = D->values[i][col2];
    }
    if (D->values[i][col2] < min_x){
        min_x = D->values[i][col2];
    }
    i++;
}
/* adding EPSILON val to max and min */
max_x=max_x+EPSILON;
max_y=max_y+EPSILON;
min_x=min_x-EPSILON;
min_y=min_y-EPSILON;
interval_y=(max_y-min_y)/Y_REGIONS; //breaking y axis into Y_REGIONS equal regions
interval_x=(max_x-min_x)/X_REGIONS; //breaking x axis into Y_REGIONS equal regions
/* calculating regions of y*/
upper_bound_y[0]=max_y;             //upper bound of the first region in y
lower_bound_y[0]=max_y-interval_y;  //lower bound of the first region in y
for (j=0; j<Y_REGIONS; j++){
    upper_bound_y[j+1]=upper_bound_y[j]-interval_y;
    lower_bound_y[j+1]=lower_bound_y[j]-interval_y;
}
/* calculating regions of x */
upper_bound_x[0]=min_x+interval_x;  //upper bound of the first region in y
lower_bound_x[0]=min_x;             //lower bound of the first region in y
for (j=0; j<X_REGIONS; j++){
    upper_bound_x[j+1]=upper_bound_x[j]+interval_x;
    lower_bound_x[j+1]=lower_bound_x[j]+interval_x;
}
/* plotting the graph */
for (i=0; i<Y_REGIONS; i++){
    printf("\n%6.20lf--%6.20lf: ", lower_bound_y[i], upper_bound_y[i]); //plotting y axis
    for (j=0; j<X_REGIONS; j++){    //x axis
        counter=0;          //resetting counter
        while (k <= D->number_of_rows){
            k++;
            /* checking whether element of input lies within region and counting number of elements */
            if (D->values[k][col1] < upper_bound_y[i] && D->values[k][col1] > lower_bound_y[i]){
                if (D->values[k][col2] < upper_bound_x[j] && D->values[k][col2] > lower_bound_x[j] ){
                    counter++;
                }
            }               
        }
        k=0; //resetting counter
        plotval=floor(log(counter+1)/log(2)); //formula to show number of values in bucket
        /* plotting x lines */
        if (plotval==0){
            printf(".");
        }
        else{
            printf("%d",plotval);
        }
    }
}
printf("\n");
return;
}

回答1:

Bounds calculations are convoluted and have holes.

See that upper_bound_x[n] == lower_bound_x[n+1]. Then when a compare occurs with (D->values[k][col2] == upper_bound_x[n], it will neither fit in in region n nor region n+1.

// Existing code
upper_bound_x[0]=min_x+interval_x;  //upper bound of the first region in y
lower_bound_x[0]=min_x;             //lower bound of the first region in y
for (j=0; j<X_REGIONS; j++){
    upper_bound_x[j+1]=upper_bound_x[j]+interval_x;
    lower_bound_x[j+1]=lower_bound_x[j]+interval_x;
}
....
if (D->values[k][col2] < upper_bound_x[j] && D->values[k][col2] > lower_bound_x[j] ){

Suggest re-write and use a bound_x[X_REGIONS+1] array and then use compare:

if (D->values[k][col2] >= bound_x[j] && D->values[k][col2] < bound_x[j] ){

Alternately, code could skip the bound[] arrays (x&y) and calculate bounds on the fly.

Minor:

Repeated code: Make helper functions to calculate min and max and then cal once each to calculate for the x and the y.

Code should post definition of CSV. It is confusion to have x in one column and y in another. Better to have a array of point (Make own struct holding an x and y), rather than an array of double pairs.

Be sure to #include <math.h>

来源：https://stackoverflow.com/questions/30424292/precision-of-comparing-double-values-with-epsilon-in-c

标签

floating-point

double

epsilon