“线程中的异常”；“主要”；带有expm的java.lang.StackOverflower错误

我正在尝试使用附加网站上定义的jblas库计算正方形矩阵的矩阵指数 但是我不知道怎么做，我根据网站写了下面的代码，我应该把它定义为一种方法，但我不知道我怎么做，如果有任何帮助，我将不胜感激

package org.jblas;

import java.util.Random;

public class MatrixFunctions {

public static  Double expm(Double A[][]) {
    return expm(A);
}
public static void main(String[] args){
    Double Q[][]=new Double[3][3];
    Random random=new Random();
    for (int i=0;i<3;i++){
        for (int j=0;j<3;j++){
            Q[i][j]=random.nextDouble();
        }
    }
    Double B;
    B=expm(Q);
    System.out.println(B[1][1]);
}
}

这只是一遍又一遍地调用自己，直到堆栈溢出

这只是一遍又一遍地调用自己，直到堆栈溢出

这只是一遍又一遍地调用自己，直到堆栈溢出

---

这只是一遍又一遍地调用自己，直到堆栈溢出。

您有一个无限递归循环

public static  Double expm(Double A[][]) {
    return expm(A);
}

每次只需重新调用递归函数，而无需更改参数

每次进行新函数调用时，都会将额外的数据推送到调用堆栈上，最终，系统无法处理这些数据，并引发堆栈溢出异常

---

如果希望异常消失，则必须更改

expm

函数以最终停止调用自身。

您有一个无限递归循环

public static  Double expm(Double A[][]) {
    return expm(A);
}

每次只需重新调用递归函数，而无需更改参数

每次进行新函数调用时，都会将额外的数据推送到调用堆栈上，最终，系统无法处理这些数据，并引发堆栈溢出异常

---

如果希望异常消失，则必须更改

expm

函数以最终停止调用自身。

您有一个无限递归循环

public static  Double expm(Double A[][]) {
    return expm(A);
}

每次只需重新调用递归函数，而无需更改参数

每次进行新函数调用时，都会将额外的数据推送到调用堆栈上，最终，系统无法处理这些数据，并引发堆栈溢出异常

---

如果希望异常消失，则必须更改

expm

函数以最终停止调用自身。

您有一个无限递归循环

public static  Double expm(Double A[][]) {
    return expm(A);
}

每次只需重新调用递归函数，而无需更改参数

每次进行新函数调用时，都会将额外的数据推送到调用堆栈上，最终，系统无法处理这些数据，并引发堆栈溢出异常

---

如果希望异常消失，则必须更改

expm

函数以最终停止调用自身。

当调用太多函数时，通常会发生堆栈溢出异常，JVM无法跟踪所有状态。99%的情况下，这种情况发生在函数在无限循环中调用自身时。你的情况就是这样：

public static  Double expm(Double A[][]) {
    return expm(A);
}

这个方法一遍又一遍地调用自己。没有什么能阻止它。我真的不确定这个函数应该做什么，所以我不能为您建议一个具体的解决方案，但一般来说，要解决这个问题，您有一个if语句，它将最终停止无限循环

为了帮助您将问题形象化，我将展示您在做什么，就好像您没有使用递归一样：

public static  Double expm1(Double A[][]) {
    return expm2(A);
}

public static  Double expm2(Double A[][]) {
    return expm3(A);
}

public static  Double expm3(Double A[][]) {
    return expm4(A);
}

//and it keeps going forever

---

正如你所看到的，这永远不会结束。最终，您将耗尽内存，并将其报告为

StackOverflowerError

当您调用太多函数时，通常会发生stackoverflow异常，JVM无法跟踪所有状态。99%的情况下，这种情况发生在函数在无限循环中调用自身时。你的情况就是这样：

public static  Double expm(Double A[][]) {
    return expm(A);
}

这个方法一遍又一遍地调用自己。没有什么能阻止它。我真的不确定这个函数应该做什么，所以我不能为您建议一个具体的解决方案，但一般来说，要解决这个问题，您有一个if语句，它将最终停止无限循环

为了帮助您将问题形象化，我将展示您在做什么，就好像您没有使用递归一样：

public static  Double expm1(Double A[][]) {
    return expm2(A);
}

public static  Double expm2(Double A[][]) {
    return expm3(A);
}

public static  Double expm3(Double A[][]) {
    return expm4(A);
}

//and it keeps going forever

---

正如你所看到的，这永远不会结束。最终，您将耗尽内存，并将其报告为

StackOverflowerError

当您调用太多函数时，通常会发生stackoverflow异常，JVM无法跟踪所有状态。99%的情况下，这种情况发生在函数在无限循环中调用自身时。你的情况就是这样：

public static  Double expm(Double A[][]) {
    return expm(A);
}

这个方法一遍又一遍地调用自己。没有什么能阻止它。我真的不确定这个函数应该做什么，所以我不能为您建议一个具体的解决方案，但一般来说，要解决这个问题，您有一个if语句，它将最终停止无限循环

为了帮助您将问题形象化，我将展示您在做什么，就好像您没有使用递归一样：

public static  Double expm1(Double A[][]) {
    return expm2(A);
}

public static  Double expm2(Double A[][]) {
    return expm3(A);
}

public static  Double expm3(Double A[][]) {
    return expm4(A);
}

//and it keeps going forever

---

正如你所看到的，这永远不会结束。最终，您将耗尽内存，并将其报告为

StackOverflowerError

当您调用太多函数时，通常会发生stackoverflow异常，JVM无法跟踪所有状态。99%的情况下，这种情况发生在函数在无限循环中调用自身时。你的情况就是这样：

public static  Double expm(Double A[][]) {
    return expm(A);
}

这个方法一遍又一遍地调用自己。没有什么能阻止它。我真的不确定这个函数应该做什么，所以我不能为您建议一个具体的解决方案，但一般来说，要解决这个问题，您有一个if语句，它将最终停止无限循环

为了帮助您将问题形象化，我将展示您在做什么，就好像您没有使用递归一样：

public static  Double expm1(Double A[][]) {
    return expm2(A);
}

public static  Double expm2(Double A[][]) {
    return expm3(A);
}

public static  Double expm3(Double A[][]) {
    return expm4(A);
}

//and it keeps going forever

---

正如你所看到的，这永远不会结束。最终，您的内存将耗尽，它将被报告为

堆栈溢出错误
您只需重新调用此函数，直到堆栈内存将满为止

publicstaticdoubleexpm（双A[]{
return expm（A）；//删除修改此行
//因为此行将重新调用您的函数
//东北