Example #1
0
        /**
         * Multiplies this matrix (the one on the left) by another
         * matrix (the one on the right).
         */
        public Matrix times(Matrix right)
        {
            if (getColumns() != right.getRows())
            {
                throw new Exception(
                          "Columns on left (" + getColumns() + ") " +
                          "is different than rows on right (" + right.getRows() + ")");
            }
            Matrix result = new Matrix(getRows(), right.getColumns());

            for (int r = 0; r < getRows(); r++)
            {
                for (int c = 0; c < right.getColumns(); c++)
                {
                    byte value = 0;
                    for (int i = 0; i < getColumns(); i++)
                    {
                        value ^= Galois.multiply(get(r, i), right.get(i, c));
                    }
                    result.set(r, c, value);
                }
            }
            return(result);
        }
Example #2
0
        /**
         * Does the work of matrix inversion.
         *
         * Assumes that this is an r by 2r matrix.
         */
        private void gaussianElimination()
        {
            // Clear out the part below the main diagonal and scale the main
            // diagonal to be 1.
            for (int r = 0; r < rows; r++)
            {
                // If the element on the diagonal is 0, find a row below
                // that has a non-zero and swap them.
                if (data[r][r] == 0)
                {
                    for (int rowBelow = r + 1; rowBelow < rows; rowBelow++)
                    {
                        if (data[rowBelow][r] != 0)
                        {
                            swapRows(r, rowBelow);
                            break;
                        }
                    }
                }
                // If we couldn't find one, the matrix is singular.
                if (data[r][r] == 0)
                {
                    throw new Exception("Matrix is singular");
                }
                // Scale to 1.
                if (data[r][r] != 1)
                {
                    byte scale = Galois.divide(1, data[r][r]);
                    for (int c = 0; c < columns; c++)
                    {
                        data[r][c] = Galois.multiply(data[r][c], scale);
                    }
                }
                // Make everything below the 1 be a 0 by subtracting
                // a multiple of it.  (Subtraction and addition are
                // both exclusive or in the Galois field.)
                for (int rowBelow = r + 1; rowBelow < rows; rowBelow++)
                {
                    if (data[rowBelow][r] != 0)
                    {
                        byte scale = data[rowBelow][r];
                        for (int c = 0; c < columns; c++)
                        {
                            data[rowBelow][c] ^= Galois.multiply(scale, data[r][c]);
                        }
                    }
                }
            }

            // Now clear the part above the main diagonal.
            for (int d = 0; d < rows; d++)
            {
                for (int rowAbove = 0; rowAbove < d; rowAbove++)
                {
                    if (data[rowAbove][d] != 0)
                    {
                        byte scale = data[rowAbove][d];
                        for (int c = 0; c < columns; c++)
                        {
                            data[rowAbove][c] ^= Galois.multiply(scale, data[d][c]);
                        }
                    }
                }
            }
        }