0
\$\begingroup\$

So far this is what I have completed. Still working on these two methods

  • boolean isIdentityMatrix(DenseMatrix matrix);
  • boolean isInvertible(DenseMatrix matrix);

Suggestions are appreciated. Thanks.

//Dense Matrix

package matrix.denseMatrix;

import java.util.Arrays;

public class DenseMatrix
{
    private int[][] elements;
    private int n;

    // in default 3x3 matrix will be created
    public DenseMatrix()
    {
        this(3);
    }

    public DenseMatrix(int size)
    {
        n = size;
        elements = new int[n][n];

        for(int[] rows : elements)
        {
            Arrays.fill(rows, 0);
        }
    }

    public int size()
    {
        return n;
    }

    public int getValue(int i, int j)
    {
        if((i | j) >= n || (i | j) < 0)
        {
            throw new IndexOutOfBoundsException();
        }
        else
        {
            return elements[i][j];
        }
    }

    public boolean set(int i, int j, int value)
    {
        if((i | j) >= n || (i | j) < 0)
        {
            throw new IndexOutOfBoundsException();
        }
        else
        {
            elements[i][j] = value;
            return true;
        }
    }

    public boolean increaseBy(int i, int j, int valueBy) throws IndexOutOfBoundsException
    {
        return set(i, j, getValue(i, j) + valueBy);
    }

    public boolean decreaseBy(int i, int j, int valueBy) throws IndexOutOfBoundsException
    {
        return set(i, j, getValue(i, j) - valueBy);
    }

    public void clear()
    {
        elements = null;
        n = 0;
    }

    public DenseMatrix add(DenseMatrix other)
    {
        if(this.size() != other.size())
        {
            return null;
        }
        else
        {
            DenseMatrix result = new DenseMatrix(this.size());

            for(int i = 0; i < this.size(); i++)
            {
                for(int j = 0; j < this.size(); j++)
                {
                    result.set(i, j, this.getValue(i, j) + other.getValue(i, j));
                }
            }
            return result;
        }
       }

    public DenseMatrix negative()
    {
        DenseMatrix result = new DenseMatrix(this.size());

        for(int i = 0; i < this.size(); i++)
        {
            for(int j = 0; j < this.size(); j++)
            {
                result.set(i, j, this.getValue(i, j) * -1);
            }
        }
        return result;
    }

    public DenseMatrix multiply(DenseMatrix other)
    {
        if(this.size() != other.size())
        {
            return null;
        }
        else
        {
            DenseMatrix result = new DenseMatrix(this.size());

            for(int i = 0; i < this.size(); i++)
            {
                for(int j = 0; j < this.size(); j++)
                {
                    for(int k = 0; k < this.size(); k++)
                    {
                        result.increaseBy(i, j, (this.getValue(i, k) * other.getValue(k, j)));
                    }
                }
            }
            return result;
        }
    }

    public DenseMatrix transpose()
    {
        DenseMatrix result = new DenseMatrix(this.size());

        for(int i = 0; i < this.size(); i++)
        {
            for(int j = 0; j < this.size(); j++)
            {
                result.set(i, j, this.getValue(j, i));
            }
        }
        return result;
    }

    @Override
    public boolean equals(Object object)
    {
        if (this == object)
        {
            return true;
        }
        if (!(object instanceof DenseMatrix))
        {
            return false;
        }

        DenseMatrix that = (DenseMatrix) object;

        if(this.size() != that.size())
        {
            return false;
        }
        else
        {
            boolean isEqual = true;
            CHECKING: for(int i = 0; i < this.size(); i++)
            {
                for(int j = 0; j < this.size(); j++)
                {
                    if(this.getValue(i, j) != that.getValue(i, j))
                    {
                        isEqual = false;
                        break CHECKING;
                    }
                }
            }
            return isEqual;
        }
    }

    @Override
    public DenseMatrix clone()
    {
        DenseMatrix clonedMatrix = new DenseMatrix(this.size());

        for(int i = 0; i < this.size(); i++)
        {
            for(int j = 0; j < this.size(); j++)
            {
                clonedMatrix.set(i, j, this.getValue(i, j));
            }
        }
        return clonedMatrix;
    }
}
\$\endgroup\$
1
\$\begingroup\$
if((i | j) >= n || (i | j) < 0)

This line does not work as you probably expect: i | j is the binary or function and will create a new int, like in this example:

i = 0101_b;
j = 0011_b;
k = i | j; // == 0111_b

You will get false IndexOutOfBoundsException with this, for example, if your matrix is 2x2, and you call getValue(2, 1).

\$\endgroup\$
  • \$\begingroup\$ A 2x2 matrix can have the max index of (1, 1). Any index being above 1 will throw IndexOutOfBoundsException. \$\endgroup\$ – Hamidur Rahman Aug 23 '18 at 18:03
0
\$\begingroup\$

one dimensional array
Defining the backing array with only one dimension allows immediatly to use the class Arrays - instead of row- or column-wise. It provides functionality which then you don't need to write.

private int[] elements;

Initialization:
elements = new int[n*n];

That's all. There is no need to fill the array row-wise with 0. According to JLS all elements are initialized with the default value of the component type. This is 0 in case of int,

Determine the position of an element to get or set it's value: elements[i * n + j];

comparing two arrays for equality
When using a one dimensional array you can call Arrays.equals(int[] a, int[] b) to check if the backing arrays are equal.

cloning the matrix
When using a one dimensional array you can call Arrays.copyOf(elements, elements.length) to create a copy of the backing array using a native method which performs very fast.

dedicated zero-size matrix
If your application will use frequently zero-size matrices, you could follow the example of Collections.emptyMap() and implement a dedicated subtype of DenseMatrix which will have simplified implementations of the mathods provided by DenseMatrix. Storing such a zero-sized matrix as a singleton will save memory and creation time.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.