Check if number has passed certain boundary

I have a Thermostat that calls tempChange(oldTemp, newTemp) when the temperature changes by 0.1*C which is too frequent for my use case. I want to add an if() to filter out when the temperature has hits or passes a half or whole degree.

I am not sure how I would even begin with coding hasNewTempPassedHalfOrWholeDegree(oldTemp, newTemp).

public void tempChange(Double oldTemp, Double newTemp) {
    if (hasNewTempPassedHalfOrWholeDegree(oldTemp, newTemp)) {
        // temperature is valid to process
    }
}

A valid temperature change would be one where the new temperature has passed a half or whole degree (ie: 20.0, 20.5, 21.0, 21.5). In other words, as @Aioros as worded: I am trying to find the "interval between the two temperatures [that] includes a whole number or a whole number + 0.5.".

Example of temperature timeline and expected results:

{ oldTemp:19.7, newTemp:20.0 } // valid
{ oldTemp:20.0, newTemp:20.2 } // not valid
{ oldTemp:20.2, newTemp:20.6 } // valid
{ oldTemp:20.6, newTemp:21.7 } // valid
{ oldTemp:21.7, newTemp:21.6 } // not valid
{ oldTemp:21.6, newTemp:21.5 } // valid
{ oldTemp:21.5, newTemp:21.2 } // not valid
{ oldTemp:21.2, newTemp:20.2 } // valid
{ oldTemp:20.2, newTemp:20.1 } // not valid

Here's one way to test if a temperature change crosses a .0 or a .5 boundary.

private boolean hasNewTempPassedHalfOrWholeDegree(Double oldTemp, Double newTemp) {
    int oldTempInt = Math.round(10d * oldTemp);
    int newTempInt = Math.round(10d * newTemp);
    int start = Math.min(oldTempInt,  newTempInt);
    int end = Math.max(oldTempInt,  newTempInt);
    
    for (int index = start; index <= end; index += 10) {
    	if (index % 50 == 0) {
    		return true;
    	}
    }
    
    return false;
}

A very simple (not elegant) way could be to convert your Double values to BigDecimal and iterate over the range checking if any value in between leaves a remainder of zero when divided by 0.5 using a classic for loop:

public static void main(String[] args){
double[][] test = {
{19.7, 20.0}, // valid
{20.0, 20.2}, // not valid
{20.2, 20.6}, // valid
{20.6, 21.7}, // valid
{21.7, 21.6}, // not valid
{21.6, 21.5}, // valid
{21.5, 21.2}, // not valid
{21.2, 20.2}, // valid
{20.2, 20.1}, // not valid
};
for(double[] d : test){
boolean b = hasNewTempPassedHalfOrWholeDegree(d[0],d[1]);
System.out.println(Arrays.toString(d) + (b ? "valid" : "not valid"));
}
}
static boolean hasNewTempPassedHalfOrWholeDegree(Double oldTemp, Double newTemp) {
BigDecimal x = new BigDecimal(String.valueOf(oldTemp));
BigDecimal y = new BigDecimal(String.valueOf(newTemp));
BigDecimal d = new BigDecimal("0.1");
BigDecimal h = new BigDecimal("0.5");
if(x.compareTo(y) == 0){
return false;
}
else if(x.compareTo(y) < 0){
for (BigDecimal i = x.add(d); i.compareTo(y) <= 0; i = i.add(d)) {
if (i.remainder(h).compareTo(BigDecimal.ZERO) == 0) {
return true;
}
}
}
else {
for (BigDecimal i = x.subtract(d); i.compareTo(y) >= 0; i = i.subtract(d)) {
if (i.remainder(h).compareTo(BigDecimal.ZERO) == 0) {
return true;
}
}
}
return false;
}

If I understand correctly what you're looking for, you could notice that the interval between two numbers a and b includes an integer or a integer-and-a-half when:

FLOOR(2*b) > FLOOR(2*a).

So your condition would look like:

if (Math.floor(2*newTemp) != Math.floor(2*oldTemp)) {
// valid
} else {
// not valid
}