Variable auf unendlich setzen

[koerschgen2001]

Hallo zusammen,

in einigen Graphenalgorithmen muss man ja Variablen erstmal auf unendlich setzen. Da das Ganze in der Programmierung nicht möglich ist möchte ich das aber symbolisch implementieren.

Und zwar eine Klasse mit einem boolean der anzeigt ob die Variable unendlich ist oder nicht.
wenn dann ein Objekt dieser Klasse mit einem Wert gefüllt wird wird der boolean auf false gesetzt und der Wertebereich auf Integer.MAX_VALUE (es sollen nur Integer möglich sein).

Ich habe nur ein Problem mit der Typenkonvertierung. Wenn ich ein Array dieser Klasse erzeuge

 public static void main(String args[]) {
    Infinity[] q = new Infinity[8];

  //....
  }

kann ich nicht ohne weiteres int Werte einlesen da Werte vom Typ Infinity erwartet werden.
Ich habe schon versucht eine Methode setWert zum einlesen von Integern zu schreiben, aber da bekomme ich wieder Probleme mit dem Array.

Im Prinzip möchte ich nur ein Array das bei der Erzeugung alle Wert symbolisch auf unendlich setzt, die dann aber nach und nach mit Integer gefüllt werden.

Hier mal der Teil vom Code ohne Fehler

public class Infinity {
  boolean infinity;
  
  
  public Infinity() {
    infinity = true;
  }
  
  public boolean getInfinity() {
    return infinity;
  }


}

Wie muss ich dass denn jetzt ergänzen damits funktioniert, ich steh ein wenig auf dem Schlau. Tips?

 

[The_S]

in deine Infinity-Klasse noch eine Variable für den Integer wert anlegen? Aber irgendwie scheint es mir so, als ob du nen völlig falschen Ansatz hast .

 

[Prusik]

Meinst du eventuell das?

public class zahl{
    bool isInfinity;
    int zahl;
    public zahl(){
        isInfinity =true;
        zahl = Integer.MAX_VALUE;
    }
    //setter und getter Methoden

     public setZahl(int zahl){
         this.zahl = zahl;
         if(zahl < Integer.MAX_VALUE){
              isInfinity = false;
         }
     }
}

und nun ein Array daraus:

zahl[] zarray = new zahl[8];

 

[koerschgen2001]

Ja, sowas in der Art hab ich auch schon gebastelt. Mein Problem liegt jetzt im Zugriff auf ein Array vom Typ Zahl.

 public int getZahl(int i) {
      return zahl[i];
    }

     public static void main(String args[]) {
       Zahl[] z = new Zahl[3];
       z[0].setZahl(1);
       z[1].setZahl(2);
       z[2].setZahl(3);

       for(int i = 0;i<z.length;i++) {
         System.out.println(z.getZahl(i));
       }
// Anmerkung: Ich habe hier die Klasse Zahl groß geschrieben um es besser von der 
// Variable zahl unterscheiden zu können.
     }

Der Compiler gibt mir andauernd ne Fehlermeldung wegen dem Typ, dass er ein Array erwartet. Ich habe schon alle möglichen Rückgabetypen bei getZahl() versucht (Zahl, int[]...), auf z direkt kann ich ja auch nicht zugreifen.

 

[Joker]

pack noch eine Methode isInfinity() dazu, dann sollte das passen.

Solltest du nur den positiven Zahlenraum benötigen kannst du vor die Unendlichekeit auch einfach -1 nehmen.

 

[koerschgen2001]

Ich steh immer noch aufm Schlauch und verstehe den Zusammenhang gerade nicht. Ich möchte den Wert also den Integer auslesen, was bringt mir dann ne Methode isInfinity() ?

 

[Illuvatar]

Wenn du mit double oder float Zahlen rechnest, kannst du auch Double.POSITIVE_INFINITY / Double.NEGATIVE_INFINITY (bzw. die entsprechenden Konstanten in Float) verwenden...

 

[koerschgen2001]

Ich lese eigentlich Daten aus einem Graphen aus, also Knoten und (gewichtete) Kanten und das sind alle nur Integer.
Und aus dem Array soll mal meine Prioritätswarteschlange werden (einfache Liste geht ja auch). Diese wird im Algorithmus am Anfang auf unendlich gesetzt (Dijkstra Algorithmus).

 

[Guest]

public static void main(String args[]) { 
   Zahl[] z = new Zahl[3]; 
   // Hier ist dein Fehler. Zu diesem Zeitpunkt ist das Array komplett leer. Alle Elemente sind null.
   z[0].setZahl(1); 
   z[1].setZahl(2); 
   z[2].setZahl(3); 

   for(int i = 0;i<z.length;i++) { 
      System.out.println(z.getZahl(i));  // z ist ein Array, daher z[i].getWasAuchImmer()
   } 
   // Anmerkung: Ich habe hier die Klasse Zahl groß geschrieben um es besser von der 
   // Variable zahl unterscheiden zu können. 
}

Korrekte Version

public final class Zahl {
   private int value = Integer.MAX_VALUE;

   public Zahl() {
   }

   public Zahl(int value) {
      this.value = value;
   }

   public int getValue() {
      return value;
   }

   public void setValue(int value) {
      this.value = value;
   }

   public boolean isInfinity() {
      return value == Integer.MAX_VALUE;
   }

   public void setInfinity() {
      value = Integer.MAX_VALUE;
   }

   public String toString() {
      if(isInfinity()) {
         return "Infinity";
      }
      return Integer.toString(value);
   }

   public int hashCode() {
      return value;
   }

   public boolean equals(Object obj) {
      if( obj == null || !(obj instanceof Zahl)) {
         return false;
      }
      Zahl z = (Zahl)obj;
      return z.value == value;
   }
}

public static void main(String args[]) { 
   Zahl[] z = new Zahl[3]; 
   z[0] = new Zahl(1); 
   z[1] = new Zahl(2); 
   z[2] = new Zahl();  // Infinity

   for(int i = 0;i<z.length;i++) { 
      System.out.println(z[i]); 
   } 
}

 

[Guest]

Ich lese eigentlich Daten aus einem Graphen aus, also Knoten und (gewichtete) Kanten und das sind alle nur Integer.
Und aus dem Array soll mal meine Prioritätswarteschlange werden (einfache Liste geht ja auch). Diese wird im Algorithmus am Anfang auf unendlich gesetzt (Dijkstra Algorithmus).

Für diesen Fall kannst du int-Array nehmen und es mit -1 initialisieren.
Das setzt aber voraus, dass du keine negativen Werte zu berücksichtigen brauchst.

int []zahlen = new int[1000000]; // Ein Haufen Zahlen
java.util.Arrays.fill(zahlen, -1); // komplettes Array mit -1 füllen

 

[SebiB90]

also programmtechnisch ist unendlich möglich. der IEE754 Standard hat dafür eine BIT Folge vorgesehen.

Double.POSITIVE_INFINITY
Double.NEGATIVE_INFINITY

 

[koerschgen2001]

Das gibts aber leider nicht für Integer.

 

[SebiB90]

joar weil Integer nicht im IEE754 abgespeichert werden
wieso kannst du denn kein Double verwenden? damit kannste auch ganzzahlige zahlen darstellen.

 

[koerschgen2001]

Hab ich auch schonmal überlegt. Aber das ist eine Seminararbeit und dann kommt bestimmt vom Dozent die Frage warum ich Double benutze weil ich in meinem Algorithmus nur mit Integern arbeite. Deshalb wollte ich ja diese Elegante Lösung über die boolean infinity variable benutzen, ums theoretsich zu implementieren aber keine ressourcen zu verschwenden.

 

[The_S]

Ein float hat genauso viele Bits wie ein Integer (32). Und eine zusätzliche Variable halte ich nicht für ellegant .

 

[Guest]

Zwei Konstanten und das Problem ist weg.

public static final int POSITIVE_INFINITY = Integer.MAX_VALUE;
public static final int NEGATIVE_INFINITY = Integer.MIN_VALUE;

Warum machst du dich mit solche Sachen verrückt? Für den Algorithmus brauchst du nur alles, was kleiner als 0 ist, als undefiniert/unendlich zu betrachten.

 

[koerschgen2001]

Ok. Dann nehme ich Double.POSITIVE_INFINITY. Das vereinfacht dann doch eniges.

 

[SebiB90]

wie schon hobbit gesagt hat
wenn du keine fragen wegen speicherverschwendung haben willst. benutz float. hat halb so viele bits wie double und hat die beiden konstanten auch.

 

[koerschgen2001]

Dann werde ich das mal so machen.

@Gast Manchmal bin ich eben ein wenig zuviel Perfektionist.

 

[Gast]

wenn dein algorithmus aber auf ganzzahlen basiert würde ich mich schon fragen warum du nun float und nicht int nimmst

 

[koerschgen2001]

Na toll, der eine sagt hot der andere hü.
Das macht mir jetzt meine ganze Planung kaputt :bae:

Wie wärs mit der Antwort, es soll Allgmeingültig sein?

 

[Guest]

Infinity hin oder her, es ist eine Frage der Präsentation. Für den Algorithmus kannst du ruhig Integer.MAX_VALUE
für unendlich verwenden. Ist dir der Zahlenbereich zu klein, nimm Long mit Long.MAX_VALUE oder von mir aus
auch BigInteger.

 

[koerschgen2001]

Dann mach ich alles.
Ich nehem Integer.MAX_VALUE verweise aber auf float bzw. Double.POSITIVE_INFINITY
(vielleicht schalge ich auch noch die infinity lösung vor), so hab ich alles Beleuchtet und jeder ist zufrieden

 

[The_S]

na also das ist jetzt wirklich schwachsinn :autsch:

 

[koerschgen2001]

Viele Wege führen nach Rom, also kann man auch alternativ Routen anbieten.

 

[The_S]

aber alles doppelt und dreifach? Oder hat das Programm wirklich nur den Sinn irgendwelche Prüfer zu beeindrucken?

 

[tincup]

Dann mach ich alles.
Ich nehem Integer.MAX_VALUE verweise aber auf float bzw. Double.POSITIVE_INFINITY
(vielleicht schalge ich auch noch die infinity lösung vor), so hab ich alles Beleuchtet und jeder ist zufrieden

Also wie Hobbit schon sagte, das ist dann eher weniger sinnvoll (und auch nicht perfektionistisch sondern eher unentschieden ).

Kann aber deinen Gedankengang absolut nachvollziehen, habe mich an solchen Dingern auch immer zerrissen. Mach bei sowas einfach so, dass es funktioniert. Und wenn du gefragt bist sag, dass das Integer Maxvalue als unendlich interpretiert wird. Und falls du dann noch aussagen kannst, dass das in Ordnung ist, weil die konkreten Werte im Algorithmus eh nie so hohe Werte erreichen, zeigt das ja nur, dass du die Methode verstanden hast.

 

[koerschgen2001]

Vielleicht hab ich mich auch falsch ausgedrückt.

Ich meinte dass ich nur eine Methode implementiere, aber in der Hausarbeit auch auf andere mögliche Varianten verweise, je nach Verwendungszweck halt.

In meinem Beispiel reicht halt Integer.MAX_VALUE weil ich nur int Werte benutze.
Wenn man aber float oder double braucht bietet sich halt die Konstante INFINITY an und die eigene Klasse ist halt nur ne theoretische Lösung (wenn mans theoretisch perfekt haben möchte) aber für den praktischen Einsatz weniger geeignet.

 

[tincup]

Ich meinte dass ich nur eine Methode implementiere, aber in der Hausarbeit auch auf andere mögliche Varianten verweise, je nach Verwendungszweck halt.

Achso, ja wenn ihr in der Hausarbeit bis auf das Detail runtergeht ist es sicherlich ein gutes Zeichen, verschiedene Implementationsvarianten aufzuzeigen.

Wenn man aber float oder double braucht bietet sich halt die Konstante INFINITY an und die eigene Klasse ist halt nur ne theoretische Lösung (wenn mans theoretisch perfekt haben möchte) aber für den praktischen Einsatz weniger geeignet.

Ich persönlich würde behaupten, dass keine Lösung "perfekter" sein kann, als die Infinity-Konstanten der beiden Gleitkommeklassen. Denn diese sind nicht nur größer (bzw. kleiner) als alle anderen Zahlen sondern verhalten sich auch noch rechnerisch halbswegs vernünftig (insofern man das bei unendlichen Werten sagen kann). Wenn du z.B. durch infinity teilst, erhältst du 0, mit Integer.MAX_VALUE klappt das nicht.

Aber das ist ja auch nicht relevant bei dieser Aufgabenstellung hier, war nur grad mal mein eigener Senf :lol: