for-Schleife optimieren

8989_Sinus · 7. Sep 2011

Hallo,
ich habe folgende for-Schleifen, die ich gerne in eine for-Schleife packen möchte. Damit habe ich allerdings ein paar Probleme.

Java:

 int start1 = 0;
        int []werte = {0, 20, 80, 118, 250, 236};

            int periode1 = werte[1];
            for (start1 = werte[0]; start1 < werte[1]; start1++) {           
            double sin = (int) a*Math.sin(2*Math.PI/periode1*start1+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi((int)start1, 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel((int)start1, (int) (sin + 240), 0);
        }
            int periode2 = werte[2];
            for (start1 = werte[0]; start1 < werte[2]; start1++) {           
            double sin = (int) a*Math.sin(2*Math.PI/periode2*start1+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi((int)start1+werte[1], 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel((int)start1+werte[1], (int) (sin + 240), 0);
        }
            int periode3 = werte[3];
            for (start1 = werte[0]; start1 < werte[3]; start1++) {           
            double sin = (int) a*Math.sin(2*Math.PI/periode3*start1+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi((int)start1+werte[1]+werte[2], 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel((int)start1+werte[1]+werte[2], (int) (sin + 240), 0);
        }
            int periode4 = werte[4];
            for (start1 = werte[0]; start1 < werte[4]; start1++) {           
            double sin = (int) a*Math.sin(2*Math.PI/periode4*start1+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi((int)start1+werte[1]+werte[2]+werte[3], 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel((int)start1+werte[1]+werte[2]+werte[3], (int) (sin + 240), 0);
            }

So sieht einer meiner Versuche aus.
Wie kann ich beim durchzählen eines Arrays ein Element überspringen?
Wie muß ich den Code ändern?

Java:

        int start = 0;
        int summe = 0;
        int []werte = {0, 20, 80, 118, 250, 236};
        
        
        for (int i = 0; i < werte.length; i++) {            
            int periode = werte[i];
            summe += werte[i];
            for (start = werte[i]; start  < werte[i]; start++) {                              
                double sin = (int) a*Math.sin(2*Math.PI/periode*start+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi((int)start+summe, 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel((int)start+summe, (int) (sin + 240), 0);
                
            }
            
        }

Danke und Gruß

DerEisteeTrinker · 7. Sep 2011

Ich würde erstmal anfangen den redundanten Code in eine Methode auslagern, dann kannst dich an die Schleifen ranwagen

hmmmmhrrrrr · 7. Sep 2011

Inwiefern ein Element überspringen? z.B die dritte Position ?

Java:

for(...){
     if(start != 2)
     {
      // hier kommt alles rein
     } 
}

??

Und das solltest du auch machen:

Ich würde erstmal anfangen und den redundanten Code in eine Methode auslagern, dann kannst dich an die Schleifen ranwagen

SlaterB · 7. Sep 2011

wenn es in einer Schleife steht ist doch nichts mehr redundant, der Tipp bringt nicht viel,
ok, als Zwischenschritt vielleicht, aber das ist doch quasi schon fertig, der Stand schon weiter?

-----

was ich sehe:
bisher begannen alle inneren Schleifen bei werte[0], nun setzt du werte als Startwert?
> start = werte; start < werte
macht doch gar nichts,

wieso ist im ersten Fall
> ip.setRoi((int)start1, 500, 1, 236);
nicht
> ip.setRoi((int)start1+werte[0], 500, 1, 236);
passend zu den anderen Schleifen?
im Moment ist werte[0] == 0, macht also keinen Unterschied,
für die summe in der neuen Schleife wird das aber wichtig falls sich das auch mal ändert,
das meinst du vielleicht mit
> Wie kann ich beim durchzählen eines Arrays ein Element überspringen?
?

ein if könnte da helfen, wenn i==0 ist, dann eben nicht summe erhöhen

-------

den int-cast bei (int)start+summe kannst du dir doch sparen, oder?

-------

mehr sehe ich nicht, gibt es denn noch konkret Probleme, meinst du etwas bestimmtes?

8989_Sinus · 7. Sep 2011

Hallo,

@SlaterB: stimmt start kann 0 sein! So funktioniert es auch zum teil und das mit dem Element überspringne hat sich erledigt.

Allerdings habe ich nun das Problem, durch die summe die einzelnen gezeichneten Elemente nicht aneinander gefügt werden sondern einen abstand haben. Ich muß doch im schon (int)start+summe hinzufügen? Dadurch ergeben sich Abstände beim zeichnen.

Gruß

Java:

        int start;
        int summe = 0;
        int []werte = { 20, 80, 118, 235, 280};
             
        for (int i = 0; i < werte.length; i++) {            
            int periode = werte[i];
            summe += werte[i];
            System.out.println("summe = " + summe);
            for (start = 0; start  < werte[i]; start++) {   
                double sin = (int) a*Math.sin(2*Math.PI/periode*start+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi((int)start+summe, 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel((int)start+summe, (int) (sin + 240), 0);              
            }          
        }

8989_Sinus · 7. Sep 2011

So funktionierts!

Java:

        for (int i = 0; i < werte.length; i++) {            
            int periode = werte[i];
            summe += werte[i];
            for (start = 0; start  < werte[i]; start++) {   
                double sin = (int) a*Math.sin(2*Math.PI/periode*start+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi((int)start+summe-werte[i], 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel((int)start+summe-werte[i], (int) (sin + 240), 0);              
            }          
        }

SlaterB · 7. Sep 2011

verschiebe Zeile 3 hinter die innere Schleife, dann sparst du dir das Minus

Final_Striker · 7. Sep 2011

Wie wäre es damit

Code:

werte[i]

erst nach der for-Schleife dazu zuaddieren, dann brauchst du es auch nicht wieder abzuziehen.

bERt0r · 7. Sep 2011

Korrigiere mich wenn ich falsch liege, aber es sieht für mich so aus als ob dieser Code bei jeder Schleife gleich ist, es wird nur mit einer anderen "periode" gerechnet. Und diese Periode ist nichts anderes als einfach der nächste wert im array.

Java:

 int periode1 = werte[1];
            for (start1 = werte[0]; start1 < werte[1]; start1++) {           
            double sin = (int) a*Math.sin(2*Math.PI/periode1*start1+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi((int)start1, 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel((int)start1, (int) (sin + 240), 0);
        }

Das solltest du auch so lösen können:

Java:

int []perioden= {0, 20, 80, 118, 250, 236};
for(int i=0;i<perioden.length;i++)           //Schleife übers Array
{
  for(int j=perioden[i];j<perioden[i+1];j++)            //Schleife bis zum nächsten Wert
          {  
                double sin = (int) a*Math.sin(2*Math.PI/perioden[i]*j+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi(j, 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel(j, (int) (sin + 240), 0);
         }
}

8989_Sinus · 8. Sep 2011

Hi,

@bERt0r
eigentlich sollte es so funktonieren. Ich bekomme diese Fehlermeldung.

java.lang.ArrayIndexOutOfBoundsException: 6
at Praktikum.SinusArray3_.run(SinusArray3_.java:33)
at ij.IJ.runUserPlugIn(IJ.java:183)
at ij.IJ.runPlugIn(IJ.java:150)
at ij.Executer.runCommand(Executer.java:124)
at ij.Executer.run(Executer.java:61)
at java.lang.Thread.run(Thread.java:619)

Die Zeile 33 entspricht dabei der Zeile 4.

Java:

int []perioden= {0, 20, 80, 118, 250, 236};
for(int i=0;i<perioden.length;i++)           //Schleife übers Array
{
  for(int j=perioden[i];j<perioden[i+1];j++)            //Schleife bis zum nächsten Wert
          {  
          int wert = perioden[i]; // Eigefügt weil er immer einen int Wert haben wollte 
                double sin = (int) a*Math.sin(2*Math.PI/wert*j+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi(j, 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel(j, (int) (sin + 240), 0);
         }
}

Gruß

SlaterB · 8. Sep 2011

vielleicht sollte i nur bis zum vorletzten perioden-Index laufen, schließlich will j noch darüber hinaus: perioden[i+1]

es wäre immer gut den Sinn von Schleifen auch zu verstehen, nicht nur abzutippen

jgh · 8. Sep 2011

die äußere Schleife läuft von 0-5, soweit so gut.
Wenn

Code:

i=5

ist, will die innere Schleife aber auf das [c]i+1[/c] Element zugreifen, das es aber das nicht gibt!
Weil die Länge deines int-Arrays 6 ist und somit nur über die Indizies 0-5 zugegriffen werden kann.
Da du es aber trotzdem machst, schmeißt er dir halt ne ArrayIndexOutOfBoundsException, logisch gell^^

Du könntest es irgendwie mit einer if-Abfragen machen....

Java:

for (int i = 0; i < perioden.length; i++) // Schleife übers Array
		{
			if (i < perioden.length - 1) {
				for (int j = perioden[i]; j < perioden[i + 1]; j++) // Schleife

aber grundsätzlich ist das unausgegoren...habe mir aber auch den Thread nicht durchgelesen...also lieber auf eine vernünftige Antwort warten!

8989_Sinus · 8. Sep 2011

Hi,
klingt logisch!
Ich danke euch für die schnellen Antworten!
Gruß

bERt0r · 8. Sep 2011

ja, da war ich wohl zu faul, die eine If ist aber auch nicht die große Kunst:

Java:

int []perioden= {0, 20, 80, 118, 250, 236};
int nextPeriode=0;
for(int i=0;i<perioden.length;i++)           //Schleife übers Array
{
if(i<perioden.length)
{
nextPeriode=perioden[i+1];
}
else
{
nextPeriode=perioden[i]+1;                               //Damit die Letzte Periode auch noch einmal ausgeführt wird (falls das gewünscht ist)
}
  for(int j=perioden[i];j<nextPeriode;j++)            //Schleife bis zum nächsten Wert
          {  
          int wert = perioden[i]; // Eigefügt weil er immer einen int Wert haben wollte 
                double sin = (int) a*Math.sin(2*Math.PI/wert*j+Math.PI/c)+d;
                Rectangle roib = ip.getRoi();
                ip.setRoi(roib);
                ip.setRoi(j, 500, 1, 236);
                ip.setValue(sin);
                ip.fill();
                ip.putPixel(j, (int) (sin + 240), 0);
         }
}

for-Schleife optimieren

8989_Sinus

Gast

DerEisteeTrinker

Bekanntes Mitglied

hmmmmhrrrrr

Gast

SlaterB

Gast

8989_Sinus

Gast

8989_Sinus

Gast

SlaterB

Gast

Final_Striker

Top Contributor

bERt0r

Top Contributor

8989_Sinus

Gast

SlaterB

Gast

jgh

Top Contributor

8989_Sinus

Gast

bERt0r

Top Contributor

Aktuelle Jobs

Neue Themen

Ähnliche Themen