Manipulate to determine $\delta$ given $\epsilon$ in continuity question

Question

This is a continuation of a question I posed at: Examining the function $f(x,y)=xy(x^2-y^2)/(x^2+y^2)$.

The quest is to analyze the partial derivative $$ f_x(x,y)=\begin{cases} \dfrac{y(x^4+4x^2y^2-y^4)}{(x^2+y^2)^2},&(x,y)\ne(0,0)\\ 0,& (x,y)=(0,0) \end{cases}$$ to see if it is continuous at (0,0). I've tried a little manipulate activity:

DynamicModule[{f, max, min},
 fx[x_, y_] := 
  Piecewise[{{(y (x^4 + 4 x^2 y^2 - y^4))/(x^2 + y^2)^2, 
     x != 0 && y != 0}}, 0];
 Manipulate[
  max = NMaximize[{fx[x, y], Sqrt[x^2 + y^2] < \[Delta]}, {x, y}][[1]];
  min = NMinimize[{fx[x, y], Sqrt[x^2 + y^2] < \[Delta]}, {x, y}][[1]];
  Column[{
    Row[{"Min = " <> ToString[min], ", Max = " <> ToString[max]}],
    Plot3D[{fx[x, y], 
      0}, {x, -\[Delta], \[Delta]}, {y, -\[Delta], \[Delta]},
     PlotStyle -> {Directive[Red], 
       Directive[LightBlue, Opacity[.8]]},
     RegionFunction -> Function[{x, y, z}, Sqrt[x^2 + y^2] < \[Delta]],
     PlotRange -> All,
     BoxRatios -> Automatic,
     PerformanceGoal -> "Quality"]
    }],
  {{\[Epsilon], .1}, .001, .15, Appearance -> "Labeled"},
  {{\[Delta], .5}, .01, 1, Appearance -> "Labeled"}
  ]
 ]

There are a couple of problems. First, it's very slow as I am calculating min, max, and redrawing the image each time the slide moves. Second, when the delta slider gets tiny, things go bad.

Any thoughts?

Example of something that happens:

NMinimize[{fx[x, y], Sqrt[x^2 + y^2] < .1}, {x, y}]

During evaluation of In[54]:= NMinimize::incst: NMinimize was unable to generate any initial points satisfying the inequality constraints {-0.1+Sqrt[x^2+y^2]<=0}. The initial region specified may not contain any feasible points. Changing the initial region or specifying explicit initial points may provide a better solution. >>

Out[54]= {-0.1, {x -> -7.45003*10^-9, y -> 0.1}}

Answer 1

In the current version of the question, the second parameter $\epsilon$ isn't needed. If you can do without it, I would suggest pre-computing the list of relevant $\delta$ values and making a ListAnimate to speed up the rendering. But I will assume that you can't go that route, maybe because you'll add some dependence on $\epsilon$ later.

Then the numerical problems can be avoided by throwing out NMinimize and NMaximize altogether:

DynamicModule[{f, max, min, g}, 
 fx[x_, y_] := 
  Piecewise[{{(y (x^4 + 4 x^2 y^2 - y^4))/(x^2 + y^2)^2, 
     x != 0 && y != 0}}, 0];
 Manipulate[
  g = Plot3D[{fx[x, y], 
     0}, {x, -δ, δ}, {y, -δ, δ}, 
    PlotStyle -> {Directive[Red], Directive[LightBlue, Opacity[.8]]}, 
    RegionFunction -> Function[{x, y, z}, Sqrt[x^2 + y^2] < δ],
     PlotRange -> All, BoxRatios -> Automatic, 
    PerformanceGoal -> "Quality"];
  {min, max} = 
   First@Cases[g, GraphicsComplex[pts_, __] :> MinMax[pts[[All,3]]]];
  Column[{Row[{"Min = " <> ToString[min], 
      ", Max = " <> ToString[max]}], 
    g}], {{ϵ, .1}, .001, .15, 
   Appearance -> "Labeled"}, {{δ, .5}, .01, 1, 
   Appearance -> "Labeled"}]]

Here, I used the fact that in order to plot the function, Mathematica already did the calculation of the minimum and maximum function value for you. In particular with the setting PerformanceGoal -> "Quality", this should be sufficiently accurate for the purposes of a Manipulate to display as the numerical minima and maxima. I extract these values using MinMax in a Cases statement applied to the plot which is generated beforehand and called g.

More explanations:

Within Cases, I make use of the fact that the 3D plot is by default given as a GraphicsComplex, in which all the 3D points are listed as one big list, followed by instructions of what to do with those points (i.e., how to assemble them into polygons etc.) The advantage of GraphicsComplex is that it allows references to 3D points by a single index (giving its position in the point list) - and another advantage is that you don't have to look for the plot coordinates anywhere else, only in the first argument of GraphicsComplex, which is what I do using the pattern GraphicsComplex[pts_,__]. Naming this list pts, I can then subject it to transformations. Cases outputs only the result of those transformations, done with :>. What I want is the largest and smallest z component among all those points. This is what MinMax does. To look only at the z components of the list, I use the part specification [[All,3]].