/// <summary>
/// This method is handling the movement of the tiles in-game.
/// </summary>
/// <exception cref="TilePositionOutOfRangeException">
/// Thrown when the position of the tile is a negative number or exceeds the scope of the matrix
/// </exception>
/// <exception cref="InvalidTileNeighbourException">
/// Thrown when two given tiles are not valid neighbours.
/// </exception>
public static List <ITile> MoveTiles(List <ITile> tiles, int tileValue)
{
if (tileValue < 0 || tileValue > 15)
{
throw new TilePositionOutOfRangeException(Messages.TileOutOfRangeExceptionMessage);
}
List <ITile> resultMatrix = tiles;
ITile freeTile = tiles[GetFreeTilePosition(tiles)];
ITile tile = tiles[GetDestinationTilePosition(tiles, tileValue)];
bool areValidNeighbourTiles = MatrixGenerator.AreValidNeighbourTiles(freeTile, tile);
if (!areValidNeighbourTiles)
{
throw new InvalidTileNeighbourException(Messages.InvalidTileNeighbourExceptionMessage);
}
int targetTilePosition = tile.Position;
resultMatrix[targetTilePosition].Position = freeTile.Position;
resultMatrix[freeTile.Position].Position = targetTilePosition;
resultMatrix.Sort();
return(resultMatrix);
}
public void GenerateField()
{
Random random = new Random();
int minesToInsert = Constants.MinesToInsert;
while (minesToInsert > 0)
{
for (int i = 0; i < this.field.GetLength(0); i++)
{
if (minesToInsert == 0)
{
break;
}
for (int j = 0; j < this.field.GetLength(1); j++)
{
if (minesToInsert == 0)
{
break;
}
int randomNumber = random.Next(0, 3);
if (randomNumber == 1)
{
this.field[i, j] = Constants.MinesSymbol;
minesToInsert--;
}
}
}
}
this.field = MatrixGenerator.GenerateMatrix(this.field, Constants.MinesSymbol);
}
static void Main(string[] args)
{
var writer = new ConsoleWriter();
writer.WriteToConsole(Messages.AskUserForMatrixSize);
var reader = new ConsoleReader();
string input = reader.ReadFromConsole();
var checker = new InputChecker();
int matrixSize = checker.CheckInput(input);
int[,] matrix = new int[matrixSize, matrixSize];
int currentNumber = 1;
int cellIndexX = 0;
int cellIndexY = 0;
int increaseX = 1;
int increaseY = 1;
var matrixGenerator = new MatrixGenerator();
currentNumber = matrixGenerator.MoveForward(matrix, matrixSize, cellIndexX, cellIndexY, increaseX, increaseY, currentNumber);
var cellFinder = new CellFinder();
cellFinder.FindEmptyCell(matrix);
cellIndexX = cellFinder.AvailableX;
cellIndexY = cellFinder.AvailableY;
currentNumber += 1;
currentNumber = matrixGenerator.ChangeDirection(matrix, matrixSize, cellIndexX, cellIndexY, increaseX, increaseY, currentNumber);
writer.PrintMatrix(matrix, matrixSize);
}
private static void Main()
{
var matrix = MatrixGenerator.GenerateMatrix();
MatrixGeneratorLogic.SetMatrixValues(matrix);
MatrixGenerator.PrintMatrix(matrix);
}
private static void CompareTimeOfWorkDependingOnMatrixSize()
{
var multipliers = new List <(string Name, IMatrixMultiplier Multiplier)>
{
("Synchronous Multiplier", new SynchronousMatrixMultiplier()),
("Parallel.For Multiplier", new ParallelForMatrixMultiplier()),
("Striped Parallelizing Multiplier", new StripedParallelizingMatrixMultiplier()),
("Sequentially Parallelizing Multiplier", new SequentiallyParallelizingMatrixMultiplier())
};
var generator = new MatrixGenerator();
for (var i = 1; i < 1001; i += i < 100 ? 1 : i < 500 ? 10 : 100)
{
Console.WriteLine($"Size: {i} * {i}");
var left = generator.Generate(i, i);
var right = generator.Generate(i, i);
foreach (var(name, multiplier) in multipliers)
{
var timestamp = ElapseWorkTime(multiplier, left, right);
Console.WriteLine($"{name} - {timestamp.TotalMilliseconds}");
}
Console.WriteLine();
}
}
public void Start()
{
//gameInProgress = true;
// cellsOpened = 0;
this.playerMatrix = new char[Constants.MatrixRow, Constants.MatrixColumn];
this.matrix = new char[Constants.MatrixRow, Constants.MatrixColumn];
matrix = MinesGenerator.GenerateMinesweeperInMatrix(matrix, minesSimbol: Constants.MinesSymbol);
matrix = MatrixGenerator.GenerateMatrix(matrix, symbolToSkip: Constants.MinesSymbol);
for (int i = 0; i < playerMatrix.GetLength(0); i++)
{
for (int j = 0; j < playerMatrix.GetLength(1); j++)
{
playerMatrix[i, j] = Constants.Symbol;
}
}
renderer.WriteLine(String.Empty);
renderer.WriteLine(String.Empty);
renderer.WriteLine("Welcome to the game “Minesweeper”. Try to reveal all cells without mines. " +
"Use 'top' to view the scoreboard, 'restart' to start a new game and 'exit' " +
"to quit the game.");
renderer.WriteLine(String.Empty);
PrintMatrix(playerMatrix);
while (gameInProgress)
{
Commands();
}
}
public static void Main()
{
int matrixLength = ConsoleInput.GetInput();
Matrix matrix = MatrixGenerator.Generate(matrixLength);
ConsoleOutput.PrintMatrix(matrix);
}
private IObjectiveFunction CreateObjectiveFunction(DataTable cases)
{
var gen = new MatrixGenerator(new PythagoreanCalculator());
var matrix = gen.GenerateMatrix(cases, new EastingNorthingColumnIndexer(0, 1));
var objective = new SimpleTourLengthCalculator(matrix);
return(objective);
}
public void ThrowArgumentOutOfRangeException_WhenProvidedMatrixSizeIsNotPositive(int matrixSize)
{
// arrange
var matrixGenerator = new MatrixGenerator();
// act and assert
Assert.Throws <ArgumentOutOfRangeException>(() => matrixGenerator.Generate(matrixSize));
}
private void RestartGame()
{
Console.WriteLine(Messages.Welcome);
this.tiles = MatrixGenerator.GenerateMatrix();
this.tiles = MatrixGenerator.ShuffleMatrix(this.tiles);
this.isGameFinished = Gameplay.IsMatrixSolved(this.tiles);
Gameplay.PrintMatrix(this.tiles);
this.gameState = State.InGame;
}
private void Initialize(int dimension)
{
_a = MatrixGenerator.Random(dimension, -500, 500); //TODO: verify det(A) not 0.
_b = new Vector(dimension);
_z = new Vector(dimension);
_optimum = BuildOptimum(dimension);
MultiplyA(_optimum, _b);
}
public void NotThrow_WhenValidMatrixSizeIsPassed()
{
// arrange
var matrixGenerator = new MatrixGenerator();
int matrixSize = 10;
// act and assert
Assert.DoesNotThrow(() => matrixGenerator.Generate(matrixSize));
}
public static void Main()
{
IWriter writer = new ConsoleWriter();
IReader reader = new ConsoleReader();
IPrinter printer = new Printer(writer);
IMatrixGenerator matrixGenerator = new MatrixGenerator();
Start(matrixGenerator, writer, reader, printer);
}
public void MatrixGeneratorGetNextDirectionShouldSwitchDirectionCorrectly()
{
DirectionType dir = DirectionType.DownRight;
for (int i = 0; i < 7; i++)
{
dir = MatrixGenerator.GetNextDirection(dir);
}
Assert.AreEqual(DirectionType.Right, dir);
}
public void InvalidNeighbourTilesTest()
{
IList <ITile> tiles = new List <ITile>();
for (int index = 1; index < 16; index++)
{
tiles.Add(new Tile(index.ToString(), index - 1));
}
tiles.Add(new Tile(string.Empty, 15));
Assert.IsFalse(MatrixGenerator.AreValidNeighbourTiles(tiles[0], tiles[5]));
}
/// <summary>
/// Starts the matrix generation.
/// </summary>
/// <param name="logger">The logger that will be used by the generator.</param>
/// <param name="config">The configuration that will be used by the generator.</param>
/// <param name="searchFolder">The folder containing the media samples.</param>
static void StartMatrixGenerator(ILogger logger, ConfigManager config, string searchFolder)
{
MatrixGenerator generator = new MatrixGenerator(logger, config, searchFolder);
generator.ProgressReporter = new ConsoleReporter(logger);
try
{
generator.GenerateMatrix();
}
catch (Exception e)
{
Logger.Error(e);
}
}
private static void Main(string[] args)
{
const int n = 6;
var generator = new MatrixGenerator(n);
var matrix = generator.Generate();
for (var y = 0; y < n; y++)
{
for (var x = 0; x < n; x++)
Console.Write("{0,4:D} ", matrix[x, y]);
Console.WriteLine();
Console.WriteLine();
}
}
public void ReturnCorrectlyFilledMatrix_WhenPassedMatrixSizeIsOne()
{
// arrange
var expectedMatrix = new int[, ]
{
{ 1 }
};
var matrixGenerator = new MatrixGenerator();
int matrixsize = 1;
// act
var resultMatrix = matrixGenerator.Generate(matrixsize);
// assert
CollectionAssert.AreEqual(expectedMatrix, resultMatrix);
}
private void TestMatrix(int rows, int columns, int[,] expectedMatrix)
{
var generator = new MatrixGenerator();
var matrix = generator.GetMatrix(rows, columns);
Assert.Equal(expectedMatrix.GetLength(0), matrix.GetLength(0));
Assert.Equal(expectedMatrix.GetLength(1), matrix.GetLength(1));
for (var i = 0; i < matrix.GetLength(0); i++)
{
for (var j = 0; j < matrix.GetLength(1); j++)
{
Assert.Equal(expectedMatrix[i, j], matrix[i, j]);
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Enter maximum size of matrix to multiply");
int N = int.Parse(Console.ReadLine());
Console.WriteLine("Enter count of reiteration");
int numberOfTests = int.Parse(Console.ReadLine());
var results = new List <Result>();
var start = DateTime.Now;
for (int i = 1; i <= N; i *= 2)
{
Result r = new Result(i.ToString());
for (int n = 1; n <= numberOfTests; n++)
{
Console.WriteLine("Testing {0} for {1}/{2} times.", i, n, numberOfTests);
var a = MatrixGenerator.Generate(i);
var b = MatrixGenerator.Generate(i);
Stopwatch t1 = Stopwatch.StartNew();
var normal = Matrix.NormalMultiply(a, b);
t1.Stop();
Stopwatch t2 = Stopwatch.StartNew();
var strassen = Matrix.StrassenMultiply(a, b);
t2.Stop();
r.Times1.Add(t1.Elapsed.TotalSeconds);
r.Times2.Add(t2.Elapsed.TotalSeconds);
}
results.Add(r);
}
string consoleFormat = "{0}\t{1:N6}s\t{2:N6}s";
WriteResults(Console.Out, results, consoleFormat, "Size \t Normal \t Straussen");
Console.WriteLine(Environment.NewLine + "Total time " + (DateTime.Now - start).ToString());
string fileFormat = "{0};{1:N6};{2:N6}";
string fileName = string.Format("results_{0}_{1}_{2}.csv", N, numberOfTests, DateTime.Now.ToFileTime());
SaveResultsToCSV(results, fileFormat, "Size of matrix;Normal multiply;Straussen multiply", fileName);
Console.ReadKey();
}
public void ReturnCorrectlyFilledMatrix_WhenPassedMatrixSizeIsThree()
{
// arrange
var expectedMatrix = new int[, ]
{
{ 1, 7, 8 },
{ 6, 2, 9 },
{ 5, 4, 3 }
};
var matrixGenerator = new MatrixGenerator();
int matrixSize = 3;
// act
var resultMatrix = matrixGenerator.Generate(matrixSize);
CollectionAssert.AreEqual(expectedMatrix, resultMatrix);
}
public void GenerateMatrixTest()
{
IList <ITile> tiles = new List <ITile>();
for (int index = 1; index < 16; index++)
{
tiles.Add(new Tile(index.ToString(), index - 1));
}
tiles.Add(new Tile(string.Empty, 15));
IList <ITile> generatedTiles = MatrixGenerator.GenerateMatrix();
for (int index = 0; index < generatedTiles.Count; index++)
{
Assert.AreEqual(generatedTiles[index].Position, tiles[index].Position);
Assert.AreEqual(generatedTiles[index].Label, tiles[index].Label);
}
}
public static void Start(IMatrixGenerator matrixGenerator, IWriter writer, IReader reader, IPrinter printer)
{
writer.WriteLine("Enter a positive number ");
string input = reader.ReadLine();
int matrixSize = 0;
while (!int.TryParse(input, out matrixSize) || matrixSize < 0 || matrixSize > 100)
{
writer.WriteLine("You haven't entered a correct positive number");
input = reader.ReadLine();
}
var generator = new MatrixGenerator();
var matrix = matrixGenerator.Generate(matrixSize);
printer.PrintMatrix(matrix);
}
public void NormalMultiplyWithIdentityMatrix()
{
Matrix a = new Matrix(new double[, ]
{
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }
});
Matrix b = MatrixGenerator.IdentityMatrix(3);
Matrix expected = new Matrix(new double[, ]
{
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }
});
Matrix actual = Matrix.NormalMultiply(a, b);
Assert.AreEqual(expected, actual);
}
private static void MatrixTest(DataTable tableOutput, ref ExcelWorkBookAdaptor adapter, ref Point topLeft, PythagoreanCalculator calc)
{
var generator = new MatrixGenerator(calc);
var matrix = generator.GenerateMatrix(tableOutput, new EastingNorthingColumnIndexer(0, 1));
if (null != matrix)
{
adapter = new ExcelWorkBookAdaptor();
adapter.NewBook();
adapter.Show();
var tableAdapter = new DataTableToExcelAdaptor(adapter[0], matrix);
tableAdapter.Write(topLeft);
}
var len = new SimpleTourLengthCalculator(matrix);
Console.WriteLine(len.TourLength(Enumerable.Range(0, 4).ToList <int>()).ToString());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
static void Main(string[] args)
{
var a = new SquareMatrix <int>(MatrixGenerator.GenerateIntSquareMatrix(5));
a[3, 3] = 5;
a[2, 4] = 3;
Print(a);
Console.WriteLine();
var b = new SymmetricMatrix <int>(MatrixGenerator.GenerateIntSymmetricMatrix(5));
b[1, 0] = 5;
b[2, 1] = 3;
Print(b);
Console.WriteLine();
var c = new DiagonalMatrix <int>(MatrixGenerator.GenerateIntDiagonalMatrix(5));
c[0, 0] = 5;
c[1, 1] = 3;
Print(c);
}
public void ReturnCorrectlyFilledMatrix_WhenPassedMatrixSizeIsSix()
{
// arrange
var expectedMatrix = new int[, ]
{
{ 1, 16, 17, 18, 19, 20, },
{ 15, 2, 27, 28, 29, 21, },
{ 14, 31, 3, 26, 30, 22, },
{ 13, 36, 32, 4, 25, 23, },
{ 12, 35, 34, 33, 5, 24, },
{ 11, 10, 9, 8, 7, 6 }
};
var matrixGenerator = new MatrixGenerator();
int matrixSize = 3;
// act
var resultMatrix = matrixGenerator.Generate(matrixSize);
CollectionAssert.AreEqual(expectedMatrix, resultMatrix);
}
public void ReturnCorrectlyFilledMatrix_WhenPassedMatrixSizeIsFive()
{
// arrange
var expectedMatrix = new int[, ]
{
{ 1, 13, 14, 15, 16 },
{ 12, 2, 21, 22, 17 },
{ 11, 23, 3, 20, 18, },
{ 10, 25, 24, 4, 19 },
{ 9, 8, 7, 6, 5 }
};
var matrixGenerator = new MatrixGenerator();
int matrixsize = 5;
// act
var resultMatrix = matrixGenerator.Generate(matrixsize);
// assert
CollectionAssert.AreEqual(resultMatrix, expectedMatrix);
}
public static void Main()
{
string[] args = Console.ReadLine()
.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
ArrayParser parser = new ArrayParser();
int[] dimensions = parser.IntegersParser(args);
int rows = dimensions[0];
int cols = dimensions[1];
MatrixGenerator matrixGenerator = new MatrixGenerator();
MatrixOperator matrixOperator = new MatrixOperator();
int[,] matrix = matrixGenerator.GenerateIntegersMatrix(rows, cols);
string command = null;
long sum = 0;
while ((command = Console.ReadLine()) != "Let the Force be with you")
{
string[] ivoArgs = command.Split();
int[] ivoCoordinates = parser.IntegersParser(ivoArgs);
string[] evilArgs = Console.ReadLine().Split();
int[] evilCoordinates = parser.IntegersParser(evilArgs);
int evilRow = evilCoordinates[0];
int evilCol = evilCoordinates[1];
matrixOperator.DeleteElementsFromBottomRightToUpperLeft(matrix, evilRow, evilCol);
int ivoRow = ivoCoordinates[0];
int ivoCol = ivoCoordinates[1];
sum += matrixOperator.SumElementsFromBottomLeftToUpperRight(matrix, ivoRow, ivoCol);
}
Console.WriteLine(sum);
}
private void InitializeMatrix(int size)
{
switch (RotationType)
{
case RotationType.Identity:
RotationMatrix = MatrixGenerator.Identity(size);
break;
case RotationType.Orthonormal:
RotationMatrix = MatrixGenerator.RandomOrthogonal(size);
break;
case RotationType.LinearTransform:
RotationMatrix = MatrixGenerator.RandomLinearTransformation(size, Condition);
break;
default:
throw new ArgumentException("Unknown matrix type.");
}
_initialized = true;
}
public void ShuffleMatrixTest()
{
List <ITile> tiles = new List <ITile>();
for (int index = 1; index < 16; index++)
{
tiles.Add(new Tile(index.ToString(), index - 1));
}
tiles.Add(new Tile(string.Empty, 15));
int occurrencesCount = 0;
IList <ITile> shuffledTiles = MatrixGenerator.ShuffleMatrix(tiles);
for (int index = 0; index < tiles.Count; index++)
{
if (tiles[index].Label == shuffledTiles[index].Label)
{
occurrencesCount++;
}
}
Assert.AreNotEqual(occurrencesCount, tiles.Count);
}
