The parameters optional argument of the Explore command allows you to specify which of the unknown names in an expression of plot are the parameters to be explore via sliders. In addition, the initialvalues option allows you to specify the parameter values to be used in the first evaluation.

Compare the following two examples:

In the first example, a pop-up dialog window will appear, suggesting end points for parameters A and B. Click on the Explore button to accept the suggested values.

The second example allows you to bypass the pop-up dialog altogether, by programmatically specifying the parameters' ranges and initial values.

Expressions or function calls which evaluate to other mathematical expressions, following substitution of parameter values, can also be explored.

The component displaying the resulting expressions is a Math Expression Component (or MathContainer).

Tip: Properties such as the autofit, border display, and dimensions of the MathContainer can be altered using the right-click context menu on that component.

With exploration of mathematical expressions it can be useful to see the unevaluated expression alongside each result.The following examples demonstrate several ways in which the result may or may not be displayed as an equation, including as an identity involving the unevaluated expression.

By default the result displays as an equation, with the unevaluated expression echoed as the left-hand-side.

Display of that left hand side can be optionally suppressed.

Since an equation can also be explored, a customized identity could be shown instead. In this next example the left hand side of the input expression is within unevaluation quotes, so that the right hand side summation is computed symbolically while the left hand side is not.

Yet another variation on the above is to use the inert operator Sum rather than the active sum. Note the lighter shade of the pretty-printed summation symbol.

One powerful way to use the Explore command is to pass it an unevaluated function call to a previously defined procedure.

The key here is that the procedure must consistently return the kind of object to be explored, whether that be a plot, an expression, or an image.

At first glance the next example may appear trivial, but the technique is used in several of the more advanced application examples that come later in this worksheet.

The following example illustrates the use of data which has previously been assigned to a name earlier in the session.

Interactive plots produced by the PlotBuilder command make use of new Explore functionality.

Issuing the following command will bring up the Plot Builder options in the Context Panel.

Select Exploration from the Plot Builder options, and then click Build Exploration.

The result is an exploration comprised of Embedded Components inserted into the current worksheet.  The Edit button beside the interactive plot will get you back to the Plot Builder.

Context-sensitive menus

Both Explore and Plot Builder can be accessed in a purely clickable manner, via the context-sensitive menus. Context-sensitive menus are used to apply operations to an expression using only a point-and click method. The menus are available for both 2-D Math input or output.   Execute the command below, then in the Context Panel for the output expression, you can see options for both Explore and Plot Builder. $$ >  exp(x)-a*x^3; ${\ⅇ}^x-a{x}^3$ (1.5.1.1) $$

The Explore command allows you to create an exploratory interface which can play frames as the instances of various parameter values. The frames are produced on-demand and kept only as they are needed. This contrasts with the animations produced by the animate plotting command, which must generate all frames in advance and retain them together. The frame on-demand approach to playing an exploration is discussed further on in this worksheet, but in this section we can see how the older style of animation is supported within an exploration interface.

After executing the Explore command below, select the plot with the pointer and run the animation using the top menu. By default, the embedded component will show the animation in continuous loop mode. While the animation is playing you can move the slider and see a changing instance of the animation.

Note that the animations are created on-the-fly for each new slider value.

The controls for parameters can be placed either to the left, bottom, or right of the component displaying results. All parameter controls can be placed via a single optional argument to the Explore command, as a customized default.

Parameter controls can also be specified individually as an override of any default.

Parameters whose values are specified as a range can have any of several types of variable controller.

The variable controller are: slider, dial, volumegauge, meter, and rotarygauge.

The size of the plotting component can be optionally specified. By default, its size is determined by the size of the initial plot.

Parameters whose values are specified as lists are incorporated as Combo Box controls.

The display of the generated frames at each set of parameter values can be animated. Each parameter control can have its own check box which determines whether it will play with the animation. These check boxes can be unselected while the animation is playing.

Note that any parameters whose animation check box is unselected during play can still be interactively controlled.

The animation check boxes can be specified as a single new default option, and this in turn can be overridden on any parameter's individual specification.  The animation check boxes can be specified as present and initially selected, present and initially unselected, or absent altogether.

By default, any combo box control of a discrete valued parameter does not get an animation check box unless this is supplied in the parameter's individual specification.

Loop animation

The loop option allows for looped play of the animated sequence.   The loop control check box can be omitted altogether (default), initially selected, or initially unselected. >  Explore( plot(abs((c-2)*(c+2))*sin(a*x),x=-6..6,view=-4..4,color=r,style=s),          parameters=[ [r=[red,blue,green],label=color,animate=true],                       [s=[line,point,line],label=style,animate=false],                       c=-2.0..2,                       [a=1..3.0]                      ],          size=[400,246],          animate,          loop,          placement=left        ); redbluegreen linepointline $\mathbf{c}$ $\mathbf{a}$   $$

Suppose that you have an Initial Value Problem (IVP) with unassigned symbolic parameters. The interactive functionality of dsolve,numeric provides an efficient mechanism for numerically solving the solution at multiple values of the parameters. You can use the Explore command to interact with such a solution space.

You can now produce a plot of the solution at parameter values alpha=0.1 and beta=0.2.

And you can also explore the family of such plots, as the parameter values change. This is accomplished by calling Explore on a function call.

Procedures which return images can be explored interactively.

	Basic example: float[8] Array
	Arrays which are supported by the ImageTools package can be interpreted as images.   The following is a basic example involving a function call which evaluates to a 2-dimensional datatype=float[8] Array which is interpreted as a grayscale image. >  Explore( Array(1..100,1..100,(i,j)->evalf(sin(p/10*(i+j))),datatype=float[8]),          parameters=[p=2.0..4.0], size = [200, 200] ); $\mathbf{p}$

	Procedures returning an image
	A function call to a command or procedure which returns an image can also be explored. >  img := ImageTools:-Read(cat(kernelopts(datadir),"/images/excavator.jpg")): >  Explore( ImageTools:-Threshold(img, threshold),          parameters=[threshold=0.2..0.8], placement=right, size = [320, 210] ); $\mathbf{threshold}$

	Animation
	Exploration of images can also be animated. >  with(Fractals:-EscapeTime): >  Explore( Mandelbrot(300, -1.78+(-1-1.5*I)/exp(zoom), -1.78+(2.2+1.5*I)/exp(zoom),                     iterationlimit=a, output=layer1)          , parameters=[ a=50..300, zoom=0.0..8.0 ]          , animate          , placement=left ); $\mathbf{a}$ $\mathbf{zoom}$

Pairs of range controls (e.g. sliders) can be coupled as interactive marker controls on 2D plots.  Each marker is displayed as a cross in the plot, which may be dragged interactively using the mouse pointer.

By default the sliding controls associated with marker parameters are hidden. These controls can be collectively made to display with the showmarkercontrols option, or individually made to display or not with the optional shown keyword in the individual parameter's specification.

DEplot and initial conditions

>  deS := diff(x(t),t)=-0.5*x(t)*y(t); $\mathrm{deS}≔\frac{\ⅆ}{\ⅆt}x\left(t\right)\=-0.5x\left(t\right)y\left(t\right)$ (2.4.1.1) >  deI := diff(y(t),t)=+0.5*x(t)*y(t)-0.15*y(t); $\mathrm{deI}≔\frac{\ⅆ}{\ⅆt}y\left(t\right)\=0.5x\left(t\right)y\left(t\right)-0.15y\left(t\right)$ (2.4.1.2) >  Explore( DEtools[DEplot]( [deS,deI], [x(t),y(t)],                           t=0..40, x=0..1, y=0..0.6,                           [[x(0)=x0,y(0)=y0]], arrows=medium),          parameters=[ [x0=0.3..0.99], [y0=0.1..0.5, shown=false] ],          showmarkercontrols,          markers=[[x0,y0]],          placement=left, animate ); $\mathbf{x0}$     $$

The following application uses example code from the SignalProcessing package and, after enclosure in a simple procedure, produces an interactive application that dynamically illustrates the effects of the filter parameter value on the resulting modified signal.

First we generate a known signal. Then we construct a reusable container Array C in order to improve performance of the exploration process by leveraging the in-place computational semantics of the InfiniteImpulseResponseFilter command.

The next example uses a self-initializing module to efficiently do in-place updates of an image Array as the parameters change.

A single call to F will produce a color image as output, which can be visualized by embedding in the current worksheet.

An interactive application can now be easily constructed.

The cobweb plot of the logistic map illustrated by iterated application of the formula r*x*(1-x) exhibits emergent chaotic behavior as the parameter r increases from a value of 3 towards the value of 4.

The procedure Cobweb defined below will produce a so-called cobweb plot by iterating the process of applying the formula to obtain a y value and taking that computed y value as the next x value in the sequence. This sequence of operations produces (x,y) points which lie alternately on the formula's curve and the x=y line.

For some values of r convergence to a point or a cycle occurs. As the value r increases towards 4 the chaotic behavior emerges. A dynamic exploratory interface with varying parameters r and x0 are much more impressive mechanisms for illustrating the emergent behavior than are static cobweb plots with fixed values of r and original point x0.

The following application performs edge detection by convolving the data with a pair of 3x3 kernels (Sobel operator), followed by optional thresholding.

The discrete valued action parameter is used to allow the choice between convolution (only) or thresholding (only) after the initial convolution. When the action ComboBox is selected as threshold then the three Sliders control the thresholding effect on the displayed image. When the ComboBox is selected as convolve then the image reverts to the result of the original convolution and the three Sliders have no effect.