정수 크기를 가져올 때 스택 오버플로 오류가 발생합니까?

Question

클래스 코드 프로젝트의 일부로 할당의 일부는 Strassen 메서드를 사용하여 두 개의 행렬을 곱하는 알고리즘을 작성하는 것입니다.

이렇게하려면 필요한 알고리즘을 만들었지 만 getSize() 호출시 스택 오버플로 오류가 발생합니다. 이것이 왜인지 알아내는 데 도움이 될 것입니다.

모든 코드를 추가하지 않았습니다. 질문과 관련이 있습니다.

// CODE CALLING THE MULTIPLICATION 
    Matrix m = new Matrix(Integer.parseInt(size.getText()), 20); 
    Matrix m2 = new Matrix(Integer.parseInt(size.getText()), 20); 
    Matrix m3 = m.strassenMult(m2); 

    // THE MATRIX CLASS 
    public class Matrix { 

    private int[][] vals; 
    private int size; 
    private boolean stable = false; 
    private long time; 

    // Constructor for known data 
    public Matrix(int[][] vals) { 
    this.vals = vals; 
    this.size = vals.length; 
    stable = true; 
    } 

    // Constructor for matrix with random size, if bounds = 0 it is empty 
    public Matrix(int size, int bounds) { 
    this.size = size; 
    vals = new int[size][size]; 
    stable = true; 
    if (bounds != 0) { 
     Random rand = new Random(System.currentTimeMillis()); 
     for (int i = 0; i < size; i++) { 
      for (int j = 0; j < size; j++) { 
       int x = rand.nextInt(); 
       x = x % bounds; 
       vals[j][i] = x; 
      } 
     } 
    } 
    } 

    private Matrix add(Matrix m2) { 
    ///////////////////////// THE ERROR IS ON THE BELOW LINE 
    int n = m2.getSize(); 
    int[][] newVals = new int[n][n]; 
    for (int i = 0; i < n; i++) { 
     for (int j = 0; j < n; j++) { 
      newVals[i][j] = vals[i][j] + m2.getVal(i, j); 
     } 
    } 
    Matrix sum = new Matrix(newVals); 
    return sum; 
    } 
    private Matrix subtract(Matrix m2) { 
    int n = m2.getSize(); 
    int[][] newVals = new int[n][n]; 
    for (int i = 0; i < n; i++) { 
     for (int j = 0; j < n; j++) { 
      newVals[i][j] = vals[i][j] - m2.getVal(i, j); 
     } 
    } 
    return new Matrix(newVals); 
    } 


    // The strassen multiplication algorithm 
    public Matrix strassenMult(Matrix m2) { 
    int n = m2.getSize(); 
    int newSize = n/2; 
    // initialize new sub-matricies 
    Matrix a11 = new Matrix(newSize, 0); 
    Matrix a12 = new Matrix(newSize, 0); 
    Matrix a21 = new Matrix(newSize, 0); 
    Matrix a22 = new Matrix(newSize, 0); 
    Matrix b11 = new Matrix(newSize, 0); 
    Matrix b12 = new Matrix(newSize, 0); 
    Matrix b21 = new Matrix(newSize, 0); 
    Matrix b22 = new Matrix(newSize, 0); 
    Matrix aResult = new Matrix(newSize, 0); 
    Matrix bResult = new Matrix(newSize, 0); 

    // divide existing matries into the sub-matricies 
    for (int i = 0; i < newSize; i++) { 
     for (int j = 0; j < newSize; j++) { 
      a11.set(i, j, vals[i][j]); // top left 
      a12.set(i, j, vals[i][j + newSize]); // top right 
      a21.set(i, j, vals[i + newSize][j]); // bottom left 
      a22.set(i, j, vals[i + newSize][j + newSize]); // bottom right 

      b11.set(i, j, m2.getVal(i, j)); // top left 
      b12.set(i, j,m2.getVal(i, j + newSize)); // top right 
      b21.set(i, j, m2.getVal(i + newSize, j)); // bottom left 
      b22.set(i, j, m2.getVal(i + newSize, j + newSize)); // bottom right 
     } 
    } 
    // Calculating p1 to p7: 
    ////////////////////////////////// ERROR IS CALLED BY THIS METHOD 
    aResult = a11.add(a22); 
    bResult = b11.add(b22); 
    Matrix p1 = aResult.strassenMult(bResult); 
    // p1 = (a11+a22) * (b11+b22) 

    aResult = a21.add(a22); // a21 + a22 
    Matrix p2 = aResult.strassenMult(b11); // p2 = (a21+a22) * (b11) 

    bResult = b12.subtract(b22); // b12 - b22 
    Matrix p3 = a11.strassenMult(bResult); 
    // p3 = (a11) * (b12 - b22) 

    bResult = b21.subtract(b11); // b21 - b11 
    Matrix p4 = a22.strassenMult(bResult); 
    // p4 = (a22) * (b21 - b11) 

    aResult = a11.add(a12); // a11 + a12 
    Matrix p5 = aResult.strassenMult(b22); 
    // p5 = (a11+a12) * (b22) 

    aResult = a21.subtract(a11); // a21 - a11 
    bResult = b11.add(b12); // b11 + b12 
    Matrix p6 = aResult.strassenMult(bResult); 
    // p6 = (a21-a11) * (b11+b12) 

    aResult = a12.subtract(a22); // a12 - a22 
    bResult = b21.add(b22); // b21 + b22 
    Matrix p7 = aResult.strassenMult(bResult); 
    // p7 = (a12-a22) * (b21+b22) 

    // calculating c21, c21, c11 e c22: 
    Matrix c12 = p3.add(p5); // c12 = p3 + p5 
    Matrix c21 = p2.add(p4); // c21 = p2 + p4 

    aResult = p1.add(p4); // p1 + p4 
    bResult = aResult.add(p7); // p1 + p4 + p7 
    Matrix c11 = bResult.subtract(p5); 
    // c11 = p1 + p4 - p5 + p7 

    aResult = p1.add(p3); // p1 + p3 
    bResult = aResult.add(p6); // p1 + p3 + p6 
    Matrix c22 = bResult.subtract(p2); 
    // c22 = p1 + p3 - p2 + p6 

    // Grouping the results obtained in a single matrix: 
    Matrix result = new Matrix(n, 0); 
    for (int i = 0; i < newSize; i++) { 
     for (int j = 0; j < newSize; j++) { 
      result.set(i, j, c11.getVal(i, j)); 
      result.set(i, j + newSize, c12.getVal(i, j)); 
      result.set(i + newSize, j, c21.getVal(i, j)); 
      result.set(i + newSize, j + newSize, c22.getVal(i, j)); 
     } 
    } 
    return result; 
    } 

    public int getSize() { 
    return size; 
    } 

Answer 1

Strassen 곱셈 함수에 기본 사례가 없습니다. 어느 시점에서 재귀를 멈추고 다른 행렬 곱셈 알고리즘을 호출해야합니다.