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