Design and implementation of symbolic algorithms for the computation of generalized asymptotes

In this paper we present two algorithms for computing the g-asymptotes or generalized asymptotes , of a plane algebraic curve, C , implicitly or parametrically deﬁned. The asymp-totes of a curve C reﬂect the status of C at points with sufﬁciently large coordinates. It is well known that an asymptote of a curve C is a line such that the distance between C and the line approaches zero as they tend to inﬁnity. However, a curve C may have more general curves than lines describing the status of C at inﬁnity. These curves are known as g-asymptotes or generalized asymptotes . The pseudocodes of these algorithms are presented, as well as the corresponding implementations. For this purpose, we use the algebra software Maple . A comparative analysis of the algorithms is carried out, based on some properties of the input curves and their results to analyze the efﬁciency of the algorithms and to establish comparative criteria. The results presented in this paper are a starting point to generalize this study to surfaces or to curves deﬁned by a non-rational parametrization, as well as to improve the efﬁciency of the algorithms. Additionally, the methods developed can provide a new and different approach in prediction (regression) or classiﬁcation algorithms in the machine learning ﬁeld.


Introduction
In this paper, we present the design and implementation of two Maple packages to deal with some algebraic-geometric constructions with curves that appear in practical applications in Computer Aided Design.
More precisely, we develop an algorithmic solution that allows determining the behavior at infinity of a plane algebraic curve, C , by determining the generalized asymptotes, or gasymptotes, of its branches at points with sufficiently large coordinates, i.e., at the infinity points.The notion of g-asymptote generalizes the classical concept of (line) asymptote and its calculation methods (see [12,16]).
This question is very important in the study of algebraic curves because the asymptotes provide information about the behavior of curves at infinity.For example, determining the asymptotes of a curve is essential to drawing its graph.

The generalized asymptotes
The asymptotes of an infinity branch, B, of a real plane algebraic curve, C , determine the behavior of B at the points with "large coordinates".In analytic geometry, an asymptote of a curve is a line such that the distance between the curve and the line approaches zero as they tend to infinity.In the field of algebraic geometry, an asymptote is a tangent line to the curve at the infinity.
If B can be explicitly defined as y = f (x) or x = g(y) ( f and g are continuous functions on an infinite interval), one may easily decide whether C has an asymptote at B by analyzing the existence of the limits of certain functions when x (or y) tends to ∞.In fact, if these limits can be computed, we may obtain the equation of the asymptote of C at B. However, if this branch B cannot be defined in an explicit way, both the decision and the computation of the asymptote of C at B, require some other tools.
It is well known that an algebraic curve may have more general curves than lines describing the status of a branch at the points with sufficiently large coordinates.In this sense, we say that a curve C is a generalized asymptote (or g-asymptote) of a given curve C if the distance between C and C tends to zero as they tend to infinity, and C cannot be approached by another curve of lower degree (see [1][2][3]).This motivates our interest in efficiently computing these generalized asymptotes.
An example is illustrated in Fig. 1 where it can be seen that a hyperbola is a degree 2 curve with two real asymptotes, which implies that the hyperbola degenerates at infinity, into two lines.The behavior of an ellipse is similar, although in this case, the infinity branches are complex and therefore, the ellipse degenerates at infinity into two complex lines.
However, the asymptotic behavior of a parabola is different, since at infinity the parabola cannot be approached by any straight line, that is, by any curve of smaller degree (see Fig. 2).
As we said previously, the concept of g-asymptote is similar to the classic concept of asymptote [10,12,14].The difference is that a g-asymptote is not necessarily a line, but a higher degree curve of the smallest possible degree that approaches the curve at infinity (a perfect curve).See Section 2 for the formal definition.To clarify this notion, we next consider a plane curve C defined by the irreducible polynomial f (x, y) = −yx − y 2 − x 3 +  Other plane curves of degree 3, such as y − x 3 = 0 or y 2 − x 3 = 0, cannot be approached by any curve of degree less than 3.

Artificial intelligence applications
We strongly believe in the possibility of applying the method presented in this paper to the field of artificial intelligence (AI) and specifically in the area of machine learning (ML).

Future work
We should emphasize that the proposal presented in the paper is opening a promising line of research in a different version of several ML algorithms.First, the methods proposed in the paper can be easily generalized to high dimensional spaces (see [3] and [7]), enabling for separating different classes using generalized asymptotic hyperplanes in classification problems.Besides, a piecewise generalized asymptotic class separation could be an extension of the proposed future work that enables a piecewise hyper dimensional generalized asymptote [8].Piecewise points should be determined based on data distribution and singular areas, determined by data distribution.The concept of g-asymptote in the n-dimensional space could thus be applied to extend the clustering on the whole space.
Finally, Artificial Neural Networks (ANN), Deep Learning methods and other algorithms that iteratively minimize a cost function for updating the weights could be an interesting field of extending the purpose of this paper, considering that weights values tend asymptotically to the optimal values that minimize the error or cost function [9,11].The evolution of the weights updates themselves could be characterized and asymptotically projected.The study of the behavior when iterations grow, and the algebraic outcome of an asymptotic weight convergence function could bring some new trends on weight optimization or interpretability of the trained networks.

Structure of the paper
In order to develop the algorithms and to describe the packages, we first recall the basic required mathematical background.Thus, Section 2 presents the main notions and explains the intuitive idea of perfect curve and g-asymptote.That is, given a curve C , a curve C is said to be a g-asymptote of C if C is a curve of the smallest possible degree that approaches C at infinity (see [1,2]).
Based on these preliminaries, Section 3 presents the algorithms and pseudocodes which construct the generalized asymptotes from plane algebraic curves given by their implicit and parametric equations, considering the infinity branches that converge to the given curve.These pseudocodes have been illustrated with examples that show the methods developed in this work, as well as the implementation programmed with the algebra system Maple, which has been included in Appendix B.
Section 4 analyzes the performance of the previous algorithms based on the computation of the Puiseux series.For this purpose, we study several cases to observe the system overload, when Algorithms 3.1 or 3.2 are executed.
In Section 5, a comparative analysis of the previous algorithms is carried out.For this purpose, some properties of the input curves are considered as well as their results when constructing the respective g-asymptotes of the input curves.Then, we analyze the efficiency of each algorithm and we establish a comparative criteria regarding the time of use of the CPU from the simplest curve to the curve with the highest complexity.

Generalized asymptotes of algebraic curves
This section starts by introducing the notions of infinity branches, convergent branches and approaching curves, derived from previous research (see [1,2,6,7]).
Let C be an irreducible plane algebraic curve defined in the affine space by an irreducible polynomial f (x, y) ∈ R[x, y].Taking into account the practical implications of the problem considered in this paper, the curve is assumed to be real and therefore, the implicit polynomial is defined over R. Let C * be its corresponding projective curve defined by the homogeneous polynomial with d := deg(C ), and f i (x, y) the homogeneous form of degree i, for i = 0, . . ., d.Let (1 : m : 0), m ∈ C be the infinity points of C * (if (0 : 1 : 0) is an infinity point of the input curve, a linear change of coordinates must be applied).
Under these conditions and in order to get the infinity branches of C , we consider the curve defined by the polynomial g(y, z) = F(1, y, z), and we compute the series expansion for the solutions of g(y, z) = 0 around z = 0.There exist exactly deg y (g) solutions given by different Puiseux series ϕ i , i = 1 . . .deg y (g).In the following, we denote as where C t is the field of formal Puiseux series, N i ∈ N, i = 1, . .., and 0 < N 1 < N 2 < • • • one of these series.Therefore, g(ϕ(t), t) = 0 in a neighborhood of t = 0 where ϕ(t) converges.
From these Puiseux series, we get the following definition of infinity branch of C (see [2]).

Definition 1 An infinity branch of a plane algebraic curve C , at the infinity point
In the following, we introduce the notions of convergent branches and approaching curves.Intuitively speaking, two infinity branches converge if they get closer as they tend to infinity.This concept allows us to analyze whether two curves approach each other.
Definition 3 Let C be a plane algebraic curve with an infinity branch B. We say that a curve C approaches C at the branch B, if lim z→∞ d((z, r (z)), C ) = 0, where d( p, C ) = min{d( p, q) : q ∈ C }, and d( p, q) denotes the Euclidean distance between the points p and q.
In [2], we show that if C is a plane curve with an infinity branch B, then a plane curve C approaches C into B, if and only if C has an infinity branch B such that B and B are convergent.
Given a plane curve C and an infinity branch B, we have described how C can be approached at B by a second curve C .Let us suppose that deg(C ) < deg(C ).Then, one may say that C degenerates, since it behaves at infinity as a curve of smaller degree.As we said in the introduction, a hyperbola is a curve of degree 2 that has two real asymptotes, which implies that the hyperbola degenerates, at infinity, to two lines (see Fig. 1).However, as we said, the asymptotic behavior of a parabola is different, since it cannot be approached at infinity by any line (see Fig. 2).This motivates the definitions of perfect curve and generalized asymptote (see [1]).

Definition 4 A curve of degree d is a perfect curve if it cannot be approached by any curve of degree less than d.
A curve C that is not perfect can be approached by other curves of smaller degree.If these curves are perfect, we call them g-asymptotes, and we represent it as C .More precisely, we have the following definition.

Definition 5 Let C be a plane algebraic curve with an infinity branch
We emphasize that the notion of g-asymptote is similar to the classical concept of asymptote.The difference is that a g-asymptote is not necessarily a line, but a perfect curve.Actually, it is a generalization, since every line is a perfect curve.Throughout the paper, we sometimes refer to g-asymptote simply as asymptote

Algorithms for computing generalized asymptotes
In this section, we describe two algorithms that construct the parametrizations of the generalized asymptotes of the infinity branches of a curve C ; both are described by the corresponding pseudocode.
First, in Section 3.1, we introduce Algorithm 3.1 which computes the g-asymptotes of a curve given by its implicit equation.In Section 3.2, we present a new algorithm, Algorithm 3.2, which is applied to a parametrically given curve.

Algorithm for curves implicitly defined
Let C be a curve with a branch , the monomials a j z 1−N j /N with j ≥ k + 1 have a negative exponent.
In the following, we write That is, we simplify the exponents such that gcd(n, n 1 , . . ., and N < n k+1 , i.e. the monomials a j z 1−N j /N with j ≥ k + 1 have negative exponents.The monomials with non-negative exponent of r (z) are Applying the change z = t n , we obtain a proper (or birational) parametrization of a curve C where n, n 1 , . . ., n k ∈ N, gcd(n, n 1 , . . ., n k ) = 1, and 0 < n 1 < • • • < n k , which is an asymptote of C (see Lemma 3 and Theorem 2 [1]).
The notion of proper parametrization can be revised in [15] (see Section 4.1 in Chapter 4).We remind that the question of determining a birational (proper) reparametrization of an input non-birational parametrization has been analyzed by several authors and there are effective answers to approach it (see Section 4.2 in [15]).
Algorithm 3.1 computes the parametrizations of the asymptotes of the infinity branches of the curve C which is implicitly defined.In Example 1, we illustrate this algorithm, which has been implemented with the mathematical software Maple (see Appendix B).

Algorithm 1 Computation of asymptotes of an implicit curve
We remark that the routine ProjectiveCurve(C ) determines the projective curve associated to the affine curve C which is defined by the homogenization, F(x, y, z), of the polynomial f (x, y) that defines C .The routine I n f init y Points(F(x, y, 0)) returns the infinity points of the projective curve.The routine PuiseuxSeries(g(y, z), z = 0, y) computes the Puiseux Series of the polynomial g(y, z) around z = 0.

Algorithm for curves parametrically defined
Throughout this paper so far, we have dealt with algebraic plane curves implicitly defined.Now, we present a method to compute infinity branches and g-asymptotes of a plane curve from their parametric representation, without implicitizing (see [3,Sec.5]).This method also involves the computation of Puiseux series and infinity branches (see [4]).
Let C be a plane curve defined by the parametrization where gcd( If C * represents the projective curve associated to C , we have that a parametrization of C * is given by P * (s) = ( p 1 (s) : p 2 (s) : 1) or, equivalently, We assume that we have prepared the input curve C through a suitable linear change of coordinates (if necessary), such that (0 : 1 : 0) is not a point at infinity of C * .
In order to compute the g-asymptotes of C , first we need to determine the infinity branches of C .That is, the sets For this purpose, taking into account Definition 1, we have that around t = 0, where t = z −1 and F is the polynomial defining implicitly C * .Observe that, in this section, we are given the parametrization P * (s) of C * and then, Thus, intuitively speaking, in order to compute the infinity branches of C , and in particular the series ϕ, one needs to rewrite the parametrization P * (s) in the form (1 : ϕ(t) : t) around t = 0.For this purpose, the idea is to look for a value of the parameter s, say (t) ∈ C t , such that P * ( (t)) = (1 : ϕ(t) : t) around t = 0.
Hence, from the above reasoning, we deduce that first, we have to consider the equation and we solve it in the variable s around t = 0. From Puiseux's Theorem, there exist solutions Thus, for each i ∈ {1, . . ., k}, there exists M i ∈ R + such that the points (1 : ϕ i (t) : t) or equivalently, the points (t −1 : t −1 ϕ i (t) : 1), where Finally, we set z = t −1 .Then, we have that the points (z, r i (z)), where r i (z) = zϕ i (z −1 ) are in C for z > M −1 i .Hence, the infinity branches of C are the sets Remark 1 Note that the series i (t) satisfies that p 1 ( i (t)) t = 1, for i ∈ {1, . . ., k}.Then, from equality (6), we have that and Once we have the infinity branches, we can compute a g-asymptote for each of them by simply removing the monomials with negative exponent from r i (z).
The following algorithm computes the infinity branches of a given parametric curve, and it provides a g-asymptote for each of the infinity branch.Similarly, as in Algorithm 3.1, the routine ProjectiveCurve(C ) determines the projective curve associated to the affine curve C which is defined by the homogenization, F(x, y, z), of the polynomial f (x, y) that defines C .The routine I n f init y Points(F(x, y, 0)) returns the infinity points of the projective curve.The routine PuiseuxSeries(g(y, z), z = 0, y) computes the Puiseux Series of the polynomial g(y, z) around z = 0. Furthermore, the routine ProjectiveParametri zation(P(s)) determines the projective curve associated to the curve C which is defined by the parametrization /* Equation 4 */ 2: P 1 , . . .P m ← I n f inity Points(P * (s)) 3: 1 (t), . . ., k (t) ← Puiseux Series ( p 12 (s) − t p 11 (s) = 0, t = 0, s)/* Eq. 5 */ 4: for all 1 (t) of P j do 5: It should be recalled that the above algorithm has been implemented in Maple (see Appendix B).We illustrate it by the following example.
Example 2 Let C be the plane curve defined by We apply Algorithm 3.2 to compute the asymptotes of C .For this purpose, we start computing the Puiseux solutions of the equation p 12 (s) − t p 11 (s) = 0 around t = 0. We get: The asymptotes are the plane curves C 1 , C 2 and C 3 defined by the proper rational parametrizations, P 1 (t), P 2 (t) and P 3 (t) (see Fig. 5).

Symbolic algorithms for the computation of generalized asymptotes
This section discusses the performance of the previous algorithms, which construct the gasymptotes from an irreducible plane algebraic curve.We recall that the first algorithm calculates the g-asymptotes of a curve for its implicit expression, considering the infinity branches that converge to the given curve.The second method deals with the case of parametrically defined curves.Both algorithms are based on the computation of the Puiseux series.
For this purpose, fourteen study cases have been selected as input for the implementation of Algorithms 3.1 and 3.2.The execution has allowed us to observe the time and memory usage information for executing a process, obtaining the system overload, and the computational performance.

Analysis of the computational performance
This subsection analyzes the computational performance of the algorithms defined in the previous section, when the procedures implemented in the Appendix B are executed.Thus, the usage of CPU and memory, as well as the real time that the process remains in the system, are evaluated.
In order to measure the efficiency of the algorithms, one hundred input parametric curves were randomly generated.For this purpose, we use the command randpoly(vars, opts) of Maple to generate random polynomials, p i , q i , i = 1, 2 in vars (in this case in the variable t).These polynomials will be used for defining the rational parametrization P(t) = ( p 1 (t)/q 1 (t), p 2 (t)/q 2 (t)).
We remind that once we have the input parametrization, we consider a change of variables so that the degree of the denominator is equal or greater than the degree of the numerator and (0 : 1 : 0) is not an infinity point.We recall that we can compute the implicit polynomial defining these curves by applying for instance resultants (see [15]).Under these conditions, seven classes were created according to the following properties: 1. Degree of the curve.

Number of monomials.
Subsequently, two curves from each group were randomly chosen, obtaining a set of fourteen curves with different characterizations (see Appendix A).All these curves determine the study cases to analyze the computational performance of the algorithms presented in Section 3, which have been programmed with the algebra system Maple, according to the implementation presented in Appendix B.
Based on all the above considerations, an analysis of the computational performance of each one of the algorithms presented has been carried out.Thus, the hardware overload degree of the machine resources (CPU and memory) has been computed, estimating the time of use of the microprocessor and the amount of memory used for the execution of each one of the procedures defined in Appendix B. In addition, the value of real time invested by the machine has been calculated for both methods presented in Section 3.
To quantify these results, it has been necessary to use the tools provided by CodeTools package of Maple.Thus, it is important to clarify that the command CodeTools:-Usage differentiates between the CPU time and the execution real time of a process.Thus, CPU time is the amount of time used to execute a procedure.On the other hand, the real execution time calculates the period during which the process remains in the system, from the time it is launched until it is finished, that is, the entire amount of time in which it is using the hardware resources of the system: CPU, memory, input/output, and so on.
Note that on mono-processor systems, the total CPU usage time will always be less than the real execution time.However, on multiprocessor systems, threads could be spread across multiple cores or CPUs.In this case, the sum of all the usage times of the multiple cores, or processors, is considered as the total CPU usage time and thus can account for the case that it is greater than the real execution time of the process.
To calculate the precise overload degree, each algorithm under analysis has been iterated one hundred times for each one of the study curves.Consequently, it has been possible to record reliable results on the system requirements, necessary to calculate the asymptotes of a given curve.The comparative criteria are based on the different properties of the input curves, such as the degree and the number of monomials, as well as the following results obtained after each execution: 1. Number of infinity branches.2. Highest degree of the analyzed asymptotes.3. Number of real asymptotes.

Number of complex asymptotes.
It is important to note that Algorithms 3.1 and 3.2 compute the infinity branches of the input curve by Puiseux series expansion, using the command algcurves:-puiseux from the algebra software Maple, with the desired accuracy fixed to ten for the calculation of these Puiseux series expansions.
From a hardware point of view, the processes have been executed by a 2018 Mac Book Pro, with an Intel Core i5 processor, with four cores 2.3 GHz, 16 GiB of 2133 MHz LPDDR3 memory, Intel Iris graphics card Plus 1,536 MiB Graphics 655, and 500 GiB SSD.The computer algebra software Maple 2021.1 has been run on the operating system macOS Monterrey, version 12.3.1.
The following subsections present the analysis of the results obtained after the application of the methods developed for the calculation of the asymptotes of plane algebraic curves, each of them with a different characterization.To facilitate the reading of some expressions, certain results have been represented in floating-point.

Computation of asymptotes of implicit algebraic curves
This subsection presents the results of running Algorithm 3.1 one hundred times, with accuracy equal to ten for the Puiseux series expansion, on the fourteen curves in the Appendix A.
Table 1 shows the properties of the input curves and their asymptotes.The curve with the highest degree and the highest number of monomials is C 3 .One may check that the asymptotes of this curve have degrees 1 and 3, much smaller than the degree of the given input curve, whose value is 17.More precisely, the parametric equations of the convergent asymptotes with the curve C 3 are:  9 α , where m(α) = 0 and m(t) := t 2 + 4 t + 5. We have collected the points whose coordinates depend algebraically on all the conjugate roots of a same irreducible polynomial, m(t) ∈ R[t] (see the notion of conjugate points in [15]).Thus, from P 3,1 , we obtain two rational parametrizations given by: [13]).
• P 3,3 (t) := t 3 , (1/8 − 1/8 √ 3 i) t − 1/24 has complex coefficients, but it is important to highlight that this parametrization defines a real asymptote C 3,3 implicitly defined by the polynomial In order to compute the implicit polynomial, we use the resultant method presented in [15].
The curve C 4 is the only one with the lowest degree and the smaller number of monomials.C 4 has two infinity branches and the highest degree asymptote has degree 2 and the parametrizations are Table 2 shows that the curve C 3 requires the longest execution time and generates the highest overhead in the microprocessor and memory when Algorithm 3.1 is run.
It is important to note that we should analyze the results obtained for the input curves C 12 and C 13 , with degrees 13 and 9, respectively.Algorithm 3.1 has presented the highest performance, and the obtained asymptotes have degree 2.
The curve C 12 has six complex asymptotes and one real linear asymptote.More precisely, the parametrizations defining the asymptotes are Table 4 allows us to analyze the efficiency of each algorithm and establishes comparative criteria regarding the time of use of the CPU from the simplest curve, that is, the one with the lowest degree and the fewest number of monomials, C 4 , to the curve with the highest complexity, C 3 .So, the best result for each algorithm is shown in bold.
Afterward, we illustrate in some figures the behavior of each algorithm from the values obtained in Table 4.The graphics illustrate the time, in milliseconds, and memory, in KiB, needed to execute Algorithm 3.1 (blue) and/or Algorithm 3.2 (pink) considering the input and also the output parameters of the algebraic curves defined implicitly and parametrically.
Figure 6 shows that analyzing the case of Algorithm 3.1, the highest efficiency is observed since it requires the least amount of CPU time.Likewise, it is shown that, for both algorithms, the degree of the curve determines the microprocessor time needed to build the asymptotes.
On the other hand, it is remarkable that although Algorithm 3.2 behaves well with simple curves (see curve C 6 in Table 4), however, CPU usage time increases exponentially as the degree of the input curve increases (see curves C 3 and C 11 in Table 4).
The following graphics represent the behavior of each algorithm depending on the parameter of the input curve (axis x), concerning the CPU usage time expressed in milliseconds or memory capacity given in KiB, respectively (axis y).Note that this is a linear-logarithmic plot, based on 10, in which the trend lines are exponential.
Figure 7 shows the behavior of the algorithms considering the number of monomials (axis x).In this case, we can see that the number of monomials only influences Algorithm 3.1, however, it does not seem to have a significant impact when Algorithm 3.2 is run.In order to explain this point, we consider two aspects.The first one is that a curve parametrically defined always can be expressed implicitly and in this case, the number of monomials defining the implicit expression is, in general, higher.On the other side, the computation of the Puiseux series has more overload when the number of monomials increases (see the implementations of Appendix B, specifically the execution of the command algcurves:-puiseux) and also with the presence of conjugated roots.This point explains Fig. 10, which shows the  machine requirements to construct the asymptotes of the input curves, depending on the number of the real or complex asymptotes (axis x).As we can see, the number of complex asymptotes clearly influences the performance of Algorithm 3.2, because executing the command  algcurves:-puiseux on such input parameters can generate conjugate roots in some cases.
On the other hand, Fig. 8 shows the result for the number of branches (axis x).In this case, it does not seem that the number of the branches determines the time of the microprocessor or memory capacity for Algorithm 3.1, although it does influence the case of Algorithm 3.2.Note that number of branches is the same that the number of Puiseux solutions and also, the overload introduced by the command algcurves:-puiseux is higher for the parametric case.
Figure 9 shows that the system performance depends on the highest asymptotes degree.Both algorithms require more CPU time and memory capacity as the degree increases (remember that trend lines are exponential).
Finally, we can state that Algorithm 3.1 presents the best computational performance, requiring the least amount of hardware resources: CPU time, real execution time, and capacity of memory.Likewise, it has been shown that for both algorithms, the degree of the curve is the parameter that determines the overload and amount of system resources needed to build the asymptotes.It is note worthy, that Algorithm 3.2 has a good behavior with simple curves (see values for the curves C 4 and C 6 in Table 4).However, it is a very "heavy" algorithm when the degree of the input curve increases, in which case the hardware needs to grow up exponentially (see the curves C 3 and C 11 in Table 4).Also, we have observed that the highest overhead occurs in the system when the parameter accuracy is increased (equal to 3 − 5 − 7 − 10), although this improves accuracy, it also increases the overhead introduced by computing the Puiseux series.

2x 2 y
+ x 2 − 2y ∈ R[x, y].The given curve C has degree 3 and two infinity branches.In Fig. 3, it can be seen that these infinity branches are approached by the parabola defined by the polynomial y − 2x 2 + 3/2x + 15/8 and by the line defined by y − x/2 + 1/8.

Fig. 3
Fig. 3 Curve C approached by a parabola and a straight line

Fig. 6
Fig. 6 CPU t (left) versus memory (right) resources needed to run Algorithm 3.1 (blue) and Algorithm 3.2 (pink) depending on the curve degree.

Fig. 7
Fig. 7 CPU t (top) versus memory (bottom) resources needed to run Algorithm 3.1 (blue) and Algorithm 3.2 (pink) depending on the number of monomials.

Fig. 8
Fig. 8 CPU t (left) versus memory (right) resources needed to run Algorithm 3.1 (blue) and Algorithm 3.2 (pink) depending on the number of branches.

Fig. 9
Fig.9 CPU t (left) versus memory (right) resources needed to run Algorithm 3.1 (blue) and Algorithm 3.2 (pink) depending on the highest asymptotes degree.

Fig. 10
Fig. 10 CPU t (top) versus memory (bottom) resources needed to run Algorithm 3.1 (blue) and Algorithm 3.2 (pink) depending on the number of the real or complex asymptotes.

Table 1
Properties of the implicit curves and their asymptotes