Provided by: pdl_2.007-2build1_amd64 bug

NAME

       PDL::Fit::LM -- Levenberg-Marquardt fitting routine for PDL

DESCRIPTION

       This module provides fitting functions for PDL. Currently, only Levenberg-Marquardt
       fitting is implemented. Other procedures should be added as required. For a fairly concise
       overview on fitting see Numerical Recipes, chapter 15 "Modeling of data".

SYNOPSIS

        use PDL::Fit::LM;
        $ym = lmfit $x, $y, $sig, \&expfunc, $a, {Maxiter => 300};

FUNCTIONS

   lmfit
       Levenberg-Marquardt fitting of a user supplied model function

        ($ym,$a,$covar,$iters) =
             lmfit $x, $y, $sig, \&expfunc, $a, {Maxiter => 300, Eps => 1e-3};

       Options:

        Maxiter:  maximum number of iterations before giving up
        Eps:      convergence citerium for fit; success when normalized change
                  in chisquare smaller than Eps

       The user supplied sub routine reference should accept 4 arguments

       •   a vector of independent values $x

       •   a vector of fitting parameters

       •   a vector of dependent variables that will be assigned upon return

       •   a matrix of partial derivatives with respect to the fitting parameters that will be
           assigned upon return

       As an example take this definition of a single exponential with 3 parameters (width,
       amplitude, offset):

        sub expdec {
          my ($x,$par,$ym,$dyda) = @_;
          my ($a,$b,$c) = map {$par->slice("($_)")} (0..2);
          my $arg = $x/$a;
          my $ex = exp($arg);
          $ym .= $b*$ex+$c;
          my (@dy) = map {$dyda->slice(",($_)")} (0..2);
          $dy[0] .= -$b*$ex*$arg/$a;
          $dy[1] .= $ex;
          $dy[2] .= 1;
        }

       Note usage of the ".=" operator for assignment

       In scalar context returns a vector of the fitted dependent variable. In list context
       returns fitted y-values, vector of fitted parameters, an estimate of the covariance matrix
       (as an indicator of goodness of fit) and number of iterations performed.

       An extended example script that uses lmfit is included below.  This nice example was
       provided by John Gehman and should help you to master the initial hurdles. It can also be
       found in the Example/Fit directory.

          use PDL;
          use PDL::Math;
          use PDL::Fit::LM;
          use strict;

          ### fit using pdl's lmfit (Marquardt-Levenberg non-linear least squares fitting)
          ###
          ### `lmfit' Syntax:
          ###
          ### ($ym,$a,$covar,$iters)
          ###  = lmfit $x, $y, $sig, \&fn, $initp, {Maxiter => 300, Eps => 1e-3};
          ###
          ### Explanation of variables
          ###
          ### OUTPUT
          ### $ym =    pdl of fitted values
          ### $a  =    pdl of paramters
          ### $covar = covariance matrix
          ### $iters = number of iterations actually used
          ###
          ### INPUT
          ### $x =      x data
          ### $y =      y data
          ### $sig =    weights for y data (can be set to scalar 1 for equal weighting)
          ### \&fn =    reference to function provided by user (more on this below)
          ### $initp =  initial values for floating parameters
          ###               (needs to be explicitly set prior to use of lmfit)
          ### Maxiter = maximum iterations
          ### Eps =     convergence criterium (maximum normalized change in Chi Sq.)

          ### Example:
          # make up experimental data:
          my $xdata = pdl sequence 5;
          my $ydata = pdl [1.1,1.9,3.05,4,4.9];

          # set initial prameters in a pdl (order in accord with fit function below)
          my $initp = pdl [0,1];

          # Weight all y data equally (else specify different weights in a pdl)
          my $wt = 1;

          # Use lmfit. Fourth input argument is reference to user-defined
          # subroutine ( here \&linefit ) detailed below.
          my ($yf,$pf,$cf,$if) = lmfit $xdata, $ydata, $wt, \&linefit, $initp;

          # Note output
          print "\nXDATA\n$xdata\nY DATA\n$ydata\n\nY DATA FIT\n$yf\n\n";
          print "Slope and Intercept\n$pf\n\nCOVARIANCE MATRIX\n$cf\n\n";
          print "NUMBER ITERATIONS\n$if\n\n";

          # simple example of user defined fit function. Guidelines included on
          # how to write your own function subroutine.
          sub linefit {

                  # leave this line as is
                  my ($x,$par,$ym,$dyda) = @_;

                  # $m and $b are fit parameters, internal to this function
                  # call them whatever make sense to you, but replace (0..1)
                  # with (0..x) where x is equal to your number of fit parameters
                  # minus 1
                  my ($m,$b) = map { $par->slice("($_)") } (0..1);

                  # Write function with dependent variable $ym,
                  # independent variable $x, and fit parameters as specified above.
                  # Use the .= (dot equals) assignment operator to express the equality
                  # (not just a plain equals)
                  $ym .= $m * $x + $b;

                  # Edit only the (0..1) part to (0..x) as above
                  my (@dy) = map {$dyda -> slice(",($_)") } (0..1);

                  # Partial derivative of the function with respect to first
                  # fit parameter ($m in this case). Again, note .= assignment
                  # operator (not just "equals")
                  $dy[0] .= $x;

                  # Partial derivative of the function with respect to next
                  # fit parameter ($b in this case)
                  $dy[1] .= 1;

                  # Add $dy[ ] .= () lines as necessary to supply
                  # partial derivatives for all floating paramters.
          }

   tlmfit
       threaded version of Levenberg-Marquardt fitting routine mfit

        tlmfit $x, $y, float(1)->dummy(0), $na, float(200), float(1e-4),
              $ym=null, $afit=null, \&expdec;

         Signature: tlmfit(x(n);y(n);sig(n);a(m);iter();eps();[o] ym(n);[o] ao(m);
                  OtherPar => subref)

       a threaded version of "lmfit" by using perl threading. Direct threading in "lmfit" seemed
       difficult since we have an if condition in the iteration. In principle that can be worked
       around by using "where" but .... Send a threaded "lmfit" version if you work it out!

       Since we are using perl threading here speed is not really great but it is just convenient
       to have a threaded version for many applications (no explicit for-loops required, etc).
       Suffers from some of the current limitations of perl level threading.

BUGS

       Not known yet.

AUTHOR

       This file copyright (C) 1999, Christian Soeller (c.soeller@auckland.ac.nz).  All rights
       reserved. There is no warranty. You are allowed to redistribute this software
       documentation under certain conditions. For details, see the file COPYING in the PDL
       distribution. If this file is separated from the PDL distribution, the copyright notice
       should be included in the file.