Bagaimana cara menerapkan infinity di Java?

Apakah Java memiliki sesuatu yang merepresentasikan tak terhingga untuk setiap tipe data numerik? Bagaimana ini diterapkan sehingga saya dapat melakukan operasi matematika dengannya?

Misalnya

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

Saya telah mencoba menggunakan jumlah yang sangat besar, tetapi saya menginginkan solusi yang tepat dan mudah .

double mendukung 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

cetakan

Infinity
NaN
-Infinity

Catatan: Infinity - Infinityadalah Bukan Nomor .

Saya kira Anda menggunakan matematika integer karena suatu alasan. Jika demikian, Anda bisa mendapatkan hasil yang secara fungsional hampir sama dengan POSITIVE_INFINITY dengan menggunakan bidang MAX_VALUE Integerkelas:

Integer myInf = Integer.MAX_VALUE;

(Dan untuk NEGATIVE_INFINITY Anda dapat menggunakan MIN_VALUE.) Tentu saja akan ada beberapa perbedaan fungsi, misalnya, saat membandingkan myInfdengan nilai yang kebetulan MAX_VALUE: jelas angka ini tidak kurang dari myInf.

Ada juga pustaka yang sebenarnya memiliki bidang POSITIVE_INFINITY dan NEGATIVE_INFINITY, tetapi itu hanyalah nama baru untuk MAX_VALUE dan MIN_VALUE.

Untuk menggunakan Infinity, Anda dapat menggunakan Doubleyang mendukung 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

Jenis Doubledan Floatmemiliki POSITIVE_INFINITYkonstanta.

Saya tidak yakin bahwa Java memiliki tak terhingga untuk setiap tipe numerik tetapi untuk beberapa tipe data numerik jawabannya positif:

Float.POSITIVE_INFINITY
Float.NEGATIVE_INFINITY

atau

Double.POSITIVE_INFINITY
Double.NEGATIVE_INFINITY

Juga Anda mungkin menemukan berguna artikel berikut yang mewakili beberapa operasi matematika yang melibatkan +/- infinity: Java Floating-Point Number Intricacies .

Hanya POSITIVE_INFINITYkonstanta pendukung tipe Double dan Float .

Untuk jenis pembungkus numerik.

misalnya Double.POSITVE_INFINITY

Semoga ini bisa membantu Anda.

Solusi umum adalah dengan memperkenalkan tipe baru. Ini mungkin lebih terlibat, tetapi memiliki keuntungan bekerja untuk semua jenis yang tidak menentukan ketidakterbatasannya sendiri.

Jika Tadalah tipe yang lteqdidefinisikan, Anda dapat mendefinisikan InfiniteOr<T>dengan lteqsesuatu seperti ini:

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

Saya akan menyerahkannya kepada Anda untuk menerjemahkan ini ke sintaks Java yang tepat. Saya berharap idenya jelas; tapi biarkan aku mengejanya.

Idenya adalah untuk membuat tipe baru yang memiliki semua nilai yang sama dengan beberapa tipe yang sudah ada, ditambah satu nilai khusus yang — sejauh yang dapat Anda katakan melalui metode publik — bertindak persis seperti yang Anda inginkan untuk bertindak tanpa batas, misalnya lebih besar dari ada yang lain. Saya menggunakan nulluntuk merepresentasikan infinity di sini, karena itu tampaknya yang paling mudah di Java.

Jika Anda ingin menambahkan operasi aritmatika, putuskan apa yang harus dilakukan, lalu terapkan. Ini mungkin paling sederhana jika Anda menangani kasus tak hingga terlebih dahulu, kemudian menggunakan kembali operasi yang ada pada nilai hingga dari tipe asli.

Mungkin ada atau mungkin tidak ada pola umum tentang manfaat atau tidaknya mengadopsi konvensi penanganan infinitas sisi kiri sebelum infinitas sisi kanan atau sebaliknya; Saya tidak tahu tanpa mencobanya, tetapi untuk kurang dari atau sama ( lteq) saya pikir lebih mudah untuk melihat infinity sisi kanan terlebih dahulu. Saya perhatikan bahwa lteqini tidak komutatif, tetapi adddan muladalah; mungkin itu relevan.

Catatan: mendapatkan definisi yang baik tentang apa yang seharusnya terjadi pada nilai tak terbatas tidak selalu mudah. Ini untuk perbandingan, penjumlahan dan perkalian, tapi mungkin bukan pengurangan. Juga, ada perbedaan antara bilangan kardinal dan ordinal tak terhingga yang mungkin ingin Anda perhatikan.

Karena nomor kelas belum final, ini adalah ide, yang belum saya temukan di posting lain. Yakni untuk mensubkelas Nomor kelas.

Ini entah bagaimana akan mengirimkan objek yang dapat diperlakukan sebagai tak terhingga untuk Integer, Long, Double, Float, BigInteger dan BigDecimal.

Karena hanya ada dua nilai, kita bisa menggunakan pola singleton:

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;
    }
}

Entah bagaimana saya pikir metode yang tersisa intValue (), longValue () dll .. kemudian harus diganti untuk membuang pengecualian. Sehingga nilai infinity tidak bisa digunakan tanpa tindakan pencegahan lebih lanjut.

Saya seorang pemula di Java ... Saya menemukan implementasi lain untuk infinity dalam dokumentasi Java, untuk booleandan doubletipe. https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.3

Nol positif dan nol negatif sebanding; jadi hasil ekspresi 0.0 == - 0.0 benar dan hasil 0.0> -0.0 salah. Tetapi operasi lain dapat membedakan nol positif dan negatif; Misalnya 1,0 / 0,0 memiliki nilai positif tak terhingga, sedangkan nilai 1,0 / -0,0 adalah tak terhingga negatif.

Ini terlihat jelek, tapi berhasil.

public class Main {

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

}