Cfrgtkky

Consider the following minimal example:

#include <stdlib.h>



#include "CGALExact_predicates_exact_constructions_kernel.h"



typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel;

typedef Kernel::FT NumberType;



int main()

{

    int numberOfIterations = 4000;



    NumberType sum = 0;

    for (int i = 0; i < numberOfIterations; i++)

    {

        sum += 1;

    }



    std::cout << "Sum = " << sum << std::endl;



    getchar();



    return 0;

}

All seems to work fine if the numberOfIterations parameter assumes small values.
However, when it is set to a value greater than some thousands, the program outputs the correct value for sum, but gives a Stack overflow error (parameters: 0x0000000000000001, 0x000000C4D2EF3FF8) when deleting the memory (I suppose).

I read the CGAL documentation on Number Types, but it is not clear to me the reason why this happens. What should I do to perform operations on exact numbers in a correct way?

Here is a more complicated example (as requested in the comments below), strictly related to my original problem:

#include <stdlib.h>



#include <CGAL/number_utils.h>

#include "CGAL/Exact_predicates_exact_constructions_kernel_with_sqrt.h"

#include "CGAL/Polyhedron_3.h"



typedef CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt Kernel;

typedef CGAL::Polyhedron_3<Kernel> Polyhedron_3;

typedef Kernel::FT NumberType;

typedef Kernel::Vector_3 Vector_3;

typedef Kernel::Direction_3 Direction_3;



Direction_3 sampleFunction(std::vector<Vector_3> vectors)

{

    NumberType denominator = 0;

    NumberType numeratorX = 0;

    NumberType numeratorY = 0;

    NumberType numeratorZ = 0;



    for (int vf = 0; vf < vectors.size(); vf++)

    {

        Vector_3 vectorF = vectors.at(vf);



        numeratorX += vectorF.x();

        numeratorY += vectorF.y();

        numeratorZ += vectorF.z();



        for (int vg = 0; vg < vectors.size(); vg++)

        {

            Vector_3 vectorG = vectors.at(vg);



            denominator += CGAL::scalar_product(vectorF, vectorG);

        }

    }

    NumberType lambda = CGAL::sqrt(denominator);



    NumberType x = numeratorX / lambda;

    NumberType y = numeratorY / lambda;

    NumberType z = numeratorZ / lambda;



    Vector_3 result(x, y, z);



    return result.direction();

}



int main()

{

    int numberOfVectors = 100;



    std::vector<Vector_3> vectors;

    srand(0);

    for (int i = 0; i < numberOfVectors; i++)

    {

        Vector_3 newVector(rand() % 100 - 50, rand() % 100 - 50, rand() % 100 - 50);

        newVector /= CGAL::sqrt(newVector.squared_length());

        vectors.push_back(newVector);

    }



    Direction_3 direction = sampleFunction(vectors);



    std::cout << direction.dx() << " " << direction.dy() << " " << direction.dz() << " " << std::endl;



    return 0;

}