Untitled

    public static <T extends MyMatrixType<T>> MyMatrix<T> generate(int size, Class<T> tClass) throws Exception {
        if(size < 2 ) throw new IllegalArgumentException("Invalid arguments!");
        ArrayList<ArrayList<T>> resultMatrix = new ArrayList<>();
        int arraySize = calculateArraySize(size);
        for(int y = 0; y <= size; y++){
            for(int n = 0; n <= (size-y); n++){
                T yValue = MyMatrixTypeFactory.generateMatrixType(y, tClass);
                T nValue = MyMatrixTypeFactory.generateMatrixType(n, tClass);
                T sizeValue = MyMatrixTypeFactory.generateMatrixType(size, tClass);
                T uValue = MyMatrixTypeFactory.generateMatrixType(size-n-y, tClass);
                T yProbability = yValue.divide(sizeValue);
                T nProbability = nValue.divide(sizeValue);
                T uProbability = uValue.divide(sizeValue);
                ArrayList<T> newRow = new ArrayList<>(Collections.nCopies(arraySize,MyMatrixTypeFactory.generateMatrixType(0, tClass)));
                T sizeMinusOneValue = MyMatrixTypeFactory.generateMatrixType(size -1, tClass);
                T yuProbability = yProbability.multiply(uValue.divide(sizeMinusOneValue));
                T ynProbability = yProbability.multiply(nValue.divide(sizeMinusOneValue));
                T yyProbability =  yProbability.multiply(MyMatrixTypeFactory.generateMatrixType(y-1, tClass)).divide(sizeMinusOneValue);
                T uyProbability = uProbability.multiply(yValue.divide(sizeMinusOneValue));
                T unProbability = uProbability.multiply(nValue.divide(sizeMinusOneValue));
                T uuProbability = uProbability.multiply(MyMatrixTypeFactory.generateMatrixType(size -n -y -1, tClass).divide(sizeMinusOneValue));
                T nyProbability = nProbability.multiply(yValue.divide(sizeMinusOneValue));
                T nnProbability = nProbability.multiply(MyMatrixTypeFactory.generateMatrixType(n-1, tClass).divide(sizeMinusOneValue));
                T nuProbability = nProbability.multiply(uValue.divide(sizeMinusOneValue));
                T yPlusOneProbability = yuProbability.add(uyProbability);
                T nPlusOneProbability = nuProbability.add(unProbability);
                T uPlusTwoProbability = ynProbability.add(nyProbability);
                T noChangeProbability = yyProbability.add(nnProbability).add(uuProbability);
                T zeroValue = MyMatrixTypeFactory.generateMatrixType(0,tClass);
                if(yPlusOneProbability.greaterThan(zeroValue)) newRow.set(calculateIndexInRow(y+1,n,size), yPlusOneProbability);
                if(nPlusOneProbability.greaterThan(zeroValue)) newRow.set(calculateIndexInRow(y,n+1,size), nPlusOneProbability);
                if(uPlusTwoProbability.greaterThan(zeroValue)) newRow.set(calculateIndexInRow(y-1,  n-1, size), uPlusTwoProbability);
                newRow.set(calculateIndexInRow(y,n,size), noChangeProbability.subtract(MyMatrixTypeFactory.generateMatrixType(1, tClass)));
                if(noChangeProbability.getDoubleValue() == 1.0) newRow.set(calculateIndexInRow(y,n,size), MyMatrixTypeFactory.generateMatrixType(1, tClass));
                resultMatrix.add(newRow);
            }
        }
        resultMatrix.get(0).set(0, MyMatrixTypeFactory.generateMatrixType(1, tClass));
        resultMatrix.get(arraySize-1).set(arraySize-1, MyMatrixTypeFactory.generateMatrixType(1, tClass));
        return new MyMatrix<>(resultMatrix);
    }