    All Packages  Class Hierarchy  This Package  Previous  Next  Index

# Class JSci.maths.wavelet.MatchingPursuit

    java.lang.Object
       |
       +----JSci.maths.wavelet.BasisFunctionLibrary
               |
               +----JSci.maths.wavelet.MatchingPursuit

public class MatchingPursuit
extends BasisFunctionLibrary
implements Cloneable

A Wavelet (and more) matching pursuit class Uses adaptative Morse coding for better performance. The MatchingPursuit is used to obtain a Time-Frequency representation (TF) through a fast algorithm.

##

MatchingPursuit(DiscreteFunction)
  Constructor

##

add(MultiscaleFunction, MultiscaleFunction)
  Add a clone of the given MultiscaleFunctions to the internal arrays of MultiscaleFunctions.
clone()
diagnostic(double)
  Check the validity of the current matching algorithm.
forcedMatch(int)
  Force the system to select the given element as the best match.
getCoefs()
  Recover the matching coefficients.
getRecord()
  all matches are recorded so one can trace them back
getRecordedNorms()
  Trace back how much of the norm was taken out at each match.
match()
  Does the matching 1 time and return the TF representation.
match(int)
  Does the matching j times and return the TF representation.
matchAll(double)
  Repeatly match until it remains less than tol * 100 percent of the original L2 norm; no matter what, at least one match will be done.
setData(DiscreteFunction)
  Allows the user to change the DiscreteFunction (see constructor).

##

MatchingPursuit

     public MatchingPursuit(DiscreteFunction f)

  Constructor

##

add

     public void add(MultiscaleFunction fprimary,
                     MultiscaleFunction fdual)

  Add a clone of the given MultiscaleFunctions to the internal arrays of MultiscaleFunctions.

  Overrides:
    add in class BasisFunctionLibrary

clone

     public Object clone()

  Overrides:
    clone in class BasisFunctionLibrary

getRecord

     public int[] getRecord()

  all matches are recorded so one can trace them back

getRecordedNorms

     public double[] getRecordedNorms()

  Trace back how much of the norm was taken out at each match.

getCoefs

     public double[] getCoefs()

  Recover the matching coefficients.

setData

     public void setData(DiscreteFunction f)

  Allows the user to change the DiscreteFunction (see constructor).

  Overrides:
    setData in class BasisFunctionLibrary

diagnostic

     public void diagnostic(double tol) throws MaximumIterationsExceededException

  Check the validity of the current matching algorithm. Will return an exception if the diagnostic fails. This makes sense: the software should stop if the algorithm isn't safely within the given tolerance.

  Throws: IllegalArgumentException
    if the matching fails
  Throws: MaximumIterationsExceededException
    if it can't match one of the elements of the dictionnary
  Throws: IllegalArgumentException
    if tol is is negative

match

     public double[][] match()

  Does the matching 1 time and return the TF representation. The TF representation may contain negative values and so, taking the absolute value of the result will often be useful.

matchAll

     public double[][] matchAll(double tol) throws MaximumIterationsExceededException

  Repeatly match until it remains less than tol * 100 percent of the original L2 norm; no matter what, at least one match will be done. It will return the TF representaiton. The TF representation may contain negative values and so, taking the absolute value of the result will often be useful.

  Parameters:
    tol - percentile of energy
  Throws: IllegalArgumentException
    if tol is not within the interval [0,1]
  Throws: MaximumIterationsExceededException
    if the number of required match exceeds 5 times the size of the dictionnary (it should be a more than confortable margin unless the problem is ill-posed, change the dictionnary if it doesn't work)

forcedMatch

     public double[][] forcedMatch(int pos)

  Force the system to select the given element as the best match. It will return the TF representaiton. The TF representation may contain negative values and so, taking the absolute value of the result will often be useful.

match

     public double[][] match(int j)

  Does the matching j times and return the TF representation. The TF representation may contain negative values and so, taking the absolute value of the result will often be useful.

  Parameters:
    number - of iterations
  Throws: IllegalArgumentException
    if j is not positive

    All Packages  Class Hierarchy  This Package  Previous  Next  Index