for-Schleife optimieren

[8989_Sinus]

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

 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?

        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]

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

 

[hmmmmhrrrrr]

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

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]

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]

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ß

        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]

So funktionierts!

        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]

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

 

[Final_Striker]

Wie wäre es damit

werte[i]

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

 

[bERt0r]

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.

 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:

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]

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.

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]

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]

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

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

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]

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

 

[bERt0r]

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

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