Segmentation Fault（Core Dumped）-矢量图

Question

I am working at algorithm which can calculate length of curve using elementary segments. So if I have vector of x and y coordinates of curve I need to calculate number of this elementary segments. I've invented my own recursive algorithm for that. There is a code:

#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;
}

In main as you can see, I'm setting x,y coordinates for parabolic function. When Eps is big for example Eps = 0.001 everything works. If I set smaller value like Eps = 0.0001 then I get error like in topic and program stop running. I've completely no idea why.

I can add any new informations which you need (about my compiler, IDE, OS etc).

Rafal

Answer 1

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

         if(i < vectorX.size())

That will exceed the bounds of the vector by 1. Maybe you needed if(i < vectorX.size()-1) or (noting the comment by AndyG) maybe you needed the i++ to be below those two uses of i .

Answer 2

You are probably running out of stack space due to the recursion.

A quick hack around this is to raise the stack size using ulimit in the shell, eg

(ulimit -s unlimited; ./my_program)

The real fix however is to remove the recursion. algorithmKolmogorow looks like it does tail-recursion only, which can always be converted to a loop:

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;
           }

    }

}

There also fixes the problem of accessing the vectors one element passed their bounds.

There are still some problems:

• N should be initialized
• algorithmKolmogorow can only be used once per program invocation. Remove the static from N and i to fix that.

Answer 3

Your value for Eps is too small. It causes the algorithm to progress too slowly, which means you run out of stack space before the calculation can finish. I increased Eps to 0.005 and the code runs fine. Not sure if it produces the right answer though; you'll have to check.

Also, you need to change these lines:

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

To this:

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

Otherwise you access past the last vector element on the last iteration. You may also want to do a tolerance study on Eps to see how small it has to be to get an accurate calculation.