# Variable auf unendlich setzen



## koerschgen2001 (28. Dez 2007)

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 (28. Dez 2007)

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 (28. Dez 2007)

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 (28. Dez 2007)

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 (28. Dez 2007)

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 (28. Dez 2007)

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 (28. Dez 2007)

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 (28. Dez 2007)

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 (28. Dez 2007)

```
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 (28. Dez 2007)

koerschgen2001 hat gesagt.:
			
		

> 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 (28. Dez 2007)

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

```
Double.POSITIVE_INFINITY
Double.NEGATIVE_INFINITY
```


----------



## koerschgen2001 (28. Dez 2007)

Das gibts aber leider nicht für Integer.


----------



## SebiB90 (28. Dez 2007)

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


----------



## koerschgen2001 (28. Dez 2007)

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 (28. Dez 2007)

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


----------



## Guest (28. Dez 2007)

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 (28. Dez 2007)

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


----------



## SebiB90 (28. Dez 2007)

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 (28. Dez 2007)

Dann werde ich das mal so machen.

@Gast Manchmal bin ich eben ein wenig zuviel Perfektionist.


----------



## Gast (29. Dez 2007)

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


----------



## koerschgen2001 (29. Dez 2007)

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 (29. Dez 2007)

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 (29. Dez 2007)

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 (2. Jan 2008)

na also das ist jetzt wirklich schwachsinn :autsch:


----------



## koerschgen2001 (2. Jan 2008)

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


----------



## The_S (2. Jan 2008)

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


----------



## tincup (2. Jan 2008)

koerschgen2001 hat gesagt.:
			
		

> 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 (2. Jan 2008)

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 (2. Jan 2008)

koerschgen2001 hat gesagt.:
			
		

> 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.



			
				koerschgen2001 hat gesagt.:
			
		

> 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:


----------

