public void GenerateMatrixes(IMatrixWriteStorage <int, EmptyData> matrixStorage)
{
Random rnd = new Random();
for (int matrindex = 0; matrindex < count; matrindex++)
{
DenseMatrix <int> matrix = new DenseMatrix <int>(m, n);
int mountainsCount = mountainsMin + rnd.Next(mountainsMax - mountainsMin);
for (int mountain = 0; mountain < mountainsCount; mountain++)
{
double x = rnd.NextDouble() * m;
double y = rnd.NextDouble() * n;
double a = min_h + rnd.NextDouble() * (max_h - min_h);
double b = 1 / (min_w + rnd.NextDouble() * (max_w - min_w));
foreach (var index in MatrixEnumerator.Indexes(matrix))
{
double rx = index[0] - x;
double ry = index[1] - y;
double r = b * Math.Sqrt(rx * rx + ry * ry);
matrix[index] += (int)(a * Math.Exp(-r * r));
}
}
foreach (var index in MatrixEnumerator.Indexes(matrix))
{
matrix[index] += 1;
}
matrixStorage.SaveMatrix("Exponent", matrix, null);
}
}
public void GenerateMatrixes(IMatrixWriteStorage <int, EmptyData> matrixStorage)
{
Random rnd = new Random();
for (int i = 0; i < count; i++)
{
DenseMatrix <int> matrix = new DenseMatrix <int>(countRows, countColumns);
foreach (IIndex index in MatrixEnumerator.Indexes(matrix))
{
matrix[index] = rnd.Next(max - min + 1) + min;
}
matrixStorage.SaveMatrix("uniform", matrix, null);
}
}
public void GenerateMatrixes(IMatrixWriteStorage <int, EmptyData> matrixStorage)
{
Random rnd = new Random();
var indexIJ = new Index2D();
for (int matrindex = 0; matrindex < count; matrindex++)
{
DenseMatrix <int> matrix = new DenseMatrix <int>(m, n);
int rectsCount = rectsMin + rnd.Next(rectsMax - rectsMin);
for (int rect = 0; rect < rectsCount; rect++)
{
int x1 = rnd.Next(m);
int y1 = rnd.Next(n);
int x2 = x1 + rnd.Next(m - x1);
int y2 = y1 + rnd.Next(n - y1);
int A = min_h + rnd.Next(max_h - min_h);
for (indexIJ.I = x1; indexIJ.I <= x2; indexIJ.I++)
{
for (indexIJ.J = y1; indexIJ.J <= y2; indexIJ.J++)
{
matrix[indexIJ] += A;
}
}
}
foreach (var index in MatrixEnumerator.Indexes(matrix))
{
matrix[index] += 1;
}
matrixStorage.SaveMatrix("Rectangles", matrix, null);
}
}
public void GenerateMatrixes(IMatrixWriteStorage <int, EmptyData> matrixStorage)
{
Random rnd = new Random();
for (int matrindex = 0; matrindex < count; matrindex++)
{
#region // задаём разбиения по каждому измерению
// формируем массив номеров строк, по которым идёт разбиение
List <int> num_row = CreatePartition(M1, n);
// формируем массив номеров столбцов, по которым идёт разбиение
List <int> num_col = CreatePartition(M2, m);
#endregion
#region // заполнение матрицы
int[,] matrix = new int[n, m];
int size_row, size_col, size_block;
int sum_control; // переменная для контороля того, что в каждом блоке // загрузка равна заданной загрузке w_block
int Max = 0; // максимальная суммарная загрузка
int w_block;
double h, f;
int expectation_1, expectation_2;
double D1, D2;
for (int i = 0; i < M1 + 1; i++)
// суммарная загрузка каждого блока принимает значение в отрезке: [w - epsilon, w + epsilon],
// но в зависимости от размера каждого блока этот отрезок может стать меньше
{
size_row = num_row[i + 1] - num_row[i];
expectation_1 = num_row[i + 1] - (num_row[i + 1] - num_row[i]) / 2;
for (int j = 0; j < M2 + 1; j++)
{
size_col = num_col[j + 1] - num_col[j];
// размерность текущего блока (i, j)
size_block = size_row * size_col;
h = rnd.NextDouble() * (max_h - min_h) + min_h;
w_block = rnd.Next(Math.Max(size_block, min_w), max_w + 1);
if (w_block > Max)
{
Max = w_block;
}
// заполнение ячеек текущего блока целочисленными значениями по распределению Гаусса
sum_control = 0;
// генерируем центр распределения: это есть (M1, M2) - локальные координаты
expectation_2 = num_col[j + 1] - (num_col[j + 1] - num_col[j]) / 2;
// пусть D1 = D2
D1 = D2 = Math.Sqrt(1 / (2 * h * Math.PI));
for (int k = num_row[i] + 1; k <= num_row[i + 1]; k++)
{
for (int l = num_col[j] + 1; l <= num_col[j + 1]; l++)
{
// нужно использовать локальные координаты
f = w_block * (1.0 / (2.0 * Math.PI * D1 * D2)) * Math.Exp(-0.5 * ((((k - expectation_1) * (k - expectation_1)) / (D1 * D1)) + (((l - expectation_2) * (l - expectation_2)) / (D2 * D2))));
matrix[k, l] = (int)Math.Ceiling(f);
sum_control += matrix[k, l];
}
}
if (w_block < sum_control)
{
// перебор по суммарной загрузке блока
while ((w_block < sum_control) && (w_block >= sum_control - size_block))
{
sum_control -= size_block;
for (int k = num_row[i] + 1; k <= num_row[i + 1]; k++)
{
for (int l = num_col[j] + 1; l <= num_col[j + 1]; l++)
{
matrix[k, l] = Math.Max(1, matrix[k, l]--);
}
}
}
}
else
{
// недобор по суммарной загрузке блока
while (w_block > sum_control)
{
sum_control += size_block;
for (int k = num_row[i] + 1; k <= num_row[i + 1]; k++)
{
for (int l = num_col[j] + 1; l <= num_col[j + 1]; l++)
{
matrix[k, l]++;
}
}
}
}
}
}
#endregion
#region // полученное решение
// 1. матрица matrix
// 2. разбиение по осям
CreateSolution(num_row, num_col);
// максимальная загрузка при полученном разбиении
// 3. Max
#endregion
#region // вывод для проверки
for (int i = 0; i < n; i++)
{
Console.WriteLine();
for (int j = 0; j < m; j++)
{
int ost = matrix[i, j] / 10;
if (ost == 0)
{
Console.Write(" ");
}
Console.Write(matrix[i, j] + " ");
}
}
#endregion
DenseMatrix <int> Matrix = new DenseMatrix <int>(n, m);
foreach (var index in MatrixEnumerator.Indexes(Matrix))
{
Matrix[index] = matrix[index[0], index[1]];
}
matrixStorage.SaveMatrix("Gauss", Matrix, null);
}
}
