Question

我正在使用能够使用基本段计算曲线长度的算法。因此，如果我有曲线的x和y坐标向量，我需要计算这些基本段的数量。我为此发明了自己的递归算法。有一个代码：

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;
//***********************************************
inline double Pitagoras(double xp, double yp, double xf, double yf)
{
    return sqrt((xp - xf)*(xp - xf) + (yp - yf)*(yp - yf));
}
//***************************************************
inline double calculateX(double xp, double yp, double a, double b, const double eps)
{
   double delta;
   double x1, x2;

     delta = (-2.0 * xp + 2.0 *a*b - 2.0 *a*yp)*(-2.0 * xp + 2.0 *a*b - 2.0 *a*yp)
        - 4.0* (1.0 + a*a)*(xp*xp + yp*yp + b*b - 2.0*b*yp - eps*eps);

     x1 = (-(-2.0 * xp + 2.0 *a*b - 2.0 *a*yp) - sqrt(delta))/(2.0 * (1.0 + a*a));
     x2 = (-(-2.0 * xp + 2.0 *a*b - 2.0 *a*yp) + sqrt(delta))/(2.0 * (1.0 + a*a));

   if(x1 >= xp)
     return x1;
     else
       return x2;
}
//***************************************************
inline double calculateY(double x, double a, double b)
{
  return a*x + b;
}
//***********************************************
unsigned long algorithmKolmogorow(double xp, double yp, double xf,
double yf, const double eps, vector<double> &vectorX, vector<double> &vectorY);
//***********************************************
int main()
{
    vector<double> vctrY; //vector of value of function
    vector<double> vctrX; //vector of x
    double xP,yP,xF,yF; //coordinates of two points on the curve
    const double Eps = 0.0001; //length of elementary line

      for(double x=1.0; x<=5 ;x +=0.001)
        {
          vctrX.push_back(x);
          vctrY.push_back(x*x); //f(x) = x^2
        }

    xP = vctrX[0];
    yP = vctrY[0];
    xF = vctrX[1];
    yF = vctrY[1]; //set beginning value

    cout<<algorithmKolmogorow(xP, yP, xF, yF, Eps, vctrX, vctrY)*Eps;

    return 0;
}
//***************************************************
unsigned long algorithmKolmogorow(double xp, double yp, double xf,
 double yf, const double eps, vector<double> &vectorX, vector<double> &vectorY)
{
    static unsigned long N; //licznik
    static unsigned long i = 1;
    double d;
    double a,b;

      d = Pitagoras(xp, yp, xf, yf);

         if(d >= eps){
            a = (yf - yp)/(xf - xp);
            b = yp - a*xp;
            xp = calculateX(xp, yp, a, b, eps);
            yp = calculateY(xp, a, b);
            N++;
         }

           else{
             i++;
             xf = vectorX[i];
             yf = vectorY[i];
             //cout<<i<<"\t"<<vectorX[i]<<"\t"<<vectorY[i]<<endl;
           }

             if(i < vectorX.size())
              N =  algorithmKolmogorow(xp, yp, xf, yf, eps, vectorX, vectorY);

return N;
}

在主要内容中，您可以看到，我为抛物线函数设置了x，y坐标。当Eps很大时例如Eps = 0.001一切正常。如果我设置较小的值，如Eps = 0.0001然后我得到错误，如主题和程序停止运行。我完全不知道为什么。

我可以添加您需要的任何新信息（关于我的编译器，IDE，操作系统等）。

拉法尔

Answer 1

         i++;
         xf = vectorX[i];
         yf = vectorY[i];
         //cout<<i<<"\t"<<vectorX[i]<<"\t"<<vectorY[i]<<endl;
       }

         if(i < vectorX.size())

这将超过向量的界限1.也许您需要if(i < vectorX.size()-1)或（注意AndyG的评论）可能您需要i++低于i的这两种用法}。

Answer 2

由于递归，您可能会耗尽堆栈空间。

快速解决这个问题是使用shell中的ulimit来提高堆栈大小，例如

(ulimit -s unlimited; ./my_program)

但真正的解决方法是删除递归。 algorithmKolmogorow看起来只是尾递归，它总是可以转换为循环：

unsigned long algorithmKolmogorow(double xp, double yp, double xf,
 double yf, const double eps, vector<double> &vectorX, vector<double> &vectorY)
{
    static unsigned long N; //licznik
    static unsigned long i = 1;
    double d;
    double a,b;

    while(true) {
      d = Pitagoras(xp, yp, xf, yf);

         if(d >= eps){
            a = (yf - yp)/(xf - xp);
            b = yp - a*xp;
            xp = calculateX(xp, yp, a, b, eps);
            yp = calculateY(xp, a, b);
            N++;
         }

           else{
             i++;
             if(i >= vectorX.size())
               return N;
             xf = vectorX[i];
             yf = vectorY[i];
             //cout<<i<<"\t"<<vectorX[i]<<"\t"<<vectorY[i]<<endl;
           }

    }

}

还解决了访问一个元素传递其边界的向量的问题。

仍有一些问题：

N应该初始化
algorithmKolmogorow每个程序调用只能使用一次。从static和N移除i以解决此问题。

Answer 3

Eps的价值太小了。它会导致算法进展太慢，这意味着在计算完成之前就会耗尽堆栈空间。我将Eps增加到0.005，代码运行正常。不确定它是否能产生正确的答案;你必须检查。

此外，您需要更改以下行：

xf = vectorX[i];
yf = vectorY[i];

对此：

xf = vectorX[i-1];
yf = vectorY[i-1];

否则，您访问最后一次迭代的最后一个向量元素。您可能还希望对Eps进行容忍度研究，以了解获得准确计算所需的小小。

分段故障（核心转储） - 向量

3 个答案: