Hi 
Ich habe leider ein Problem damit, ein Array zu definieren. Es geht um das Array in Zeile 163:
Kann man das Array irgendwie so ähnlich definieren, wie ich das hier versuche?
Ich habe leider ein Problem damit, ein Array zu definieren. Es geht um das Array in Zeile 163:
Java:
import java.util.Random;
class Main
{
/**
* Array mit Zufallszahlen gefüllt, 0en am Rand.
* @param int[][] cellsThis
* @param int size
*/
private static void fill(int[][] cellsThis, int size)
{
int max = size - 1;
for(int y = 0; y < size; ++y)
{
cellsThis[0][y] = 0;
cellsThis[max][y] = 0;
}
Random r = new Random();
for(int x = 1; x < max; ++x)
{
cellsThis[x][0] = cellsThis[x][max] = 0;
for(int y = 1; y < max; ++y)
{
cellsThis[x][y] = r.nextInt(10); // 0 ... 9
}
}
}
/**
* durchschnittlicher Umgebungsstatus
* @param int[][] cellsThis
* @param int x
* @param int y
* @return double
*/
private static double envAvg(int[][] cellsThis, int x, int y)
{
int sum = 0;
int cnt = 0;
for(int xEnv = -1; xEnv < 2; ++xEnv)
{
for(int yEnv = -1; yEnv < 2; ++yEnv)
{
if
(
(xEnv != 0 || yEnv != 0) &&
cellsThis[x + xEnv][y + yEnv] != 0
)
{
sum += cellsThis[x + xEnv][y + yEnv];
++cnt;
}
}
}
if(cnt == 0)
{
return 0.0; // keine Umgebungsstati vorhanden
}
return sum / cnt;
}
/**
* @param int cell
* @param double envAvg
* @param double var
* @return boolean
*/
private static boolean badEnv(int cell, double envAvg, double var)
{
return
envAvg != 0 && // wenn zumindest 1 Umgebungsstatus vorhanden
Math.abs(cell - envAvg) > var; // wenn Differenz größer Schwellwert
}
/**
* @param double value 0 ... 1
* Gibt die Wahrscheinlichkeit an, mit der diese Funktion true zurück gibt.
* @return boolean
*/
private static boolean action(double value)
{
Random r = new Random();
double rand = r.nextDouble(); // float-Zufallszwahl 0 ... 1
return
value == 1 || // auf jeden Fall
rand < value; // nur unter Umständen
}
/**
* Bessere Umgebung suchen (gibt keine Garantie, dass die Suche erfolgreich ist).
*/
private static void move(int[][][] cells, int x, int y, int max, double varNew, int that, int other)
{
boolean cont = true;
int xNew = 1;
while(xNew < max && cont)
{
int yNew = 1;
while(yNew < max && cont)
{
if(cells[other][xNew][yNew] == 0) // ob neue Zelle noch frei
{
// leere Zelle gefunden
double envAvgNew = envAvg(cells[that], xNew, yNew); // Kontrolle Umgebung der Zelle
if
(
envAvgNew == 0.0 || // wenn keine Umgebungsstati vorhanden
Math.abs(cells[that][x][y] - envAvgNew) < varNew // Differenz kleiner neuen Schwellwert
)
{
// übersiedeln (zur erstbesten Möglichkeit):
cells[other][xNew][yNew] = cells[that][x][y];
cells[other][x][y] = 0;
cont = false;
}
}
++yNew;
}
++xNew;
}
}
/**
* Meinung um 1 anpassen.
* @param int[][] cellsOther
* @param int x
* @param int y
* @param double envAvg
*/
private static void adapt(int[][] cellsOther, int x, int y, double envAvg)
{
// Sollte es aufgrund von Rechenungenauigkeiten bei envAvg möglich sein,
// dass es den Wert < 1 oder > 9 hat, wird hier zusätzlich auf < 9 bzw. > 1 kontrolliert.
if(envAvg > cellsOther[x][y])
{
if(cellsOther[x][y] < 9)
{
++cellsOther[x][y];
}
}
else if(cellsOther[x][y] > 1)
{
--cellsOther[x][y];
}
}
public static void main(String[] args)
{
double var = 3.0; // Schwellwert
double fvar = 0.5; // Verbesserungsfaktor 0 ... 1
double[] probs = // je gerundeten durschnittlichen Umgebungsstatus: Wahrscheinlichkeit Umzug relativ zu Meinungsänderung
{ // 0 (kein Umzug, nur Meinungsänderung) ... 1 (nur Umzug, keine Meinungsänderung)
0, // dummy-Eintrag
0.6,
0.3, // 30 % Umzug, 70 % Meinungsänderung
1.0, // Umzug
0.2,
0, // Meinungsänderung
0.6,
0.8, // 80 % Umzug, 20 % Meinungsänderung
1,
1
};
double wreact = 1; // 0 (reagiert nie) ... 1 (reagiert immer)
int size = 8;
int[][] cells0 =
{
{0,0,0,0,0,0,0,0},
{0,3,3,3,1,1,1,0},
{0,3,7,3,1,1,1,0}, // 7: 2/2
{0,3,3,3,1,1,1,0},
{0,1,1,1,8,8,8,0},
{0,1,1,1,8,0,8,0}, // 0: 5/5
{0,1,1,1,8,8,8,0},
{0,0,0,0,0,0,0,0}
};
int[][][] cells = new int[2][size][size]; // Werte der Zelle: 0 (leer), 1 (links) ... 9 (rechts)
cells[0] = cells0;
// fill(cells[that], size);
// Initialisieren:
int max = size - 1;
int that = 0; // immer wechseln zwischen 0 und 1, das eine ist die Datenquelle, das andere die Datensenke
// neuer Durchlauf
int other = (that + 1) % 2;
// die 0en müssen in other kopiert werden (hier wird aber gleich alles kopiert):
for(int x = 0; x < size; ++x)
{
for(int y = 0; y < size; ++y)
{
cells[other][x][y] = cells[that][x][y];
}
}
for(int x = 1; x < max; ++x)
{
for(int y = 1; y < max; ++y)
{
if(cells[that][x][y] > 0)
{
double envAvg = envAvg(cells[that], x, y); // Kontrolle Umgebung der Zelle
boolean badEnv = badEnv(cells[that][x][y], envAvg, var); // wenn schlechte Umgebung
boolean action = action(wreact); // wenn eine Reaktion erfolgen soll
if
(
badEnv &&
action
)
{
double prob = probs[(int)Math.round(envAvg)];
if(action(prob)) // ob ein Umzug erfolgen soll
{
move(cells, x, y, max, var * fvar, that, other);
}
else
{
adapt(cells[other], x, y, envAvg);
}
}
}
}
}
that = other;
}
}
Zuletzt bearbeitet:
