@snowman You wrote:

- You mean that when numpoints is specified, increasing the gridrefine may make the needed numpoints surpass the specified numpoints, as a result, making the figure is rougher? Only when the number of needed numpoints for gridrefine is less than the specified numpoints, can the figure is smooth?

The **numpoints** option just causes confusion, and it shouldn't be used at all. It's functionality is completely superceded by the **grid** option. It causes confusion because it has no relation to the **numpoints **option of the regular **plot **command, nor does it specify the number of computed points, nor even the *initial *number of computed points, in an **implicitplot**. All that it does is set the *initial* grid at **N **x **N**, where **N **is roughly **sqrt(numpoints)**. I emphasize *initial* grid because the **gridrefine** option may increase the grid, but only within the rectangles that have a point of the curve.

- By the way, how do you figure out that For
** gridrefine=3** F(x,y) is calculated at** 515 **points, while **4119** points are used for **gridrefine=6.**

As long as the **resolution** option is not used, the number of computed points can be determined as the number of rows in the point-data matrix of the plot structure. This is **op([1,1,2,1,2], P)** where **P **is the plot structure (the return value of the **implicitplot** command). For example, using your **F**:

**P||(0..6):= plots:-implicitplot~(F, 0..20, 0..10, gridrefine=~ [$0..6])[]:**

map2(op, [1,1,2,1,2], [P||(0..6)]);

[83, 165, 331, 659, 1317, 2631, 5263]

We see that the number of computed points approximately doubles (and that's a very close approximation) for each unit increase in **gridrefine**, which is exactly what I'd expect for a monotonic curve.

- There's a formula that The highest grid level for
**gridrefine=l **will be **[2^l*m,2^l*n] ,** which may not help me to achieve the value of 515, and 4119.

That formula is misleading because only grid rectangles that are already known to contain a point of the curve are subdivided. For a monotonic curve, that's relatively few of the rectangles. But suppose I change your **F** to a nearly space-filling curve:

**F1:= (x,y)-> y-sin(99*x):**

P||(0..6):= plots:-implicitplot~(F1, 0..20, -1..1, gridrefine=~ [$0..6])[]:

map2(op, [1,1,2,1,2], [P||(0..6)]);

[759, 2647, 5935, 49501, 126235, 771225, 1892517]

- The results of "
**showstat(`plots/implicitplot`**) )" are too long, which confuses me a lot.

You won't be able to understand the roughness issue by reading any Maple code. All the Maple code does is compute some number of points (x,y) such that F(x,y) = 0 (and some other trivialities like defining the axes and colors). The end result of the Maple code can be examined by using **op(P)** (note: no index numbers for this **op**) on the returned plot structure **P**. You'll see that it's trivial, (which is not to say that the *computations* done by **implicitplot **are trivial, just that in this case the end result of those computations is), and it's still fairly far from an actual visual plot. To actually display the plot on a physical device, the plot structure is passed to *rendering* code. This code is not written in Maple, and you can't see it. Obviously, the number of points (or pixels) actually plotted on your screen is determined by your screen's resolution (the number of pixels that it has).