As pkpnd stated in their comment, there is a known difference between one int and the next (ex. 4 and 5 are one integer apart). However, how far apart are two arbitrary doubles, an ulp?

One suggestion that I have to emulate a range is to use a NavigableMap:

enum Range {
    LIGHT, MODERATE, VIGOROUS, UNKNOWN
}

NavigableMap<Double, Range> map = new TreeMap<>();

map.put(Double.NEGATIVE_INFINITY, Range.UNKNOWN);
map.put(0D, Range.LIGHT);
map.put(3D, Range.MODERATE);
map.put(6D, Range.VIGOROUS);

System.out.println(map.floorEntry(4D).getValue());

Output:

MODERATE

You're free to handle out-of-range values however you'd like, as well a Double.NaN.

I fully concur with @TimothyTruckle on format, follow his advice.

Using binaries is restrictive (only two states), and not user-friendly. I don't like byte arithmetics, its quite un-Java like. I suppose you come from C/C++ background.

In more Java-like syntax, I propose a fluent interface on a Range class:

public class Range {

     private static enum RangeType{ INCLUSIVE, EXCLUSIVE, INFINITE };

     private static class RangeStart {
         private final RangeType startType;
         private final Double startValue;
         private RangeStart(RangeType type, Double value){
             this.startType = type;
             this.startValue = value;
         }
         public Range toInclusive(double endValue) {
              // Optionally check endValue >= startValue and throw something
              return new Range(startType, startValue, RangeType.INCLUSIVE, endValue);
         }
         public Range toExclusive(double endValue) {
              // Optionally check endValue >= startValue and throw something
              return new Range(startType, startValue, RangeType.EXCLUSIVE, endValue);
         }
         public Range toInfinity() {
              return new Range(startType, startValue, RangeType.INFINITY, 0.);
         }
     }

     public static RangeStart fromInfinity() {
          retur new RangeStart(RangeType.INFINITY, 0.)
     }

     public static RangeStart fromInclusive(double fromValue) {
          retur new RangeStart(RangeType.INCLUSIVE, fromValue)
     }

     public static RangeStart fromExclusive(double fromValue) {
          retur new RangeStart(RangeType.EXCLUSIVE, fromValue)
     }

     private final RangeType startType;
     private final Double startValue;
     private final RangeType endType;
     private final Double endValue;

     private Range(RangeType startType, Double startValue, RangeType endType, Double endValue) {
          this.startType  = startType;
          this.startValue = startValue;
          this.endType    = endType;
          this.endValue   = endValue;
     }

     public boolean contains(double value){
          // Do your thing here, I'm not doing all the work! ;-)
     }
}

This creates a re-usable Range object to check values. The Pattern used is similar to the Builder Pattern (I named the Builder RangeStart).

Example usage:

Range range5i7e = Range.fromInclusive(5).toExclusive(7);
range5i7e.contains(5); // true
range5i7e.contains(5); // false
Range.fromInclusive(-10).toInfinity().contains(3720); // true    Range.fromInclusive(5).toExclusive(3); // Throws something ?

Style improvements:

You may want to make inclusive the standard and use Range.from(1).to(2) to make a closed Range. It's much less verbose.

You could also make the Range infinite-ended on both sides unless otherwise told, like Range.to(5) would be ]Inf, 5] etc.

Java's Primitive Data Types

boolean: 1-bit. May take on the values true and false only.

byte: 1 signed byte (two's complement). Covers values from -128 to 127.

short: 2 bytes, signed (two's complement), -32,768 to 32,767

int: 4 bytes, signed (two's complement). -2,147,483,648 to 2,147,483,647.

long: 8 bytes signed (two's complement). Ranges from -9,223,372,036,854,775,808 to +9,223,372,036,854,775,807.

float: 4 bytes, IEEE 754. Covers a range from 1.40129846432481707e-45 to 3.40282346638528860e+38 (positive or negative).

double: 8 bytes IEEE 754. Covers a range from 4.94065645841246544e-324d to 1.79769313486231570e+308d (positive or negative).

char: 2 bytes, unsigned, Unicode, 0 to 65,535

Technically, the range of double is Double.NEGATIVE_INFINITY through Double.POSITIVE_INFINITY, and no real number is outside that range. If you want to eliminate the overflow to infinity cases, test Double.isFinite(val) after the conversion.

Double.MIN_VALUE represents the minimum positive value. (That is, a positive value close to zero.)

From the documentation:

A constant holding the smallest positive nonzero value of type double, 2^-1074.

This is the reason why

System.out.println(inRange(new BigDecimal("0.0")));
System.out.println(inRange(new BigDecimal("-987.0")));

outputs false. None of the provided values are (strictly) greater than 0.

The solution

Since the range of doubles are symmetrical around origo (as opposed to integers, which stretches one step further on the negative side) you can get the minimum (negative) value by writing -Double.MAX_VALUE. That is

BigDecimal DOUBLE_MIN = BigDecimal.valueOf(-Double.MAX_VALUE);

You could add spacing ;)

if (i > 0 && i < 100)