/// <summary> /// Returns true iff <c>object</c> is a /// <c>FieldMatrix</c> instance with the same dimensions as this /// and all corresponding matrix entries are equal. /// </summary> /// <param name="obj">the object to test equality against.</param> /// <returns>true if object equals this</returns> public override Boolean Equals(Object obj) { if (obj == this) { return(true); } if (obj is FieldMatrix <T> ) { return(false); } FieldMatrix <T> m = (FieldMatrix <T>)obj; int nRows = getRowDimension(); int nCols = getColumnDimension(); if (m.getColumnDimension() != nCols || m.getRowDimension() != nRows) { return(false); } for (int row = 0; row < nRows; ++row) { for (int col = 0; col < nCols; ++col) { if (!getEntry(row, col).Equals(m.getEntry(row, col))) { return(false); } } } return(true); }
private bool FilledCoordinateNotSelf(List <Coordinate> coordinates, Coordinate coordinate) { FieldMatrix matrix = field.FieldMatrix; return(!(matrix.ValidCoordinate(coordinate) && (matrix[coordinate] == null || matrix[coordinate] == Brick))); }
/// <summary> /// Check if a matrix is multiplication compatible with the instance. /// </summary> /// <param name="m">Matrix to check.</param> /// <exception cref="DimensionMismatchException"> if the matrix is not /// multiplication-compatible with instance.</exception> protected void checkMultiplicationCompatible(FieldMatrix <T> m) { if (getColumnDimension() != m.getRowDimension()) { throw new DimensionMismatchException(m.getRowDimension(), getColumnDimension()); } }
public void OnPointerClick(PointerEventData eventData) { if (_dragging || Input.touchCount > 1 || eventData.button != PointerEventData.InputButton.Left) { return; } if (nextClickOverride != null) { nextClickOverride(); nextClickOverride = null; return; } Utils.GetInputCoords(out var x, out var y); if (FieldMatrix.Get(x, y, out var block)) { block.logic.Click(eventData); } else { PixelDriver.Add(PixelRoad.Circle(Colors.GetPalette(-1)[3], 3f, 3f, 0.05f, 0.5f, x, y).SetWeight(0.05f)); } }
/// <inheritdoc/> public FieldMatrix <T> multiply(FieldMatrix <T> m) { // safety check checkMultiplicationCompatible(m); int nRows = getRowDimension(); int nCols = m.getColumnDimension(); int nSum = getColumnDimension(); FieldMatrix <T> outp = createMatrix(nRows, nCols); for (int row = 0; row < nRows; ++row) { for (int col = 0; col < nCols; ++col) { T sum = field.getZero(); for (int i = 0; i < nSum; ++i) { sum = sum.add(getEntry(row, i).multiply(m.getEntry(i, col))); } outp.setEntry(row, col, sum); } } return(outp); }
/// <summary> /// Convert a <see cref="FieldMatrix"/>/<see cref="BigFraction"/> matrix to a /// <see cref="RealMatrix"/>. /// </summary> /// <param name="m">Matrix to convert.</param> /// <returns>the converted matrix.</returns> public static Array2DRowRealMatrix bigFractionMatrixToRealMatrix(FieldMatrix <BigFraction> m) { BigFractionMatrixConverter converter = new BigFractionMatrixConverter(); m.walkInOptimizedOrder(converter); return(converter.getConvertedMatrix()); }
public void SnakeGame_GameIteration_SnakeCrash() { Position head = new Position(), tail = new Position(); eCellType[] field = new eCellType[64]; FieldMatrix.Seed(field, head, tail); eDirectionType currentDirection = eDirectionType.None, nextDirection = eDirectionType.Right; FieldMatrix.SetCellTypeByPosition(field, new Position() { row = head.row, col = (byte)(head.col + 1) }, eCellType.SnakeDown); Assert.ThrowsException <CrashedInSnakeException>(() => GameEngine.ApplyChange(field, head, tail, currentDirection, nextDirection, out bool expanded), "Did not crash moving to the right"); FieldMatrix.Seed(field, head, tail); FieldMatrix.SetCellTypeByPosition(field, new Position() { row = (byte)(head.row + 1), col = head.col }, eCellType.SnakeHead); nextDirection = eDirectionType.Down; Assert.ThrowsException <CrashedInSnakeException>(() => GameEngine.ApplyChange(field, head, tail, currentDirection, nextDirection, out bool expanded), "Did not crash moving down"); }
static void DragFromTo(int fromX, int fromY, int toX, int toY) { if (!FieldMatrix.Get(fromX, fromY, out var fromBlock)) { return; } if (FieldMatrix.Get(toX, toY, out var toBlock)) { var bind = BindMatrix.GetBind(fromBlock, toBlock); var newBlockOffset = new Vector2(toX - fromX, toY - fromY); if (bind == null) { BindMatrix.AddBind(fromBlock, toBlock, newBlockOffset, Bind.BlockBindStrength); return; } if (bind.First != fromBlock) { if (!(fromBlock is RootBlock) && BindMatrix.GetOutBindsCount(fromBlock) == 0) { fromBlock.Destroy(); return; } bind.Break(); BindMatrix.AddBind(fromBlock, toBlock, newBlockOffset, Bind.BlockBindStrength); return; } return; } NodeBlock.Create(toX, toY, fromBlock); }
void FinishPlacing() { if (_placing) { return; } var position = cam.transform.position; int x = Mathf.RoundToInt(position.x), y = Mathf.RoundToInt(position.y); if (FieldMatrix.Get(x, y, out _)) { Animator.Interpolate( new Color(0.3f, 0f, 0f, DarkenAlpha), new Color(0f, 0f, 0f, DarkenAlpha), 1f) .Type(InterpolationType.Square) .PassValue(v => background.color = v); return; } _placing = true; Animator.Interpolate(DarkenAlpha, 0f, 1f).Type(InterpolationType.Linear) .PassValue(v => { background.color = new Color(0, 0, 0, v); }) .WhenDone(() => { gameObject.SetActive(false); Roots.CreateRoot(x, y, -1, palette.ColorsId); _placing = false; }); }
// Use this for initialization void OnEnable() { fieldMatrix = GetComponent <FieldMatrix>(); field = fieldMatrix.playingfield; x = fieldMatrix.x; z = fieldMatrix.z; SpawnInField(); }
/// <summary> /// Check if a matrix is subtraction compatible with the instance. /// </summary> /// <param name="m">Matrix to check.</param> /// <exception cref="MatrixDimensionMismatchExceptio">n if the matrix is not /// subtraction-compatible with instance.</exception> protected void checkSubtractionCompatible(FieldMatrix <T> m) { if ((getRowDimension() != m.getRowDimension()) || (getColumnDimension() != m.getColumnDimension())) { throw new MatrixDimensionMismatchException(m.getRowDimension(), m.getColumnDimension(), getRowDimension(), getColumnDimension()); } }
/// <inheritdoc/> public FieldMatrix <T> transpose() { int nRows = getRowDimension(); int nCols = getColumnDimension(); FieldMatrix <T> outp = createMatrix(nCols, nRows); walkInOptimizedOrder(new DefaultFieldMatrixPreservingVisitorAnonymous2 <T>(field.getZero(), outp)); return(outp); }
public void ClearField() { foreach (var root in Roots.Root.Values.ToArray()) { root.Destroy(); } foreach (var block in FieldMatrix.GetAllAsList()) { block.Destroy(); } }
/// <summary> /// Returns a diagonal matrix with specified elements. /// </summary> /// <typeparam name="T">the type of the field elements</typeparam> /// <param name="diagonal">diagonal elements of the matrix (the array elements /// will be copied)</param> /// <returns>diagonal matrix</returns> public static FieldMatrix <T> createFieldDiagonalMatrix <T>(T[] diagonal) where T : FieldElement <T> { FieldMatrix <T> m = createFieldMatrix(diagonal[0].getField(), diagonal.Length, diagonal.Length); for (int i = 0; i < diagonal.Length; ++i) { m.setEntry(i, i, diagonal[i]); } return(m); }
/// <inheritdoc/> public FieldMatrix <T> getColumnMatrix(int column) { checkColumnIndex(column); int nRows = getRowDimension(); FieldMatrix <T> outp = createMatrix(nRows, 1); for (int i = 0; i < nRows; ++i) { outp.setEntry(i, 0, getEntry(i, column)); } return(outp); }
/// <summary> /// Returns the P rows permutation matrix. /// <para>P is a sparse matrix with exactly one element set to 1.0 in /// each row and each column, all other elements being set to 0.0.</para> /// <para>The positions of the 1 elements are given by the <see cref="getPivot()"> /// pivot permutation vector</see>.</para> /// </summary> /// <returns>the P rows permutation matrix (or null if decomposed matrix is singular) /// </returns> /// <remarks> /// See <see cref="getPivot()"/> /// </remarks> public FieldMatrix <T> getP() { if ((cachedP == null) && !singular) { int m = pivot.Length; cachedP = new Array2DRowFieldMatrix <T>(field, m, m); for (int i = 0; i < m; ++i) { cachedP.setEntry(i, pivot[i], field.getOne()); } } return(cachedP); }
/// <inheritdoc/> public FieldMatrix <T> getRowMatrix(int row) { checkRowIndex(row); int nCols = getColumnDimension(); FieldMatrix <T> outp = createMatrix(1, nCols); for (int i = 0; i < nCols; ++i) { outp.setEntry(0, i, getEntry(row, i)); } return(outp); }
/// <inheritdoc/> public FieldMatrix <T> getSubMatrix(int[] selectedRows, int[] selectedColumns) { // safety checks checkSubMatrixIndex(selectedRows, selectedColumns); // copy entries FieldMatrix <T> subMatrix = createMatrix(selectedRows.Length, selectedColumns.Length); subMatrix.walkInOptimizedOrder(new DefaultFieldMatrixChangingVisitorAnonymous1 <T>(field.getZero(), selectedRows, selectedColumns, this)); return(subMatrix); }
public static GameSerialized Create() { var result = new GameSerialized { NodeBlocks = new List <NodeBlockSerialized>(), RootBlocks = new List <RootBlockSerialized>(), Binds = new List <BindSerialized>(), SoundsPlayers = new List <SoundsPlayerSerialized>(), }; foreach (var block in FieldMatrix.GetAllAsList()) { switch (block) { case NodeBlock nodeBlock: { if (NodeBlockSerialized.Create(nodeBlock, out var t)) { result.NodeBlocks.Add(t); } break; } case RootBlock rootBlock: { if (RootBlockSerialized.Create(rootBlock, out var t)) { result.RootBlocks.Add(t); } break; } } } foreach (var bind in BindMatrix.GetAllAsList()) { if (BindSerialized.Create(bind, out var t)) { result.Binds.Add(t); } } foreach (var root in Roots.Root.Values) { if (SoundsPlayerSerialized.Create(root.block.soundsPlayer, root.block.rootId, out var t)) { result.SoundsPlayers.Add(t); } } return(result); }
/// <inheritdoc/> public FieldMatrix <T> scalarAdd(T d) { int rowCount = getRowDimension(); int columnCount = getColumnDimension(); FieldMatrix <T> outp = createMatrix(rowCount, columnCount); for (int row = 0; row < rowCount; ++row) { for (int col = 0; col < columnCount; ++col) { outp.setEntry(row, col, getEntry(row, col).add(d)); } } return(outp); }
public static PixelRoad NodeBackground() { var pr = new PixelRoad(-1f); pr._colorFunc = (x, y) => { if (FieldMatrix.Get(x, y, out var block)) { return(new WeightedColor(Roots.Root[block.rootId].block.view.PrimaryPainter.palette.GetColor(2), pr._weight)); } return(WeightedColor.Clear); }; return(pr); }
public void OnBeginDrag(PointerEventData eventData) { if (eventData.button != PointerEventData.InputButton.Left || Input.touchCount > 1) { return; } _dragging = true; Utils.GetInputCoords(out var x, out var y); if (FieldMatrix.Get(x, y, out _draggedBlock)) { _draggingBlock = true; _draggedBlock.logic.BeginDrag(eventData); BlockEditor.OnBlockDragStart(_draggedBlock); } }
/// <inheritdoc/> public FieldMatrix <T> getSubMatrix(int startRow, int endRow, int startColumn, int endColumn) { checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); FieldMatrix <T> subMatrix = createMatrix(endRow - startRow + 1, endColumn - startColumn + 1); for (int i = startRow; i <= endRow; ++i) { for (int j = startColumn; j <= endColumn; ++j) { subMatrix.setEntry(i - startRow, j - startColumn, getEntry(i, j)); } } return(subMatrix); }
public void SnakeGame_GameIteration_TurnUp() { Position head = new Position(), tail = new Position(); eCellType[] field = new eCellType[64]; FieldMatrix.Seed(field, head, tail); eDirectionType currentDirection = eDirectionType.None, nextDirection = eDirectionType.Up; GameEngine.ApplyChange(field, head, tail, currentDirection, nextDirection, out bool expanded); Assert.AreEqual(3, field.Count(c => c != eCellType.None)); Assert.AreEqual(eCellType.SnakeRight, field[TestOffset(3, 3)], "Tail did not move to the right"); Assert.AreEqual(eCellType.SnakeUp, field[TestOffset(3, 4)], "Body did not move to the right"); Assert.AreEqual(eCellType.SnakeHead, field[TestOffset(2, 4)], "Head did not move up"); }
/// <summary> /// Returns the matrix U of the decomposition. /// <para>U is an upper-triangular matrix</para> /// </summary> /// <returns>the U matrix (or null if decomposed matrix is singular)</returns> public FieldMatrix <T> getU() { if ((cachedU == null) && !singular) { int m = pivot.Length; cachedU = new Array2DRowFieldMatrix <T>(field, m, m); for (int i = 0; i < m; ++i) { T[] luI = lu[i]; for (int j = i; j < m; ++j) { cachedU.setEntry(i, j, luI[j]); } } } return(cachedU); }
/// <inheritdoc/> public void setColumnMatrix(int column, FieldMatrix <T> matrix) { checkColumnIndex(column); int nRows = getRowDimension(); if ((matrix.getRowDimension() != nRows) || (matrix.getColumnDimension() != 1)) { throw new MatrixDimensionMismatchException(matrix.getRowDimension(), matrix.getColumnDimension(), nRows, 1); } for (int i = 0; i < nRows; ++i) { setEntry(i, column, matrix.getEntry(i, 0)); } }
/// <inheritdoc/> public void setRowMatrix(int row, FieldMatrix <T> matrix) { checkRowIndex(row); int nCols = getColumnDimension(); if ((matrix.getRowDimension() != 1) || (matrix.getColumnDimension() != nCols)) { throw new MatrixDimensionMismatchException(matrix.getRowDimension(), matrix.getColumnDimension(), 1, nCols); } for (int i = 0; i < nCols; ++i) { setEntry(row, i, matrix.getEntry(0, i)); } }
/// <summary> /// Returns the matrix L of the decomposition. /// <para>L is a lower-triangular matrix</para> /// </summary> /// <returns>the L matrix (or null if decomposed matrix is singular)</returns> public FieldMatrix <T> getL() { if ((cachedL == null) && !singular) { int m = pivot.Length; cachedL = new Array2DRowFieldMatrix <T>(field, m, m); for (int i = 0; i < m; ++i) { T[] luI = lu[i]; for (int j = 0; j < i; ++j) { cachedL.setEntry(i, j, luI[j]); } cachedL.setEntry(i, i, field.getOne()); } } return(cachedL); }
/// <inheritdoc/> public FieldMatrix <T> subtract(FieldMatrix <T> m) { // safety check checkSubtractionCompatible(m); int rowCount = getRowDimension(); int columnCount = getColumnDimension(); FieldMatrix <T> outp = createMatrix(rowCount, columnCount); for (int row = 0; row < rowCount; ++row) { for (int col = 0; col < columnCount; ++col) { outp.setEntry(row, col, getEntry(row, col).subtract(m.getEntry(row, col))); } } return(outp); }
/// <summary> /// Creates a column <see cref="FieldMatrix"/> using the data from the input /// array. /// </summary> /// <typeparam name="T">the type of the field elements</typeparam> /// <param name="columnData">the input column data</param> /// <returns>a columnData x 1 FieldMatrix</returns> /// <exception cref="NoDataException"> if <c>data</c> is empty.</exception> /// <exception cref="NullArgumentException"> if <c>columnData</c> is <c>null</c>. /// </exception> public static FieldMatrix <T> createColumnFieldMatrix <T>(T[] columnData) where T : FieldElement <T> { if (columnData == null) { throw new NullArgumentException(); } int nRows = columnData.Length; if (nRows == 0) { throw new NoDataException(new LocalizedFormats("AT_LEAST_ONE_ROW")); } FieldMatrix <T> m = createFieldMatrix(columnData[0].getField(), nRows, 1); for (int i = 0; i < nRows; ++i) { m.setEntry(i, 0, columnData[i]); } return(m); }