/// <summary>
/// Metoda factory generująca koło
/// </summary>
/// <param name="size">Rozmiar układu</param>
/// <param name="stateCount">Ilość możliwych wartości</param>
/// <returns>Układ początkowy z kołem</returns>
internal static InitialConditionsGrid CircleFactory(int size=30,int stateCount=SPDAssets.MAX)
{
InitialConditionCell[,] ic = new InitialConditionCell[size, size];
List<InitialConditionCell>[] setLists = new List<InitialConditionCell>[SPDAssets.MAX];
for (int i = 0; i < setLists.Length; i++) setLists[i] = new List<InitialConditionCell>();
for (int i = 0; i < size; i++)
for (int j = 0; j < size; j++)
{
InitialConditionCell c = new InitialConditionCell(i, j, 0, -1);
for (int k = 0;k<stateCount-1;k++)
{
if ((i - size/2) * (i - size/2) + (j - size/2) * (j - size/2) <= (size/2)*(size/2) / ((k+1)*(k + 1)))
{
c.Set = k;
}
}
if (c.Set < 0)
{
c.Set = stateCount-1;
}
ic[i, j] = c;
setLists[c.Set].Add(c);
}
var sets = setLists.Select(a => a.ToArray()).ToArray();
InitialConditionsGrid ig = new InitialConditionsGrid
{
CellGrid = ic,
CellSets = sets
};
return ig;
}
/// <summary>
/// Metoda generująca macierz losowego układu
/// </summary>
/// <param name="r">Randomizer</param>
/// <param name="size">Rozmiar układu</param>
/// <param name="stateCount">Ilość stanów</param>
/// <returns>Macierz układu</returns>
internal static InitialConditionsGrid GenerateRandom(Random r, int size = 100, int stateCount = SPDAssets.MAX)
{
int x = size;
int y = size;
List <InitialConditionCell>[] setLists = new List <InitialConditionCell> [stateCount];
for (int i = 0; i < setLists.Length; i++)
{
setLists[i] = new List <InitialConditionCell>();
}
InitialConditionCell[,] grid = new InitialConditionCell[x, y];
for (int i = 0; i < x; i++)
{
for (int j = 0; j < y; j++)
{
int k = r.Next(setLists.Length);
InitialConditionCell c = new InitialConditionCell(i, j, k, k);
grid[i, j] = c;
setLists[k].Add(c);
}
}
var sets = setLists.Select(a => a.ToArray()).ToArray();
InitialConditionsGrid ig = new InitialConditionsGrid
{
CellGrid = grid,
CellSets = sets
};
return(ig);
}
/// <summary>
/// Metoda factory generująca przekątną
/// </summary>
/// <param name="size">Rozmiar układu</param>
/// <param name="stateCount">Ilość możliwych wartości</param>
/// <returns>Układ początkowy z przekątną</returns>
internal static InitialConditionsGrid DiagonalFactory(int size = 30, int stateCount = SPDAssets.MAX)
{
InitialConditionCell[,] ic = new InitialConditionCell[size, size];
List <InitialConditionCell>[] setLists = new List <InitialConditionCell> [stateCount];
for (int i = 0; i < setLists.Length; i++)
{
setLists[i] = new List <InitialConditionCell>();
}
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
int k = Math.Abs(i - j);
int m = Math.Max(ic.GetLength(0), ic.GetLength(1));
InitialConditionCell c = new InitialConditionCell(i, j, 0, k * (stateCount) / m);
ic[i, j] = c;
setLists[c.Set].Add(c);
}
}
var sets = setLists.Select(a => a.ToArray()).ToArray();
InitialConditionsGrid ig = new InitialConditionsGrid
{
CellGrid = ic,
CellSets = sets
};
return(ig);
}
internal static InitialConditions FromCellArray(Tuple <int, float>[,] cells, string getFileName = "FileLoaded")
{
InitialConditionsGrid icg = InitialConditionsGrid.FromCellArray(cells);
return(new InitialConditions {
Name = getFileName, Grid = icg
});
}
internal static InitialConditionsGrid NowakMayFactory(int size = 31, int StateCount = SPDAssets.MAX)
{
InitialConditionCell[,] ic = new InitialConditionCell[size, size];
List <InitialConditionCell>[] setLists = new List <InitialConditionCell> [SPDAssets.MAX];
for (int i = 0; i < setLists.Length; i++)
{
setLists[i] = new List <InitialConditionCell>();
}
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
int k = -1;
if (size % 2 == 0)
{
if (i == size / 2 || i + 1 == size / 2)
{
if (j == size / 2 || j + 1 == size / 2)
{
k = 0;
}
}
}
else
{
if (i == size / 2)
{
if (j == size / 2)
{
k = 0;
}
}
}
if (k < 0)
{
k = StateCount - 1;
}
InitialConditionCell c = new InitialConditionCell(i, j, k, k);
ic[i, j] = c;
setLists[c.Set].Add(c);
}
}
var sets = setLists.Select(a => a.ToArray()).ToArray();
InitialConditionsGrid ig = new InitialConditionsGrid
{
CellGrid = ic,
CellSets = sets
};
return(ig);
}
private int[,] Transform(InitialConditionsGrid ig)
{
var ar = ig.CellGrid;
int[,] result = new int[ar.GetLength(0), ar.GetLength(1)];
for (int i = 0; i < ar.GetLength(0); i++)
{
for (int j = 0; j < ar.GetLength(1); j++)
{
result[i, j] = ar[i, j].Value;
}
}
return(result);
}
public static InitialConditions CreateICFromPick(PointMatrixPick Condition)
{
var IC = new InitialConditions();
var IG = new InitialConditionsGrid();
IG.CellGrid = new InitialConditionCell[Condition.Indices.GetLength(0), Condition.Indices.GetLength(1)];
for (int i = 0; i < Condition.Indices.GetLength(0); i++)
{
for (int j = 0; j < Condition.Indices.GetLength(1); j++)
{
IG.CellGrid[i, j] = new InitialConditionCell(i, j, Condition.Indices[i, j], Condition.Indices[i, j]);
}
}
IC.Grid = IG;
return IC;
}
public static InitialConditions CreateICFromPick(PointMatrixPick Condition)
{
var IC = new InitialConditions();
var IG = new InitialConditionsGrid();
IG.CellGrid = new InitialConditionCell[Condition.Indices.GetLength(0), Condition.Indices.GetLength(1)];
for (int i = 0; i < Condition.Indices.GetLength(0); i++)
{
for (int j = 0; j < Condition.Indices.GetLength(1); j++)
{
IG.CellGrid[i, j] = new InitialConditionCell(i, j, Condition.Indices[i, j], Condition.Indices[i, j]);
}
}
IC.Grid = IG;
return(IC);
}
/// <summary>
/// Metoda factory generująca koło
/// </summary>
/// <param name="reversed">Czy wartości mają być odwrócone</param>
/// <param name="size">Rozmiar</param>
/// <param name="stateCount">Ilość możliwych wartości komórek</param>
/// <returns>Układ początkowy z kołem</returns>
internal static InitialConditions CircleFactory(bool reversed = false, int size = 30, int stateCount = SPDAssets.MAX, bool twoState = false)
{
InitialConditionsGrid ig = InitialConditionsGrid.CircleFactory(size, twoState ? 2 : stateCount);
ig.Transform(GetTransformation(twoState ? 2 : stateCount, reversed), twoState ? 2 : stateCount);
if (twoState)
{
ig.Transform((x) => (x == 0 ? 0 : stateCount - 1), 2);
}
var ic = new InitialConditions
{
Name = "Koło " + (reversed ? "- odwrócone kolory" : ""),
Grid = ig
};
return(ic);
}
/// <summary>
/// Metoda generująca losowy układ
/// </summary>
/// <param name="size">Rozmiar układu</param>
/// <param name="stateCount">Ilość możliwych wartości komórek</param>
/// <returns>Układ początkowy</returns>
internal static InitialConditions GenerateRandom(int size = 100, int stateCount = SPDAssets.MAX, bool twoState = false)
{
Random r = new Random();
var Grid = InitialConditionsGrid.GenerateRandom(r, size, twoState?2:stateCount);
Grid.Transform(GetTransformation(twoState ? 2 : stateCount), twoState ? 2 : stateCount);
if (twoState)
{
Grid.Transform((x) => (x == 0 ? 0 : stateCount - 1), 2);
}
var ic = new InitialConditions
{
Name = "Losowy" + r.Next(),
Grid = Grid
};
return(ic);
}
/// <summary>
/// Metoda factory generująca koło
/// </summary>
/// <param name="size">Rozmiar układu</param>
/// <param name="stateCount">Ilość możliwych wartości</param>
/// <returns>Układ początkowy z kołem</returns>
internal static InitialConditionsGrid CircleFactory(int size = 30, int stateCount = SPDAssets.MAX)
{
InitialConditionCell[,] ic = new InitialConditionCell[size, size];
List <InitialConditionCell>[] setLists = new List <InitialConditionCell> [SPDAssets.MAX];
for (int i = 0; i < setLists.Length; i++)
{
setLists[i] = new List <InitialConditionCell>();
}
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
InitialConditionCell c = new InitialConditionCell(i, j, 0, -1);
for (int k = 0; k < stateCount - 1; k++)
{
if ((i - size / 2) * (i - size / 2) + (j - size / 2) * (j - size / 2) <= (size / 2) * (size / 2) / ((k + 1) * (k + 1)))
{
c.Set = k;
}
}
if (c.Set < 0)
{
c.Set = stateCount - 1;
}
ic[i, j] = c;
setLists[c.Set].Add(c);
}
}
var sets = setLists.Select(a => a.ToArray()).ToArray();
InitialConditionsGrid ig = new InitialConditionsGrid
{
CellGrid = ic,
CellSets = sets
};
return(ig);
}
/// <summary>
/// Metoda factory generująca przekątną
/// </summary>
/// <param name="size">Rozmiar układu</param>
/// <param name="stateCount">Ilość możliwych wartości</param>
/// <returns>Układ początkowy z przekątną</returns>
internal static InitialConditionsGrid DiagonalFactory(int size=30,int stateCount=SPDAssets.MAX)
{
InitialConditionCell[,] ic = new InitialConditionCell[size, size];
List<InitialConditionCell>[] setLists = new List<InitialConditionCell>[stateCount];
for (int i = 0; i < setLists.Length; i++) setLists[i] = new List<InitialConditionCell>();
for (int i = 0; i < size; i++)
for (int j = 0; j < size; j++)
{
int k = Math.Abs(i - j);
int m = Math.Max(ic.GetLength(0), ic.GetLength(1));
InitialConditionCell c = new InitialConditionCell(i, j, 0, k * (stateCount) / m);
ic[i, j] = c;
setLists[c.Set].Add(c);
}
var sets = setLists.Select(a => a.ToArray()).ToArray();
InitialConditionsGrid ig = new InitialConditionsGrid
{
CellGrid = ic,
CellSets = sets
};
return ig;
}
internal static InitialConditionsGrid NowakMayFactory(int size = 31, int StateCount = SPDAssets.MAX)
{
InitialConditionCell[,] ic = new InitialConditionCell[size, size];
List<InitialConditionCell>[] setLists = new List<InitialConditionCell>[SPDAssets.MAX];
for (int i = 0; i < setLists.Length; i++) setLists[i] = new List<InitialConditionCell>();
for (int i = 0; i < size; i++)
for (int j = 0; j < size; j++)
{
int k=-1;
if (size%2 == 0)
{
if (i == size/2 || i + 1 == size/2)
{
if (j == size / 2 || j + 1 == size / 2)
{
k = 0;
}
}
}
else
{
if (i == size / 2)
{
if (j == size / 2 )
{
k = 0;
}
}
}
if (k < 0) k = StateCount - 1;
InitialConditionCell c = new InitialConditionCell(i,j,k,k);
ic[i, j] = c;
setLists[c.Set].Add(c);
}
var sets = setLists.Select(a => a.ToArray()).ToArray();
InitialConditionsGrid ig = new InitialConditionsGrid
{
CellGrid = ic,
CellSets = sets
};
return ig;
}
/// <summary>
/// Metoda generująca macierz losowego układu
/// </summary>
/// <param name="r">Randomizer</param>
/// <param name="size">Rozmiar układu</param>
/// <param name="stateCount">Ilość stanów</param>
/// <returns>Macierz układu</returns>
internal static InitialConditionsGrid GenerateRandom(Random r,int size=100,int stateCount=SPDAssets.MAX)
{
int x = size;
int y = size;
List<InitialConditionCell>[] setLists = new List<InitialConditionCell>[stateCount];
for(int i=0;i<setLists.Length;i++) setLists[i]=new List<InitialConditionCell>();
InitialConditionCell[,] grid = new InitialConditionCell[x,y];
for(int i=0;i<x;i++)
for (int j = 0; j < y; j++)
{
int k = r.Next(setLists.Length);
InitialConditionCell c = new InitialConditionCell(i,j,k,k);
grid[i, j] = c;
setLists[k].Add(c);
}
var sets = setLists.Select(a => a.ToArray()).ToArray();
InitialConditionsGrid ig = new InitialConditionsGrid
{
CellGrid = grid,
CellSets = sets
};
return ig;
}
private int[,] Transform(InitialConditionsGrid ig)
{
var ar = ig.CellGrid;
int[,] result = new int[ar.GetLength(0), ar.GetLength(1)];
for (int i = 0; i < ar.GetLength(0); i++)
for (int j = 0; j < ar.GetLength(1); j++)
result[i, j] = ar[i, j].Value;
return result;
}
