Да се напише класа која чува матрица од float вредности FloatMatrix. Класата треба да е immutable. Тоа значи дека, откако еднаш ќе се инстанцира да не може да се менува состојбата на објектот, односно да не може да се менуваат податоците зачувани во него. За потребите на класата треба да се имплементираат следните методи:

FloatMatrix(float a[], int m, int n) - конструктор кој прима низа од реални броеви каде што m и n се димензиите на матрицата. Доколку нема доволно елементи во низата тогаш да се фрли исклучок InsufficientElementsException, а доколку има повеќе елементи да се земат последните m x n вредности, т.е. да се игнорираат вишокот на броеви од почетокот на низата
getMatrixDimensions():String - метод кој враќа стринг во формат [m x n]
numRows():int - метод кој враќа број на редови
numColumns():int - метод кој враќа број на колони
maxElementAtRow(int row):float- метод кој го враќа максималниот елемент во дадениот ред, доколку вредноста е ред кој не постои да се фрли исклучок InvalidRowNumberException (row има вредност [1, m])
maxElementAtColumn(int column):float- метод кој го враќа максималниот елемент во дадената колона, доколку вредноста е колона кој не постои да се фрли исклучок InvalidColumnNumberException (column има вредност [1, n])
sum() : float - метод кој ја враќа сумата на сите елементи од матрицата
toSortedArray():float[] – метод кој враќа еднодимензионална низа каде вредностите се сортирани во опаѓачки редослед
toString() - методот, каде броевите се заокружени на 2 децимални места, меѓу себе се одделени со табулаторско место \t а редовите на матрицата се одделени со нов ред
да се преоптоварат equals() и hashCode() методите
Забелешка: Исклучоците не треба да се фаќаат, треба само да се фрлаат

Да се дефинира класаInsufficientElementsException која што наследува од класата Exception и при фрлање на исклучок се добива порака"Insufficient number of elements"

Да се дефинира класа InvalidRowNumberExceptionкоја што наследува од класата Exception и при фрлање на исклучок се добива порака "Invalid row number"

Да се дефинира класа InvalidColumnNumberException која што наследува од класата Exception и при фрлање на исклучок се добива порака "Invalid column number"

Покрај класата FloatMatrix треба да напишете дополнително уште една класа која ќе служи за вчитување на матрица од реални броеви од влезен тек на податоци. Оваа класа треба да се вика MatrixReader и во неа треба да имате еден public static метод за вчитување на матрица од реални броеви од InputStream

readFloatMatrix(InputStream input):FloatMatrix - вчитува матрица од реални броеви од input зададена во следниот формат: Во првата линија има два цели броеви кои кажуваат колку редови и колони има матрицата, а во наредните редови се дадени елементите на матрицата по редови, одделени со едно или повеќе празни места



import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
import java.io.IOException;

class FloatMatrix {
    private int size;
    private float matrica[][];
    private int x, y;

    FloatMatrix(float a[], int m, int n) throws InsufficientElementsException {
        size = a.length;
        x = m;
        y = n;
        if (size < x * y)
            throw new InsufficientElementsException();
        else {
            int br = size - x * y;
            matrica = new float[m][n];
            for (int k = 0; k < m; k++)
                for (int l = 0; l < n; l++) {
                    matrica[k][l] = a[br];
                    br++;
                }
        }
    }

    public String getMatrixDimensions() {
        int row = numRows();
        int col = numColumns();
        return "[" + row + " x " + col + "]";
    }

    public int numRows() {
        return x;
    }

    public int numColumns() {
        return y;
    }

    public float maxElementAtRow(int row) throws InvalidRowNumberException {
        float max = matrica[0][0];

        if (row - 1 >= x || x < 0)
            throw new InvalidRowNumberException();
        for (int i = 0; i < y; i++)
            if (matrica[row - 1][i] > max)
                max = matrica[row - 1][i];
        return max;
    }

    float maxElementAtColumn(int column) throws InvalidColumnNumberException {
        float max = matrica[0][0];

        if (column - 1 >= y || y < 0)
            throw new InvalidColumnNumberException();
        for (int i = 0; i < x; i++)
            if (matrica[i][column - 1] > max)
                max = matrica[i][column - 1];
        return max;
    }

    public float sum() {
        float suma = 0;
        for (int i = 0; i < x; i++)
            for (int j = 0; j < y; j++)
                suma += matrica[i][j];
        return suma;
    }

    float[] toSortedArray() {
        float[] arr = new float[x * y];
        float temp = 0;
        int br = 0;
        for (int k = 0; k < x; k++)
            for (int l = 0; l < y; l++) {
                arr[br] = matrica[k][l];
                br++;
            }
        for (int i = 0; i < x * y; i++)
            for (int j = 1; j < x * y - i; j++) {
                if (arr[j - 1] < arr[j]) {
                    temp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = temp;
                }
            }

        return arr;
    }

    @Override
    public String toString() {

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < x; i++) {
            for (int j = 0; j < y; j++) {
                sb.append(String.format("%.2f", matrica[i][j] + "\t"));
            }
            sb.append("\n");
        }

        return sb.toString();
    }

    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + y;
        result = prime * result + Arrays.hashCode(matrica);
        result = prime * result + x;
        return result;
    }

    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        FloatMatrix other = (FloatMatrix) obj;
        if (x != other.x)
            return false;
        if (!Arrays.deepEquals(matrica, other.matrica))
            return false;
        if (y != other.y)
            return false;
        return true;
    }
}

class MatrixReader {
    public static FloatMatrix readFloatMatrix(InputStream input)
            throws InsufficientElementsException {
        Scanner in = new Scanner(input);
        int n = in.nextInt();
        int m = in.nextInt();
        float[] niza = new float[n * m];
        for (int i = 0; i < (n * m); i++)
            niza[i] = in.nextFloat();
        in.close();
        return new FloatMatrix(niza, n, m);
    }
}

class InsufficientElementsException extends Exception {
    InsufficientElementsException() {
        super("Insufficient number of elements");
    }
}

class InvalidRowNumberException extends Exception {
    InvalidRowNumberException() {
        super("Invalid row number");
    }
}

class InvalidColumnNumberException extends Exception {
    /**
     *
     */
    private static final long serialVersionUID = 1L;

    InvalidColumnNumberException() {
        super("Invalid column number");
    }
}

public class FloatMatrixTester {

    // MAIN POCETOK
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);

        int tests = scanner.nextInt();
        FloatMatrix fm = null;

        float[] info = null;

        DecimalFormat format = new DecimalFormat("0.00");

        for (int t = 0; t < tests; t++) {

            String operation = scanner.next();

            switch (operation) {
            case "READ": {
                int N = scanner.nextInt();
                int R = scanner.nextInt();
                int C = scanner.nextInt();

                float[] f = new float[N];

                for (int i = 0; i < f.length; i++)
                    f[i] = scanner.nextFloat();

                try {
                    fm = new FloatMatrix(f, R, C);
                    info = Arrays.copyOf(f, f.length);

                } catch (InsufficientElementsException e) {
                    System.out.println("Exception caught: " + e.getMessage());
                }

                break;
            }

            case "INPUT_TEST": {
                int R = scanner.nextInt();
                int C = scanner.nextInt();

                StringBuilder sb = new StringBuilder();

                sb.append(R + " " + C + "\n");

                scanner.nextLine();

                for (int i = 0; i < R; i++)
                    sb.append(scanner.nextLine() + "\n");

                fm = MatrixReader.readFloatMatrix(new ByteArrayInputStream(sb
                        .toString().getBytes()));

                info = new float[R * C];
                Scanner tempScanner = new Scanner(new ByteArrayInputStream(sb
                        .toString().getBytes()));
                tempScanner.nextFloat();
                tempScanner.nextFloat();
                for (int z = 0; z < R * C; z++) {
                    info[z] = tempScanner.nextFloat();
                }

                tempScanner.close();

                break;
            }

            case "PRINT": {
                System.out.println(fm.toString());
                break;
            }

            case "DIMENSION": {
                System.out.println("Dimensions: " + fm.getMatrixDimensions());
                break;
            }

            case "COUNT_ROWS": {
                System.out.println("Rows: " + fm.numRows());
                break;
            }

            case "COUNT_COLUMNS": {
                System.out.println("Columns: " + fm.numColumns());
                break;
            }

            case "MAX_IN_ROW": {
                int row = scanner.nextInt();
                try {
                    System.out.println("Max in row: "
                            + format.format(fm.maxElementAtRow(row)));
                } catch (InvalidRowNumberException e) {
                    System.out.println("Exception caught: " + e.getMessage());
                }
                break;
            }

            case "MAX_IN_COLUMN": {
                int col = scanner.nextInt();
                try {
                    System.out.println("Max in column: "
                            + format.format(fm.maxElementAtColumn(col)));
                } catch (InvalidColumnNumberException e) {
                    System.out.println("Exception caught: " + e.getMessage());
                }
                break;
            }

            case "SUM": {
                System.out.println("Sum: " + format.format(fm.sum()) );
                break;
            }

            case "CHECK_EQUALS": {
                int val = scanner.nextInt();

                int maxOps = val % 7;

                for (int z = 0; z < maxOps; z++) {
                    float work[] = Arrays.copyOf(info, info.length);

                    int e1 = (31 * z + 7 * val + 3 * maxOps) % info.length;
                    int e2 = (17 * z + 3 * val + 7 * maxOps) % info.length;

                    if (e1 > e2) {
                        float temp = work[e1];
                        work[e1] = work[e2];
                        work[e2] = temp;
                    }

                    FloatMatrix f1 = fm;
                    FloatMatrix f2 = new FloatMatrix(work, fm.numRows(),
                            fm.numColumns());
                    System.out
                            .println("Equals check 1: "
                                    + f1.equals(f2)
                                    + " "
                                    + f2.equals(f1)
                                    + " "
                                    + (f1.hashCode() == f2.hashCode()&&f1
                                            .equals(f2)));
                }

                if (maxOps % 2 == 0) {
                    FloatMatrix f1 = fm;
                    FloatMatrix f2 = new FloatMatrix(new float[] { 3.0f, 5.0f,
                            7.5f }, 1, 1);

                    System.out
                            .println("Equals check 2: "
                                    + f1.equals(f2)
                                    + " "
                                    + f2.equals(f1)
                                    + " "
                                    + (f1.hashCode() == f2.hashCode() && f1
                                            .equals(f2)));
                }

                break;
            }

            case "SORTED_ARRAY": {
                float[] arr = fm.toSortedArray();

                String arrayString = "[";

                if (arr.length > 0)
                    arrayString += format.format(arr[0]) + "";

                for (int i = 1; i < arr.length; i++)
                    arrayString += ", " + format.format(arr[i]);

                arrayString += "]";

                System.out.println("Sorted array: " + arrayString);
                break;
            }

            }

        }

        scanner.close();
    }
}