2-microlocal analysis extends the usual regularity analysis based on Hölder exponents by associating to each point in the signal an infinite number of exponents. It is not possible to describe the details in this help (see reference (3)). We will only mention that 2-microlocal analysis defines, at each point t, a "2-microlocal frontier", which is a concave decreasing curve in an abstract plane whose coordinates are denoted (s, s'). The intersection of the frontier with the s-axis is precisely the local Hölder exponent, while, under mild assumptions, the intersection with the second bisector is the pointwise exponent. In addition, 2-microlocal analysis describes completely what happens under integro-differentiation of the signal: the frontier is simply translated along the s-axis. This allows to predict the changes in regularity under various transformations, most notably the Hilbert transform. Classical definitions of 2-microlocal analysis involve either a Littlewood-Paley analysis, or a wavelet analysis. There also exist purely time domain definitions, which however only yield a sub-part of the 2-microlocal frontier. These time domain definitions are advantageous because they allow to design robust estimation procedures. These in turn yield estimators of both the pointwise and local exponents, which are in many cases better than direct methods. Two such methods are currently implemented in Fraclab.
Hit first Refresh so that the name and size boxes get updated. The window parameter will, as usual, define the number of sample points that will be used for estimating the exponents at any given point t : exactly 0.5 window points will be taken into account on each side of t. The step parameter lets you decide the spacing between consecutive points were the exponents will be computed. Thus, choosing step equal to 1 means that you wish to perform the estimation at each point. More precisely, the routine will compute the estimations at the following points, assuming your signal is (t(1), ..., t(n)): The first point to be considered will be t(0.5 window + 1). Then all points of the form t(0.5 window + 1 + step) will be dealt with, until the index (0.5 window + 1 + step) exceeds n - 0.5 window -1. Let us take the example of the default values which are window = step = n. In this case, the computations will be performed only at the middle point 0.5n of your input signal, using the whole signal as a window. In general, you will want to choose a large value for window, i.e. at least 100, and preferably 200. Note however that a large window size implies long computing times (for window = step = n = 256, you should wait about one minute).The actual number of points where the estimation will be performed will then depend on both the step parameter (choosing step not smaller than n implies that only one point will be considered) and the length n of your signal.
You then need to choose what to estimate: The default is frontier. When you hit Compute, you will, if you are patient enough, get three output signals: Gfrd_sig# is a graph structure containing the abscissa and ordinates in the (s, s') plane of the 2 microlocal frontier. This is the signal you may want to visualize. The second output, frd_sig#, is the plain frontier. Finally, lend_sig# is a graph that lets you check the quality of the estimation. Briefly, the method works by locating the abscissa s of the plateau with maximal length in a certain graph. In order for the procedure to be robust, there should be a well defined maximal length plateau in lend_sig#. Since there is a different graph for each value of s', lend_sig# will contain several piecewise constant lines, and the estimation will work well if each of these lines has a well defined maximal length plateau. You may check this by viewing this output (see (7) for more on this algorithm). In general, the frontier frd_sig#, being an estimated one, will not be concave and decreasing as predicted by the theory. The Make the frontier convex part of the menu allows to force this, and thus to obtain more meaningful results. Select frd_sig# in the Variables list, then hit Refresh (in the Make the frontier convex part of the window) so that the name of the input signal becomes frd_sig#. You may then adjust the s' cut-off : this is the ordinate of the first point that will be processed. More precisely, only the part of the estimated frontier whose points have coordinates (s, s') with s' smaller than the chosen cut-off will be considered and convexified. As a consequence, the output obtained on pressing Convexify, called conv_frd_sig#, will be the convex envelope of the sub-part of the frontier with s' < cut-off. The default cut-off of 0 is usually a relevant choice, because the estimation method only guarantees to have meaningful results for the part of the frontier between the s axis and the second bissector s' = -s. Moreover, the two main values we are interested in are the intersection of the frontier with the s axis (local Hölder exponent) and with the second bisector (pointwise exponent).
If you have chosen to estimate a frontier, it generally makes sense to perform the estimation at one or only a few points. Otherwise, the outputs will be quite messy, with different lines crossing in a complicated manner. However, all the computations, including the convexification, work in the same way in the case of multiple frontiers. Of course, the lend_sig# output becomes very difficult to read.
Instead of estimating a frontier, you may estimate the local or pointwise exponent. In that view, click on the default frontier to the right of estimate, and choose either local or pointwise. Fraclab will then estimate the part of the frontier around the s axis and the second bisector, and will extract the values of the local and pointwise exponents for you. The output will then be the graph of the chosen exponent, or, more precisely, a 1D signal giving the estimated exponents at the points where the computations were performed. In these cases, you will in general want to estimate with a step size of 1 on order to get the exponents at each point whose index lies between : 0.5 window + 1 and : n - 0.5 window - 1. For both local or pointwise, the lower part of the window (the Make the frontier convex part) is grayed out. You just need to click the Compute button, and you'll get two outputs : Gloc_sig# and lenlocd_sig# for the local exponent, and Gpt_sig# and lenptd_sig# for the pointwise one. Gloc_sig# and Gpt_sig# contain the estimated Hölder exponents, while lenlocd_sig# and lenptd_sig# are again plots of the plateaus, which allow to check that a meaningful maximal plateau was detected.
For this routine, we have chosen to have two separate sub-menus, one for the estimation at one point and one for the estimation on an interval. This is mainly for interface presentation purpose, as the algorithms are the same.
Hit first Refresh so that the Input Signal gets updated. In the part 2-microlocal frontier estimation, choose the Point to analyze by entering its index in the box facing it. The default is the point right at the middle of your signal. You may then choose the Discretization of the frontier, i.e. the number of values s' at which the corresponding s will be estimated. Be warned that this method can be quite lengthy, and that its time complexity is linear in the number of values of s'. The remaining part of the window deals with the type and presentation of the Results. First, decide if you wish to see an Example of estimation in the Graphs to be plotted part. As in the previous method, the algorithm works by detecting significant straight lines in a certain abstract space. Choosing Yes will let Fraclab display a graph in which you may want to check that a significant linear part is present (this linear part is materialized by a blue line, see reference (8) for details). Then, you need to decide if you want the algorithm to compute the local and pointwise exponents. In the Regularity exponents part, choose Yes or No to the right of Compute the exponents. If you choose No, you will only get the frontier, a signal called Graph_frt_sig#, which will be both saved in the Variables list and displayed on the screen (another signal is sent to the Variables list, frt_sig#, which contains only the s-values in the frontier). Graph_frt_sig# is really a graph structure: Graph_frt_sig#.data1 contains the s-values of the frontier, while Graph_frt_sig#.data2 contains the s'-values). On the display, the frontier appears as a set of small triangles connected by straight segments. In addition the two lines s' = -s and s' = 1 -s are plotted. This is because this estimation procedure is only valid for the part of the frontier between these two lines. In addition, displaying the second bisector helps locating the pointwise Hölder exponent.
If you choose Yes for Compute the exponents, you'll get in addition the estimated values of the Pointwise exponent, as obtained with two slightly different methods, and of the Local exponent, which will appear in the boxes in front of the corresponding labels. Also, these values will be saved in the Variables list, under the names pw1Exp_sig#, pw2Exp_sig#, and locExp_sig# (these are 1x1 matrices). In this sub-menu, only one point is processed, and you get one value for each exponent.
Finally, since some computations are lengthy, you may decide to see the Waitbar on screen by choosing Yes in the lower part of the window.
Basically, this is the same as above, except now you may perform estimation as several consecutive points of your original signal. The only difference are:
When the computations are over, three graphic windows appear on the screen: the two first ones display the pointwise exponents as estimated with two slightly different procedures, and the third one display the local Hölder function. In abscissa, you can check that the exponents were estimated between the Starting point of the analysis and Ending point of the analysis. In addition, four signals have been added to the Variables list: Frt_sig# are the estimated frontiers are each analyzed point. Pw1Exp_sig# and Pw2Exp_sig# are the pointwise Hölder functions, and LocExp_sig# is the estimated local one.
In the first oscillation-based method for estimating 2 microlocal exponents, the # in the lend_sig# output does not increment. Thus you need to be careful and rename this signal if you plan to use it afterwards. Also, the currently highlighted signal in the Variables window is lend_sig# after the computation is completed. Thus you'll find that your newly estimated frontiers are at the bottom of the list as usual, while your selection will be located above them.
In the second oscillation-based method for estimating 2 microlocal exponents, the # in all output signals does not always increment. The same remarks apply. In addition, in the case of estimation at multiple points, only the s-values are saved in the frontiers. This is not very convenient. However, you will generally want to estimate frontiers at single points. Otherwise, use the first method Oscillation based (1) that does not have this drawback.