How to implement infinity in Java?

后端 未结 10 1276
别跟我提以往
别跟我提以往 2020-11-28 03:02

Does Java have anything to represent infinity for every numerical data type? How is it implemented such that I can do mathematical operations with it?

E.g.



        
相关标签:
10条回答
  • 2020-11-28 03:22

    double supports Infinity

    double inf = Double.POSITIVE_INFINITY;
    System.out.println(inf + 5);
    System.out.println(inf - inf); // same as Double.NaN
    System.out.println(inf * -1); // same as Double.NEGATIVE_INFINITY
    

    prints

    Infinity
    NaN
    -Infinity
    

    note: Infinity - Infinity is Not A Number.

    0 讨论(0)
  • 2020-11-28 03:26

    Only Double and Float type support POSITIVE_INFINITY constant.

    0 讨论(0)
  • 2020-11-28 03:28

    A generic solution is to introduce a new type. It may be more involved, but it has the advantage of working for any type that doesn't define its own infinity.

    If T is a type for which lteq is defined, you can define InfiniteOr<T> with lteq something like this:

    class InfiniteOr with type parameter T:
        field the_T of type null-or-an-actual-T
        isInfinite()
            return this.the_T == null
        getFinite():
            assert(!isInfinite());
            return this.the_T
        lteq(that)
            if that.isInfinite()
                return true
            if this.isInfinite()
                return false
            return this.getFinite().lteq(that.getFinite())
    

    I'll leave it to you to translate this to exact Java syntax. I hope the ideas are clear; but let me spell them out anyways.

    The idea is to create a new type which has all the same values as some already existing type, plus one special value which—as far as you can tell through public methods—acts exactly the way you want infinity to act, e.g. it's greater than anything else. I'm using null to represent infinity here, since that seems the most straightforward in Java.

    If you want to add arithmetic operations, decide what they should do, then implement that. It's probably simplest if you handle the infinite cases first, then reuse the existing operations on finite values of the original type.

    There might or might not be a general pattern to whether or not it's beneficial to adopt a convention of handling left-hand-side infinities before right-hand-side infinities or vice versa; I can't tell without trying it out, but for less-than-or-equal (lteq) I think it's simpler to look at right-hand-side infinity first. I note that lteq is not commutative, but add and mul are; maybe that is relevant.

    Note: coming up with a good definition of what should happen on infinite values is not always easy. It is for comparison, addition and multiplication, but maybe not subtraction. Also, there is a distinction between infinite cardinal and ordinal numbers which you may want to pay attention to.

    0 讨论(0)
  • 2020-11-28 03:31

    I'm a beginner in Java... I found another implementation for the infinity in the Java documentation, for the boolean and double types. https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.3

    Positive zero and negative zero compare equal; thus the result of the expression 0.0==-0.0 is true and the result of 0.0>-0.0 is false. But other operations can distinguish positive and negative zero; for example, 1.0/0.0 has the value positive infinity, while the value of 1.0/-0.0 is negative infinity.

    It looks ugly, but it works.

    public class Main {
    
        public static void main(String[] args) {
            System.out.println(1.0/0.0);
            System.out.println(-1.0/0.0);
        }
    
    }
    
    0 讨论(0)
  • 2020-11-28 03:37

    To use Infinity, you can use Double which supports Infinity: -

        System.out.println(Double.POSITIVE_INFINITY);
        System.out.println(Double.POSITIVE_INFINITY * -1);
        System.out.println(Double.NEGATIVE_INFINITY);
    
        System.out.println(Double.POSITIVE_INFINITY - Double.NEGATIVE_INFINITY);
        System.out.println(Double.POSITIVE_INFINITY - Double.POSITIVE_INFINITY);
    

    OUTPUT: -

    Infinity
    -Infinity
    -Infinity
    
    Infinity 
    NaN
    
    0 讨论(0)
  • 2020-11-28 03:37

    For the numeric wrapper types.

    e.g Double.POSITVE_INFINITY

    Hope this might help you.

    0 讨论(0)
提交回复
热议问题