I tried to compare if grids in two rasters are the same, one raster is FCELL and another raster is DCELL. I got different result when I int both raster first before comparing them; and when I float() both raster first before I comparing them
Is there some reason that you expect the rasters to be the same? Maybe
begin by posting the outputs of `r.info` for both rasters, and what
command you used to compare them?
On Sun, Jan 24, 2021 at 6:13 AM ming han <dustming@gmail.com> wrote:
Hi Everyone
I tried to compare if grids in two rasters are the same, one raster is FCELL and another raster is DCELL. I got different result when I int both raster first before comparing them; and when I float() both raster first before I comparing them
Is there some reason that you expect the rasters to be the same? Maybe
begin by posting the outputs of [r.info](http://r.info) for both rasters, and what
command you used to compare them?
I tried to compare if grids in two rasters are the same, one raster is FCELL and another raster is DCELL. I got different result when I int both raster first before comparing them; and when I float() both raster first before I comparing them
Is there some reason that you expect the rasters to be the same? Maybe
begin by posting the outputs of `r.info` for both rasters, and what
command you used to compare them?
On Sun, Jan 24, 2021 at 6:13 AM ming han <dustming@gmail.com> wrote:
>
> Hi Everyone
>
> I tried to compare if grids in two rasters are the same, one raster is FCELL and another raster is DCELL. I got different result when I int both raster first before comparing them; and when I float() both raster first before I comparing them
>
> Is there any reason for this?
>
> Thanks
> Ming
> _______________________________________________
> grass-user mailing list
> grass-user@lists.osgeo.org
> https://lists.osgeo.org/mailman/listinfo/grass-user
The str_r is a CELL raster. the result is different when I change it to:
if(int(cat1_acc_riv) == int(cat1_minacc), str_r, null())
Note that numerical "equality" is better tested with a threshold test
against the map pixel difference.
As the threshold, we use GRASS_EPSILON which is defined as 1.0e-15.
Hence the test needs to be implemented in a different way, i.e. by
using an epsilon.
Essentially something like this:
if(fabs(map_A - map_B) <= 1.0e-15, ... )
In your case (untested):
r.mapcalc diffepsilon = if( abs( map_A - map_B) <= 1.0e-15, str_r , null())
See related discussions here: [1], [2] and elsewhere.
The str_r is a CELL raster. the result is different when I change it to:
if(int(cat1_acc_riv) == int(cat1_minacc), str_r, null())
Note that numerical “equality” is better tested with a threshold test
against the map pixel difference.
As the threshold, we use GRASS_EPSILON which is defined as 1.0e-15.
Hence the test needs to be implemented in a different way, i.e. by
using an epsilon.
Essentially something like this:
if(fabs(map_A - map_B) <= 1.0e-15, … )
In your case (untested):
r.mapcalc diffepsilon = if( abs( map_A - map_B) <= 1.0e-15, str_r , null())
See related discussions here: [1], [2] and elsewhere.
Trying to answer the original question: with a DCELL map “cat1_acc_riv” and a FCELL map “cat1_minacc”, why is “float(cat1_acc_riv) == float(cat1_minacc)” not equal to “int(cat1_acc_riv) == int(cat1_minacc)” ?
int truncates to integer while float converts to single precision floating point. E.g. with cat1_acc_riv = 1.1 and cat1_minacc = 1.9, “float(cat1_acc_riv) == float(cat1_minacc)” becomes “1.1 == 1.9” whereas “int(cat1_acc_riv) == int(cat1_minacc)” becomes “1 == 1”, thus the results are different.
Another reason for possible differences is that float can only represent max 7 decimal digits. E.g. float(194320567) becomes 194320560 but int(194320567) preserves the value 194320567.
Thus the safest is to cast everything to the type with the highest precision. In this case with FCELL and DCELL, use “double(cat1_acc_riv) == double(cat1_minacc)” or even better the suggestion of Markus N.
The str_r is a CELL raster. the result is different when I change it to:
if(int(cat1_acc_riv) == int(cat1_minacc), str_r, null())
Note that numerical “equality” is better tested with a threshold test
against the map pixel difference.
As the threshold, we use GRASS_EPSILON which is defined as 1.0e-15.
Hence the test needs to be implemented in a different way, i.e. by
using an epsilon.
Essentially something like this:
if(fabs(map_A - map_B) <= 1.0e-15, … )
In your case (untested):
r.mapcalc diffepsilon = if( abs( map_A - map_B) <= 1.0e-15, str_r , null())
See related discussions here: [1], [2] and elsewhere.
Trying to answer the original question: with a DCELL map “cat1_acc_riv” and a FCELL map “cat1_minacc”, why is “float(cat1_acc_riv) == float(cat1_minacc)” not equal to “int(cat1_acc_riv) == int(cat1_minacc)” ?
int truncates to integer while float converts to single precision floating point. E.g. with cat1_acc_riv = 1.1 and cat1_minacc = 1.9, “float(cat1_acc_riv) == float(cat1_minacc)” becomes “1.1 == 1.9” whereas “int(cat1_acc_riv) == int(cat1_minacc)” becomes “1 == 1”, thus the results are different.
Another reason for possible differences is that float can only represent max 7 decimal digits. E.g. float(194320567) becomes 194320560 but int(194320567) preserves the value 194320567.
Thus the safest is to cast everything to the type with the highest precision. In this case with FCELL and DCELL, use “double(cat1_acc_riv) == double(cat1_minacc)” or even better the suggestion of Markus N.
The str_r is a CELL raster. the result is different when I change it to:
if(int(cat1_acc_riv) == int(cat1_minacc), str_r, null())
Note that numerical “equality” is better tested with a threshold test
against the map pixel difference.
As the threshold, we use GRASS_EPSILON which is defined as 1.0e-15.
Hence the test needs to be implemented in a different way, i.e. by
using an epsilon.
Essentially something like this:
if(fabs(map_A - map_B) <= 1.0e-15, … )
In your case (untested):
r.mapcalc diffepsilon = if( abs( map_A - map_B) <= 1.0e-15, str_r , null())
See related discussions here: [1], [2] and elsewhere.
Hi,
Is it important to cross-post this discussion on both dev and user lists?
Regards,
Zoltan
···
On 2021-01-24 17:56, Markus Metz wrote:
Trying to answer the original question: with a DCELL map “cat1_acc_riv” and a FCELL map “cat1_minacc”, why is “float(cat1_acc_riv) == float(cat1_minacc)” not equal to “int(cat1_acc_riv) == int(cat1_minacc)” ?
int truncates to integer while float converts to single precision floating point. E.g. with cat1_acc_riv = 1.1 and cat1_minacc = 1.9, “float(cat1_acc_riv) == float(cat1_minacc)” becomes “1.1 == 1.9” whereas “int(cat1_acc_riv) == int(cat1_minacc)” becomes “1 == 1”, thus the results are different.
Another reason for possible differences is that float can only represent max 7 decimal digits. E.g. float(194320567) becomes 194320560 but int(194320567) preserves the value 194320567.
Thus the safest is to cast everything to the type with the highest precision. In this case with FCELL and DCELL, use “double(cat1_acc_riv) == double(cat1_minacc)” or even better the suggestion of Markus N.
The str_r is a CELL raster. the result is different when I change it to:
if(int(cat1_acc_riv) == int(cat1_minacc), str_r, null())
Note that numerical “equality” is better tested with a threshold test
against the map pixel difference.
As the threshold, we use GRASS_EPSILON which is defined as 1.0e-15.
Hence the test needs to be implemented in a different way, i.e. by
using an epsilon.
Essentially something like this:
if(fabs(map_A - map_B) <= 1.0e-15, … )
In your case (untested):
r.mapcalc diffepsilon = if( abs( map_A - map_B) <= 1.0e-15, str_r , null())
See related discussions here: [1], [2] and elsewhere.
Hi,
Is it important to cross-post this discussion on both dev and user lists?
Regards,
Zoltan
On 2021-01-24 17:56, Markus Metz wrote:
Trying to answer the original question: with a DCELL map “cat1_acc_riv” and a FCELL map “cat1_minacc”, why is “float(cat1_acc_riv) == float(cat1_minacc)” not equal to “int(cat1_acc_riv) == int(cat1_minacc)” ?
int truncates to integer while float converts to single precision floating point. E.g. with cat1_acc_riv = 1.1 and cat1_minacc = 1.9, “float(cat1_acc_riv) == float(cat1_minacc)” becomes “1.1 == 1.9” whereas “int(cat1_acc_riv) == int(cat1_minacc)” becomes “1 == 1”, thus the results are different.
Another reason for possible differences is that float can only represent max 7 decimal digits. E.g. float(194320567) becomes 194320560 but int(194320567) preserves the value 194320567.
Thus the safest is to cast everything to the type with the highest precision. In this case with FCELL and DCELL, use “double(cat1_acc_riv) == double(cat1_minacc)” or even better the suggestion of Markus N.
The str_r is a CELL raster. the result is different when I change it to:
if(int(cat1_acc_riv) == int(cat1_minacc), str_r, null())
Note that numerical “equality” is better tested with a threshold test
against the map pixel difference.
As the threshold, we use GRASS_EPSILON which is defined as 1.0e-15.
Hence the test needs to be implemented in a different way, i.e. by
using an epsilon.
Essentially something like this:
if(fabs(map_A - map_B) <= 1.0e-15, … )
In your case (untested):
r.mapcalc diffepsilon = if( abs( map_A - map_B) <= 1.0e-15, str_r , null())
See related discussions here: [1], [2] and elsewhere.
Many thanks for your help. Is if(fabs(map_A - map_B) <= 1.0e-15, … ) approach may increase the runtime compare to ‘==’ way?
The formulas are very simple, I don’t think that differences in runtime can be reliably measured. (De-)compression of the data and the operating system’s file cache have a much stronger influence on the runtime.
Trying to answer the original question: with a DCELL map “cat1_acc_riv” and a FCELL map “cat1_minacc”, why is “float(cat1_acc_riv) == float(cat1_minacc)” not equal to “int(cat1_acc_riv) == int(cat1_minacc)” ?
int truncates to integer while float converts to single precision floating point. E.g. with cat1_acc_riv = 1.1 and cat1_minacc = 1.9, “float(cat1_acc_riv) == float(cat1_minacc)” becomes “1.1 == 1.9” whereas “int(cat1_acc_riv) == int(cat1_minacc)” becomes “1 == 1”, thus the results are different.
Another reason for possible differences is that float can only represent max 7 decimal digits. E.g. float(194320567) becomes 194320560 but int(194320567) preserves the value 194320567.
Thus the safest is to cast everything to the type with the highest precision. In this case with FCELL and DCELL, use “double(cat1_acc_riv) == double(cat1_minacc)” or even better the suggestion of Markus N.
The str_r is a CELL raster. the result is different when I change it to:
if(int(cat1_acc_riv) == int(cat1_minacc), str_r, null())
Note that numerical “equality” is better tested with a threshold test
against the map pixel difference.
As the threshold, we use GRASS_EPSILON which is defined as 1.0e-15.
Hence the test needs to be implemented in a different way, i.e. by
using an epsilon.
Essentially something like this:
if(fabs(map_A - map_B) <= 1.0e-15, … )
In your case (untested):
r.mapcalc diffepsilon = if( abs( map_A - map_B) <= 1.0e-15, str_r , null())
See related discussions here: [1], [2] and elsewhere.
No inconvenience - general list etiquette usually says start with ‘user’ and then move to ‘dev’ if it looks like a SW issue.
But I am NOT lecturing you, so please do not take offense.
Keep well,
Zoltan
···
On 2021-01-24 18:28, ming han wrote:
sorry for the inconvenience. I was just not sure if it is problem that needs developers to answer.
Best regards
Ming
Hi,
Is it important to cross-post this discussion on both dev and user lists?
Regards,
Zoltan
On 2021-01-24 17:56, Markus Metz wrote:
Trying to answer the original question: with a DCELL map “cat1_acc_riv” and a FCELL map “cat1_minacc”, why is “float(cat1_acc_riv) == float(cat1_minacc)” not equal to “int(cat1_acc_riv) == int(cat1_minacc)” ?
int truncates to integer while float converts to single precision floating point. E.g. with cat1_acc_riv = 1.1 and cat1_minacc = 1.9, “float(cat1_acc_riv) == float(cat1_minacc)” becomes “1.1 == 1.9” whereas “int(cat1_acc_riv) == int(cat1_minacc)” becomes “1 == 1”, thus the results are different.
Another reason for possible differences is that float can only represent max 7 decimal digits. E.g. float(194320567) becomes 194320560 but int(194320567) preserves the value 194320567.
Thus the safest is to cast everything to the type with the highest precision. In this case with FCELL and DCELL, use “double(cat1_acc_riv) == double(cat1_minacc)” or even better the suggestion of Markus N.
The str_r is a CELL raster. the result is different when I change it to:
if(int(cat1_acc_riv) == int(cat1_minacc), str_r, null())
Note that numerical “equality” is better tested with a threshold test
against the map pixel difference.
As the threshold, we use GRASS_EPSILON which is defined as 1.0e-15.
Hence the test needs to be implemented in a different way, i.e. by
using an epsilon.
Essentially something like this:
if(fabs(map_A - map_B) <= 1.0e-15, … )
In your case (untested):
r.mapcalc diffepsilon = if( abs( map_A - map_B) <= 1.0e-15, str_r , null())
See related discussions here: [1], [2] and elsewhere.
A note about the usage of GRASS_EPSILON = 1.0e-15:
The range of single precision floating point is about 1.4012984643e−45 to 3.4028234664e38
That means for large numbers, using GRASS_EPSILON will also detect floating point precision limits, not only meaningful differences. For small numbers, GRASS_EPSILON will not detect meaningful differences. GRASS_EPSILON could instead be modified with something like “max(abs(map_A), abs(map_B)) * 1.0e-15” to test for meaningful differences.
Many thanks for your help. Is if(fabs(map_A - map_B) <= 1.0e-15, … ) approach may increase the runtime compare to ‘==’ way?
The formulas are very simple, I don’t think that differences in runtime can be reliably measured. (De-)compression of the data and the operating system’s file cache have a much stronger influence on the runtime.
Trying to answer the original question: with a DCELL map “cat1_acc_riv” and a FCELL map “cat1_minacc”, why is “float(cat1_acc_riv) == float(cat1_minacc)” not equal to “int(cat1_acc_riv) == int(cat1_minacc)” ?
int truncates to integer while float converts to single precision floating point. E.g. with cat1_acc_riv = 1.1 and cat1_minacc = 1.9, “float(cat1_acc_riv) == float(cat1_minacc)” becomes “1.1 == 1.9” whereas “int(cat1_acc_riv) == int(cat1_minacc)” becomes “1 == 1”, thus the results are different.
Another reason for possible differences is that float can only represent max 7 decimal digits. E.g. float(194320567) becomes 194320560 but int(194320567) preserves the value 194320567.
Thus the safest is to cast everything to the type with the highest precision. In this case with FCELL and DCELL, use “double(cat1_acc_riv) == double(cat1_minacc)” or even better the suggestion of Markus N.
The str_r is a CELL raster. the result is different when I change it to:
if(int(cat1_acc_riv) == int(cat1_minacc), str_r, null())
Note that numerical “equality” is better tested with a threshold test
against the map pixel difference.
As the threshold, we use GRASS_EPSILON which is defined as 1.0e-15.
Hence the test needs to be implemented in a different way, i.e. by
using an epsilon.
Essentially something like this:
if(fabs(map_A - map_B) <= 1.0e-15, … )
In your case (untested):
r.mapcalc diffepsilon = if( abs( map_A - map_B) <= 1.0e-15, str_r , null())
See related discussions here: [1], [2] and elsewhere.