วิธีการใช้อินฟินิตี้ใน Java?

Java มีอะไรที่แสดงถึงอนันต์สำหรับข้อมูลตัวเลขทุกชนิดหรือไม่ มันนำไปใช้อย่างไรเช่นที่ฉันสามารถดำเนินการทางคณิตศาสตร์กับมันได้หรือไม่

เช่น

int myInf = infinity; //However it is done
myInf + 5; //returns infinity
myInf*(-1); //returns negative infinity

ฉันได้ลองใช้จำนวนมาก แต่ฉันต้องการทางออกที่เหมาะสมและง่าย

double รองรับอินฟินิตี้

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

พิมพ์

Infinity
NaN
-Infinity

หมายเหตุ: Infinity - Infinityเป็นไม่จำนวน

ฉันคิดว่าคุณกำลังใช้เลขจำนวนเต็มด้วยเหตุผล ถ้าเป็นเช่นนั้นคุณจะได้รับผลลัพธ์ที่เกือบจะเหมือนกับ POSITIVE_INFINITY โดยใช้ฟิลด์ MAX_VALUE ของIntegerชั้นเรียน:

Integer myInf = Integer.MAX_VALUE;

(และสำหรับ NEGATIVE_INFINITY คุณสามารถใช้ MIN_VALUE.) มีแน่นอนจะทำงานบางอย่างแตกต่างเช่นเมื่อเปรียบเทียบmyInfค่าที่เกิดขึ้นจะเป็น MAX_VALUE A: myInfอย่างชัดเจนจำนวนนี้มีไม่น้อยกว่า

นอกจากนี้ยังมีห้องสมุดที่มีฟิลด์ POSITIVE_INFINITY และ NEGATIVE_INFINITY จริง ๆ แต่จริง ๆ แล้วเป็นเพียงชื่อใหม่สำหรับ MAX_VALUE และ MIN_VALUE

วิธีใช้Infinityคุณสามารถใช้Doubleสิ่งที่รองรับ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);

ผลลัพธ์ : -

Infinity
-Infinity
-Infinity

Infinity 
NaN

DoubleและFloatประเภทที่มีPOSITIVE_INFINITYอย่างต่อเนื่อง

ฉันไม่แน่ใจว่า Java มีอินฟินิตี้สำหรับตัวเลขทุกประเภท แต่สำหรับข้อมูลตัวเลขบางประเภทคำตอบนั้นเป็นค่าบวก:

Float.POSITIVE_INFINITY
Float.NEGATIVE_INFINITY

หรือ

Double.POSITIVE_INFINITY
Double.NEGATIVE_INFINITY

นอกจากนี้คุณอาจพบว่ามีประโยชน์บทความต่อไปนี้ซึ่งหมายถึงการดำเนินการทางคณิตศาสตร์บางส่วนที่เกี่ยวข้องกับการ +/- อินฟินิตี้: Java Floating-Point จำนวนซับซ้อน

เฉพาะคู่และประเภทลอยการสนับสนุนPOSITIVE_INFINITYอย่างต่อเนื่อง

สำหรับประเภทที่ห่อหุ้มตัวเลข

เช่น Double.POSITVE_INFINITY

หวังว่านี่จะช่วยคุณได้

วิธีแก้ปัญหาทั่วไปคือการแนะนำรูปแบบใหม่ อาจมีส่วนเกี่ยวข้องมากกว่า แต่มีข้อได้เปรียบในการทำงานกับประเภทใด ๆ ที่ไม่ได้กำหนดขอบเขตของตัวเอง

หากTเป็นประเภทที่lteqกำหนดไว้คุณสามารถกำหนดInfiniteOr<T>ด้วยlteqบางสิ่งดังนี้:

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())

ฉันจะปล่อยให้คุณแปลสิ่งนี้เป็นไวยากรณ์ Java ที่แน่นอน ฉันหวังว่าความคิดนั้นชัดเจน แต่ให้ฉันสะกดมันออกไป

แนวคิดคือการสร้างรูปแบบใหม่ที่มีค่าเหมือนกันทั้งหมดที่มีอยู่แล้วบางประเภทรวมถึงค่าพิเศษหนึ่งอย่างที่คุณสามารถบอกได้ด้วยวิธีการสาธารณะ - ทำหน้าที่อย่างที่คุณต้องการให้อินฟินิตี้ทำ สิ่งอื่นใด ฉันใช้nullเพื่อเป็นตัวแทนอนันต์ที่นี่เนื่องจากที่ดูเหมือนตรงไปตรงมาที่สุดใน Java

หากคุณต้องการเพิ่มการดำเนินการทางคณิตศาสตร์ให้ตัดสินใจว่าควรทำอย่างไรและดำเนินการนั้น มันอาจจะง่ายที่สุดถ้าคุณจัดการกับกรณีที่ไม่มีที่สิ้นสุดก่อนจากนั้นนำการดำเนินการที่มีอยู่มาใช้ใหม่ในค่า จำกัด ของประเภทดั้งเดิม

อาจมีหรือไม่มีรูปแบบทั่วไปว่าจะเป็นประโยชน์หรือไม่ที่จะนำมาใช้เป็นแนวทางในการจัดการกับ infinities ด้านซ้ายก่อน infinities ด้านขวาหรือในทางกลับกัน; ฉันไม่สามารถบอกได้โดยไม่ต้องลอง แต่สำหรับน้อยกว่าหรือเท่ากับ ( lteq) ฉันคิดว่ามันง่ายกว่าที่จะดูอินฟินิตี้ทางด้านขวาก่อน ผมทราบว่าlteqเป็นไม่ได้สับเปลี่ยน แต่addและmulมี; อาจจะเกี่ยวข้อง

หมายเหตุ: การหาคำจำกัดความที่ดีว่าอะไรควรเกิดขึ้นกับค่าอนันต์ไม่ใช่เรื่องง่ายเสมอไป เป็นการเปรียบเทียบการบวกและการคูณ แต่อาจไม่เป็นการลบ นอกจากนี้ยังมีความแตกต่างระหว่างตัวเลขที่ไม่มีที่สิ้นสุดและลำดับที่คุณอาจต้องการที่จะใส่ใจ

เนื่องจากหมายเลขห้องเรียนยังไม่สิ้นสุดนี่เป็นแนวคิดที่ฉันยังไม่พบในโพสต์อื่น คือคลาสย่อยที่ Number

สิ่งนี้จะส่งมอบวัตถุที่สามารถถือว่าเป็นอินฟินิตี้สำหรับ Integer, Long, Double, Float, BigInteger และ BigDecimal

เนื่องจากมีเพียงสองค่าเราจึงสามารถใช้รูปแบบซิงเกิล:

public final class Infinity extends Number {
    public final static Infinity POSITIVE = new Infinity(false);
    public final static Infinity NEGATIVE = new Infinity(true);
    private boolean negative;
    private Infinity(boolean n) {
        negative = n;
    }
}

อย่างใดฉันคิดว่าวิธีที่เหลือ intValue (), longValue () ฯลฯ .. จากนั้นควรจะ overriden ที่จะโยนข้อยกเว้น เพื่อให้ค่าอนันต์ไม่สามารถใช้ได้

ฉันเป็นผู้เริ่มต้นใน Java ... ฉันพบการใช้งานอื่นสำหรับอินฟินิตี้ในเอกสารคู่มือ Java สำหรับbooleanและdoubleประเภท https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.3

ศูนย์บวกและศูนย์ลบเปรียบเทียบเท่ากับ; ดังนั้นผลลัพธ์ของนิพจน์ 0.0 == - 0.0 เป็นจริงและผลลัพธ์ของ 0.0> -0.0 เป็นเท็จ แต่การดำเนินการอื่น ๆ สามารถแยกแยะความแตกต่างระหว่างศูนย์บวกและลบ ตัวอย่างเช่น 1.0 / 0.0 มีค่าบวกอนันต์ในขณะที่ค่า 1.0 / -0.0 เป็นค่าลบอนันต์

มันดูน่าเกลียด แต่มันใช้ได้

public class Main {

    public static void main(String[] args) {
        System.out.println(1.0/0.0);
        System.out.println(-1.0/0.0);
    }

}