# locfit

## PURPOSE

Smoothing noisy data using Local Regression and Likelihood.

## SYNOPSIS

function fit=locfit(varargin)

## DESCRIPTION

     Smoothing noisy data using Local Regression and Likelihood.

     arguments still to add: dc maxit

      Usage: fit = locfit(x,y)   % local regression fit of x and y.
             fit = locfit(x)     % density estimation of x.

      Smoothing with locfit is a two-step procedure. The locfit()
      function evaluates the local regression smooth at a set of points
      (can be specified through an evaluation structure). Then, use
      the predict() function to interpolate this fit to other points.

      Additional arguments to locfit() are specified as 'name',value pairs, e.g.:
      locfit( x, 'alpha',[0.7,1.5] , 'family','rate' , 'ev','grid' , 'mg',100 );

      Data-related inputs:

        x is a vector or matrix of the independent (or predictor) variables.
          Rows of x represent subjects, columns represent variables.
          Generally, local regression would be used with 1-4 independent
          variables. In higher dimensions, the curse-of-dimensionality,
          as well as the difficulty of visualizing higher dimensional
          surfaces, may limit usefulness.

        y is the column vector of the dependent (or response) variable.
          For density families, 'y' is omitted.
     NOTE: x and y are the first two arguments. All other arguments require
            the 'name',value notation.

        'weights' Prior weights for observations (reciprocal of variance, or
               sample size).
        'cens' Censoring indicators for hazard rate or censored regression.
               The coding is '1' (or 'TRUE') for a censored observation, and
               '0' (or 'FALSE') for uncensored observations.
        'base' Baseline parameter estimate. If a baseline is provided,
               the local regression model is fitted as
                            Y_i = b_i + m(x_i) + epsilon_i,
               with Locfit estimating the m(x) term. For regression models,
               this effectively subtracts b_i from Y_i. The advantage of the
               'base' formulation is that it extends to likelihood
               regression models.
        'scale' A scale to apply to each variable. This is especially
               important for multivariate fitting, where variables may be
               measured in non-comparable units. It is also used to specify
               the frequency for variables with the 'a' (angular) style.
         'sty' Character string (length d) of styles for each predictor variable.
               n denotes `normal'; a denotes angular (or periodic); l and r
               denotes one-sided left and right; c is conditionally parametric.

      Smoothing Parameters and Bandwidths:
      The bandwidth (or more accurately, half-width) of the smoothing window
      controls the amount of smoothing. Locfit allows specification of constant
      (fixed), nearest neighbor, certain locally adaptive variable bandwidths,
      and combinations of these. Also related to the smoothing parameter
      are the local polynmial degree and weight function.

        'nn' 'Nearest neighbor' smoothing parameter. Specifying 'nn',0.5
             means that the width of each smoothing neighborhood is chosen
             to cover 50% of the data.

         'h' A constant (or fixed) bandwidth parameter. For example, 'h',2
             means that the smoothing windows have constant half-width
             (or radius) 2. Note that h is applied after scaling.

       'pen' penalty parameter for adaptive smoothing. Needs to be used
             with care.

      'alpha' The old way of specifying smoothing parameters, as used in
             my book. alpha is equivalent to the vector [nn,h,pen].
             If multiple componenents are non-zero, the largest corresponding
             bandwidth is used. The default (if none of alpha,nn,h,pen
             are provided) is [0.7 0 0].

       'deg' Degree of local polynomial. Default: 2 (local quadratic).
             Degrees 0 to 3 are supported by almost all parts of the
             Locfit code. Higher degrees may work in some cases.

      'kern' Weight function, default = 'tcub'. Other choices are
             'rect', 'trwt', 'tria', 'epan', 'bisq' and 'gauss'.
             Choices may be restricted when derivatives are
             required; e.g. for confidence bands and some bandwidth
             selectors.

        'kt' Kernel type, 'sph' (default); 'prod'. In multivariate
             problems, 'prod' uses a simplified product model which
             speeds up computations.

      'acri' Criterion for adaptive bandwidth selection.

      Derivative Estimation.
      Generally I recommend caution when using derivative estimation
      (and especially higher order derivative estimation) -- can you
      really estimate derivatives from noisy data? Any derivative
      estimate is inherently more dependent on an assumed smoothness
      (expressed through the bandwidth) than the data. Warnings aside...

      'deriv' Derivative estimation. 'deriv',1 specifies the first derivative
             (or more correctly, an estimate of the local slope is returned.
             'deriv',[1 1] specifies the second derivative. For bivariate fits
             'deriv',2 specifies the first partial derivative wrt x2.
             'deriv',[1 2] is mixed second-order derivative.

      Fitting family.
      'family' is used to specify the local likelihood family.
             Regression-type families are 'gaussian', 'binomial',
               'poisson', 'gamma' and 'geom'. If the family is preceded
               by a q (e.g. 'qgauss', or 'qpois') then quasi-likelihood is
               used; in particular, a dispersion estimate is computed.
               Preceding by an 'r' makes an attempt at robust (outlier-resistant)
               estimation. Combining q and r (e.g. 'family','qrpois') may
               work, if you're lucky.
             Density estimation-type families are 'dens', 'rate' and 'hazard'
               (hazard or failure rate). Note that `dens' scales the output
               to be a statistical density estimate (i.e. scaled to integrate
               to 1). 'rate' estimates the rate or intensity function (events
               per unit time, or events per unit area), which may be called
               density in some fields.
             The default family is 'qgauss' if a response (y argument) has been
             provided, and 'dens' if no response is given.
        'link' Link function for local likelihood fitting. Depending on the
               family, choices may be 'ident', 'log', 'logit',
               'inverse', 'sqrt' and 'arcsin'.

      Evaluation structures.
        By default, locfit chooses a set of points, depending on the data
        and smoothing parameters, to evaluate at. This is controlled by
        the evaluation structure.
          'ev' Specify the evaluation structure. Default is 'tree'.
               Other choices include 'phull' (triangulation), 'grid' (a grid
               of points), 'data' (each data point), 'crossval' (data,
               but use leave-one-out cross validation), 'none' (no evaluation
               points, effectively producing the global parametric fit).
               Alternatively, a vector/matrix of evaluation points may be
               provided.
               (kd trees not currently supported in mlocfit)
         'll' and 'ur' -- row vectors specifying the upper and lower limits
               for the bounding box used by the evaluation structure.
               They default to the data range.
         'mg' For the 'grid' evaluation structure, 'mg' specifies the
               number of points on each margin. Default 10. Can be either a
               single number or vector.
        'cut' Refinement parameter for adaptive partitions. Default 0.8;
               smaller values result in more refined partitions.
        'maxk' Controls space assignment for evaluation structures. For the
               adaptive evaluation structures, it is impossible to be sure
               in advance how many vertices will be generated. If you get
               warnings about `Insufficient vertex space', Locfit's default
               assigment can be increased by increasing 'maxk'. The default
               is 'maxk','100'.

        'xlim' For density estimation, Locfit allows the density to be
               supported on a bounded interval (or rectangle, in more than
               one dimension). The format should be [ll;ul] (ie, matrix with
               two rows, d columns) where ll is the lower left corner of
               the rectangle, and ur is the upper right corner.
               One-sided bounds, such as [0,infty), are not supported, but can be
               effectively specified by specifying a very large upper
               bound.

          'module' either 'name' or {'name','/path/to/module',parameters}.

      Density Estimation
          'renorm',1  will attempt to renormalize the local likelihood
               density estimate so that it integrates to 1. The llde
               (specified by 'family','dens') is scaled to estimate the
               density, but since the estimation is pointwise, there is
               no guarantee that the resulting density integrates exactly
               to 1. Renormalization attempts to achieve this.

      The output of locfit() is a Matlab structure:

     fit.data.x (n*d)
     fit.data.y (n*1)
     fit.data.weights (n*1 or 1*1)
     fit.data.censor (n*1 or 1*1)
     fit.data.baseline (n*1 or 1*1)
     fit.data.style (string length d)
     fit.data.scales (1*d)
     fit.data.xlim (2*d)

     fit.evaluation_structure.type (string)
     fit.evaluation_structure.module.name (string)
     fit.evaluation_structure.module.directory (string)
     fit.evaluation_structure.module.parameters (string)
     fit.evaluation_structure.lower_left (numeric 1*d)
     fit.evaluation_structure.upper_right (numeric 1*d)
     fit.evaluation_structure.grid (numeric 1*d)
     fit.evaluation_structure.cut (numeric 1*d)
     fit.evaluation_structure.maxk
     fit.evaluation_structure.derivative

     fit.smoothing_parameters.alpha = (nn h pen) vector
     fit.smoothing_parameters.adaptive_criterion (string)
     fit.smoothing_parameters.degree (numeric)
     fit.smoothing_parameters.family (string)
     fit.smoothing_parameters.link (string)
     fit.smoothing_parameters.kernel (string)
     fit.smoothing_parameters.kernel_type (string)
     fit.smoothing_parameters.deren
     fit.smoothing_parameters.deit
     fit.smoothing_parameters.demint
     fit.smoothing_parameters.debug

     fit.fit_points.evaluation_points (d*nv matrix)
     fit.fit_points.fitted_values (matrix, nv rows, many columns)
     fit.fit_points.evaluation_vectors.cell
     fit.fit_points.evaluation_vectors.splitvar
     fit.fit_points.evaluation_vectors.lo
     fit.fit_points.evaluation_vectors.hi
     fit.fit_points.fit_limits (d*2 matrix)
     fit.fit_points.family_link (numeric values)
     fit.fit_points.kappa (likelihood, degrees of freedom, etc)

     fit.parametric_component

      The OLD format:

        fit{1} = data.
        fit{2} = evaluation structure.
        fit{3} = smoothing parameter structure.
        fit{4}{1} = fit points matrix.
        fit{4}{2} = matrix of fitted values etc.
               Note that these are not back-transformed, and may have the
               parametric component removed.
               (exact content varies according to module).
        fit{4}{3} = various details of the evaluation points.
        fit{4}{4} = fit limits.
        fit{4}{5} = family,link.
        fit{5} = parametric component values.

## CROSS-REFERENCE INFORMATION

This function calls:

This function is called by:

- fig10_1 Local Regression and Likelihood, Figure 10.1.
- fig11_1 Local Regression and Likelihood, Figure 11.1
- fig11_4 Local Regression and Likelihood, Figure 11.4.
- fig11_5 Local Regression and Likelihood, Figure 11.5.
- fig13_1 Local Regression and Likelihood, Figure 13.1
- fig1_1 Local Regression and Likelihood, Figure 1.1.
- fig2_2 Local Regression and Likelihood, Figure 2.2.
- fig2_3 Local Regression and Likelihood, Figure 2.3.
- fig2_4 Local Regression and Likelihood, Figure 2.4.
- fig2_5 Local Regression and Likelihood, Figure 2.5.
- fig2_6 Local Regression and Likelihood, Figure 2.6.
- fig3_1 Local Regression and Likelihood, Figure 3.1.
- fig4_1 Local Regression and Likelihood, Figure 4.1.
- fig4_2 Local Regression and Likelihood, Figure 4.2.
- fig4_3 Local Regression and Likelihood, Figure 4.3.
- fig5_1 Local Regression and Likelihood, Figure 5.1.
- fig5_2 Local Regression and Likelihood, Figure 5.2.
- fig5_3 Local Regression and Likelihood, Figure 5.3.
- fig5_4 Local Regression and Likelihood, Figure 5.4.
- fig5_5 Local Regression and Likelihood, Figure 5.5.
- fig5_6 Local Regression and Likelihood, Figure 5.6.
- fig6_1 Local Regression and Likelihood, Figure 6.1.
- fig6_2 Local Regression and Likelihood, Figure 6.2.
- fig6_3 Local Regression and Likelihood, Figure 6.3.
- fig6_4 Local Regression and Likelihood, Figure 6.4.
- fig6_5 Local Regression and Likelihood, Figure 6.5.
- fig6_6 Local Regression and Likelihood, Figure 6.6.
- fig6_7 Local Regression and Likelihood, Figure 6.6.
- fig7_1 Local Regression and Likelihood, Figure 7.1.
- fig7_2 Local Regression and Likelihood, Figure 7.2.
- fig7_3 Local Regression and Likelihood, Figure 7.3.
- fig7_4 Local Regression and Likelihood, Figure 7.4.
- fig7_5 Local Regression and Likelihood, Figure 7.5.
- fig7_6 Local Regression and Likelihood, Figure 7.6.
- fig8_1 Local Regression and Likelihood, Figure 8.1.
- fig8_2 Local Regression and Likelihood, Figure 8.2.
- fig8_3 Local Regression and Likelihood, Figure 8.3.
- fig9_2 Local Regression and Likelihood, Figure 9.2.
- lfex1 Local Estimation a spike firing rate (in spikes per unit time).
- lfex2 Model the success probability of successive trials of a monkey
- aic
- gcv
- hatmatrix
- kappa0 Compute the constants for `tube-formula' based simultaneous
- lcv
- lf_censor
- lfgui LFGUI M-file for lfgui.fig
- lfsmooth
- locfit_all Smoothing noisy data using Local Regression and Likelihood.
- scb Simultaneous Confidence Bands
- smooth_lf must (unlike R smooth.lf() function) give x and y.
- den_jack Function to compute smooth estimates of the mean of x using locfit,

## SOURCE CODE

    0001 function fit=locfit(varargin)
    0002
    0003 % Smoothing noisy data using Local Regression and Likelihood.
    0004 %
    0005 % arguments still to add: dc maxit
    0006 %
    0007 %  Usage: fit = locfit(x,y)   % local regression fit of x and y.
    0008 %         fit = locfit(x)     % density estimation of x.
    0009 %
    0010 %  Smoothing with locfit is a two-step procedure. The locfit()
    0011 %  function evaluates the local regression smooth at a set of points
    0012 %  (can be specified through an evaluation structure). Then, use
    0013 %  the predict() function to interpolate this fit to other points.
    0014 %
    0015 %  Additional arguments to locfit() are specified as 'name',value pairs, e.g.:
    0016 %  locfit( x, 'alpha',[0.7,1.5] , 'family','rate' , 'ev','grid' , 'mg',100 );
    0017 %
    0018 %
    0019 %  Data-related inputs:
    0020 %
    0021 %    x is a vector or matrix of the independent (or predictor) variables.
    0022 %      Rows of x represent subjects, columns represent variables.
    0023 %      Generally, local regression would be used with 1-4 independent
    0024 %      variables. In higher dimensions, the curse-of-dimensionality,
    0025 %      as well as the difficulty of visualizing higher dimensional
    0026 %      surfaces, may limit usefulness.
    0027 %
    0028 %    y is the column vector of the dependent (or response) variable.
    0029 %      For density families, 'y' is omitted.
    0030 % NOTE: x and y are the first two arguments. All other arguments require
    0031 %        the 'name',value notation.
    0032 %
    0033 %    'weights' Prior weights for observations (reciprocal of variance, or
    0034 %           sample size).
    0035 %    'cens' Censoring indicators for hazard rate or censored regression.
    0036 %           The coding is '1' (or 'TRUE') for a censored observation, and
    0037 %           '0' (or 'FALSE') for uncensored observations.
    0038 %    'base' Baseline parameter estimate. If a baseline is provided,
    0039 %           the local regression model is fitted as
    0040 %                        Y_i = b_i + m(x_i) + epsilon_i,
    0041 %           with Locfit estimating the m(x) term. For regression models,
    0042 %           this effectively subtracts b_i from Y_i. The advantage of the
    0043 %           'base' formulation is that it extends to likelihood
    0044 %           regression models.
    0045 %    'scale' A scale to apply to each variable. This is especially
    0046 %           important for multivariate fitting, where variables may be
    0047 %           measured in non-comparable units. It is also used to specify
    0048 %           the frequency for variables with the 'a' (angular) style.
    0049 %     'sty' Character string (length d) of styles for each predictor variable.
    0050 %           n denotes `normal'; a denotes angular (or periodic); l and r
    0051 %           denotes one-sided left and right; c is conditionally parametric.
    0052 %
    0053 %
    0054 %  Smoothing Parameters and Bandwidths:
    0055 %  The bandwidth (or more accurately, half-width) of the smoothing window
    0056 %  controls the amount of smoothing. Locfit allows specification of constant
    0057 %  (fixed), nearest neighbor, certain locally adaptive variable bandwidths,
    0058 %  and combinations of these. Also related to the smoothing parameter
    0059 %  are the local polynmial degree and weight function.
    0060 %
    0061 %    'nn' 'Nearest neighbor' smoothing parameter. Specifying 'nn',0.5
    0062 %         means that the width of each smoothing neighborhood is chosen
    0063 %         to cover 50% of the data.
    0064 %
    0065 %     'h' A constant (or fixed) bandwidth parameter. For example, 'h',2
    0066 %         means that the smoothing windows have constant half-width
    0067 %         (or radius) 2. Note that h is applied after scaling.
    0068 %
    0069 %   'pen' penalty parameter for adaptive smoothing. Needs to be used
    0070 %         with care.
    0071 %
    0072 %  'alpha' The old way of specifying smoothing parameters, as used in
    0073 %         my book. alpha is equivalent to the vector [nn,h,pen].
    0074 %         If multiple componenents are non-zero, the largest corresponding
    0075 %         bandwidth is used. The default (if none of alpha,nn,h,pen
    0076 %         are provided) is [0.7 0 0].
    0077 %
    0078 %   'deg' Degree of local polynomial. Default: 2 (local quadratic).
    0079 %         Degrees 0 to 3 are supported by almost all parts of the
    0080 %         Locfit code. Higher degrees may work in some cases.
    0081 %
    0082 %  'kern' Weight function, default = 'tcub'. Other choices are
    0083 %         'rect', 'trwt', 'tria', 'epan', 'bisq' and 'gauss'.
    0084 %         Choices may be restricted when derivatives are
    0085 %         required; e.g. for confidence bands and some bandwidth
    0086 %         selectors.
    0087 %
    0088 %    'kt' Kernel type, 'sph' (default); 'prod'. In multivariate
    0089 %         problems, 'prod' uses a simplified product model which
    0090 %         speeds up computations.
    0091 %
    0092 %  'acri' Criterion for adaptive bandwidth selection.
    0093 %
    0094 %
    0095 %  Derivative Estimation.
    0096 %  Generally I recommend caution when using derivative estimation
    0097 %  (and especially higher order derivative estimation) -- can you
    0098 %  really estimate derivatives from noisy data? Any derivative
    0099 %  estimate is inherently more dependent on an assumed smoothness
    0100 %  (expressed through the bandwidth) than the data. Warnings aside...
    0101 %
    0102 %  'deriv' Derivative estimation. 'deriv',1 specifies the first derivative
    0103 %         (or more correctly, an estimate of the local slope is returned.
    0104 %         'deriv',[1 1] specifies the second derivative. For bivariate fits
    0105 %         'deriv',2 specifies the first partial derivative wrt x2.
    0106 %         'deriv',[1 2] is mixed second-order derivative.
    0107 %
    0108 %  Fitting family.
    0109 %  'family' is used to specify the local likelihood family.
    0110 %         Regression-type families are 'gaussian', 'binomial',
    0111 %           'poisson', 'gamma' and 'geom'. If the family is preceded
    0112 %           by a q (e.g. 'qgauss', or 'qpois') then quasi-likelihood is
    0113 %           used; in particular, a dispersion estimate is computed.
    0114 %           Preceding by an 'r' makes an attempt at robust (outlier-resistant)
    0115 %           estimation. Combining q and r (e.g. 'family','qrpois') may
    0116 %           work, if you're lucky.
    0117 %         Density estimation-type families are 'dens', 'rate' and 'hazard'
    0118 %           (hazard or failure rate). Note that `dens' scales the output
    0119 %           to be a statistical density estimate (i.e. scaled to integrate
    0120 %           to 1). 'rate' estimates the rate or intensity function (events
    0121 %           per unit time, or events per unit area), which may be called
    0122 %           density in some fields.
    0123 %         The default family is 'qgauss' if a response (y argument) has been
    0124 %         provided, and 'dens' if no response is given.
    0125 %    'link' Link function for local likelihood fitting. Depending on the
    0126 %           family, choices may be 'ident', 'log', 'logit',
    0127 %           'inverse', 'sqrt' and 'arcsin'.
    0128 %
    0129 %  Evaluation structures.
    0130 %    By default, locfit chooses a set of points, depending on the data
    0131 %    and smoothing parameters, to evaluate at. This is controlled by
    0132 %    the evaluation structure.
    0133 %      'ev' Specify the evaluation structure. Default is 'tree'.
    0134 %           Other choices include 'phull' (triangulation), 'grid' (a grid
    0135 %           of points), 'data' (each data point), 'crossval' (data,
    0136 %           but use leave-one-out cross validation), 'none' (no evaluation
    0137 %           points, effectively producing the global parametric fit).
    0138 %           Alternatively, a vector/matrix of evaluation points may be
    0139 %           provided.
    0140 %           (kd trees not currently supported in mlocfit)
    0141 %     'll' and 'ur' -- row vectors specifying the upper and lower limits
    0142 %           for the bounding box used by the evaluation structure.
    0143 %           They default to the data range.
    0144 %     'mg' For the 'grid' evaluation structure, 'mg' specifies the
    0145 %           number of points on each margin. Default 10. Can be either a
    0146 %           single number or vector.
    0147 %    'cut' Refinement parameter for adaptive partitions. Default 0.8;
    0148 %           smaller values result in more refined partitions.
    0149 %    'maxk' Controls space assignment for evaluation structures. For the
    0150 %           adaptive evaluation structures, it is impossible to be sure
    0151 %           in advance how many vertices will be generated. If you get
    0152 %           warnings about `Insufficient vertex space', Locfit's default
    0153 %           assigment can be increased by increasing 'maxk'. The default
    0154 %           is 'maxk','100'.
    0155 %
    0156 %    'xlim' For density estimation, Locfit allows the density to be
    0157 %           supported on a bounded interval (or rectangle, in more than
    0158 %           one dimension). The format should be [ll;ul] (ie, matrix with
    0159 %           two rows, d columns) where ll is the lower left corner of
    0160 %           the rectangle, and ur is the upper right corner.
    0161 %           One-sided bounds, such as [0,infty), are not supported, but can be
    0162 %           effectively specified by specifying a very large upper
    0163 %           bound.
    0164 %
    0165 %      'module' either 'name' or {'name','/path/to/module',parameters}.
    0166 %
    0167 %  Density Estimation
    0168 %      'renorm',1  will attempt to renormalize the local likelihood
    0169 %           density estimate so that it integrates to 1. The llde
    0170 %           (specified by 'family','dens') is scaled to estimate the
    0171 %           density, but since the estimation is pointwise, there is
    0172 %           no guarantee that the resulting density integrates exactly
    0173 %           to 1. Renormalization attempts to achieve this.
    0174 %
    0175 %  The output of locfit() is a Matlab structure:
    0176 %
    0177 % fit.data.x (n*d)
    0178 % fit.data.y (n*1)
    0179 % fit.data.weights (n*1 or 1*1)
    0180 % fit.data.censor (n*1 or 1*1)
    0181 % fit.data.baseline (n*1 or 1*1)
    0182 % fit.data.style (string length d)
    0183 % fit.data.scales (1*d)
    0184 % fit.data.xlim (2*d)
    0185 %
    0186 % fit.evaluation_structure.type (string)
    0187 % fit.evaluation_structure.module.name (string)
    0188 % fit.evaluation_structure.module.directory (string)
    0189 % fit.evaluation_structure.module.parameters (string)
    0190 % fit.evaluation_structure.lower_left (numeric 1*d)
    0191 % fit.evaluation_structure.upper_right (numeric 1*d)
    0192 % fit.evaluation_structure.grid (numeric 1*d)
    0193 % fit.evaluation_structure.cut (numeric 1*d)
    0194 % fit.evaluation_structure.maxk
    0195 % fit.evaluation_structure.derivative
    0196 %
    0197 % fit.smoothing_parameters.alpha = (nn h pen) vector
    0198 % fit.smoothing_parameters.adaptive_criterion (string)
    0199 % fit.smoothing_parameters.degree (numeric)
    0200 % fit.smoothing_parameters.family (string)
    0201 % fit.smoothing_parameters.link (string)
    0202 % fit.smoothing_parameters.kernel (string)
    0203 % fit.smoothing_parameters.kernel_type (string)
    0204 % fit.smoothing_parameters.deren
    0205 % fit.smoothing_parameters.deit
    0206 % fit.smoothing_parameters.demint
    0207 % fit.smoothing_parameters.debug
    0208 %
    0209 % fit.fit_points.evaluation_points (d*nv matrix)
    0210 % fit.fit_points.fitted_values (matrix, nv rows, many columns)
    0211 % fit.fit_points.evaluation_vectors.cell
    0212 % fit.fit_points.evaluation_vectors.splitvar
    0213 % fit.fit_points.evaluation_vectors.lo
    0214 % fit.fit_points.evaluation_vectors.hi
    0215 % fit.fit_points.fit_limits (d*2 matrix)
    0216 % fit.fit_points.family_link (numeric values)
    0217 % fit.fit_points.kappa (likelihood, degrees of freedom, etc)
    0218 %
    0219 % fit.parametric_component
    0220 %
    0221 %
    0222 %  The OLD format:
    0223 %
    0224 %    fit{1} = data.
    0225 %    fit{2} = evaluation structure.
    0226 %    fit{3} = smoothing parameter structure.
    0227 %    fit{4}{1} = fit points matrix.
    0228 %    fit{4}{2} = matrix of fitted values etc.
    0229 %           Note that these are not back-transformed, and may have the
    0230 %           parametric component removed.
    0231 %           (exact content varies according to module).
    0232 %    fit{4}{3} = various details of the evaluation points.
    0233 %    fit{4}{4} = fit limits.
    0234 %    fit{4}{5} = family,link.
    0235 %    fit{5} = parametric component values.
    0236 %
    0237
    0238
    0239
    0240 % Minimal input validation
    0241 if nargin < 1
    0242    error( 'At least one input argument required' );
    0243 end
    0244
    0245 xdata = double(varargin{1});
    0246 d = size(xdata,2);
    0247 n = size(xdata,1);
    0248 if ((nargin>1) && (~ischar(varargin{2})))
    0249   ydata = double(varargin{2});
    0250   if (any(size(ydata) ~= [n 1])); error('y must be n*1 column vector'); end;
    0251   family = 'qgauss';
    0252   na = 3;
    0253 else
    0254   ydata = 0;
    0255   family = 'density';
    0256   na = 2;
    0257 end;
    0258 if mod(nargin-na,2)==0
    0259   error( 'All arguments other than x, y must be name,value pairs' );
    0260 end
    0261
    0262
    0263 wdata = ones(n,1);
    0264 cdata = 0;
    0265 base  = 0;
    0266 style = 'n';
    0267 scale = 1;
    0268 xl = zeros(2,d);
    0269
    0270 alpha = [0 0 0];
    0271 deg = 2;
    0272 link = 'default';
    0273 acri = 'none';
    0274 kern = 'tcub';
    0275 kt = 'sph';
    0276 deren = 0;
    0277 deit  = 'default';
    0278 demint= 20;
    0279 debug = 0;
    0280
    0281 ev = 'tree';
    0282 ll = zeros(1,d);
    0283 ur = zeros(1,d);
    0284 mg = 10;
    0285 maxk = 100;
    0286 deriv=0;
    0287 cut = 0.8;
    0288 mdl = struct('name','std', 'directory','', 'parameters',0 );
    0289
    0290 while na < length(varargin)
    0291     inc = 0;
    0292     if (varargin{na}=='y')
    0293         ydata = double(varargin{na+1});
    0294         family = 'qgauss';
    0295         inc = 2;
    0296         if (any(size(ydata) ~= [n 1])); error('y must be n*1 column vector'); end;
    0297     end
    0298     if (strcmp(varargin{na},'weights'))
    0299         wdata = double(varargin{na+1});
    0300         inc = 2;
    0301         if (any(size(wdata) ~= [n 1])); error('weights must be n*1 column vector'); end;
    0302     end
    0303     if (strcmp(varargin{na},'cens'))
    0304         cdata = double(varargin{na+1});
    0305         inc = 2;
    0306         if (any(size(cdata) ~= [n 1])); error('cens must be n*1 column vector'); end;
    0307     end
    0308     if (strcmp(varargin{na},'base')) % numeric vector, n*1 or 1*1.
    0309         base = double(varargin{na+1});
    0310         if (length(base)==1); base = base*ones(n,1); end;
    0311         inc = 2;
    0312     end
    0313     if (strcmp(varargin{na},'style')) % character string of length d.
    0314         style = varargin{na+1};
    0315         inc = 2;
    0316     end;
    0317     if (strcmp(varargin{na},'scale')) % row vector, length 1 or d.
    0318         scale = varargin{na+1};
    0319         if (scale==0)
    0320           scale = zeros(1,d);
    0321           for i=1:d
    0322             scale(i) = sqrt(var(xdata(:,i)));
    0323           end;
    0324         end;
    0325         inc = 2;
    0326     end;
    0327     if (strcmp(varargin{na},'xlim')) % 2*d numeric matrix.
    0328         xl = varargin{na+1};
    0329         inc = 2;
    0330     end
    0331     if (strcmp(varargin{na},'alpha')) % row vector of length 1, 2 or 3.
    0332         alpha = [varargin{na+1} 0 0 0];
    0333         alpha = alpha(1:3);
    0334         inc = 2;
    0335     end
    0336     if (strcmp(varargin{na},'nn')) % scalar
    0337         alpha(1) = varargin{na+1};
    0338         inc = 2;
    0339     end
    0340     if (strcmp(varargin{na},'h')) % scalar
    0341         alpha(2) = varargin{na+1};
    0342         inc = 2;
    0343     end;
    0344     if (strcmp(varargin{na},'pen')) % scalar
    0345         alpha(3) = varargin{na+1};
    0346         inc = 2;
    0347     end;
    0348     if (strcmp(varargin{na},'acri')) % string
    0349         acri = varargin{na+1};
    0350         inc = 2;
    0351     end
    0352     if (strcmp(varargin{na},'deg')) % positive integer.
    0353         deg = varargin{na+1};
    0354         inc = 2;
    0355     end;
    0356     if (strcmp(varargin{na},'family')) % character string.
    0357         family = varargin{na+1};
    0358         inc = 2;
    0359     end;
    0360     if (strcmp(varargin{na},'link')) % character string.
    0361         link = varargin{na+1};
    0362         inc = 2;
    0363     end;
    0364     if (strcmp(varargin{na},'kern')) % character string.
    0365         kern = varargin{na+1};
    0366         inc = 2;
    0367     end;
    0368     if (strcmp(varargin{na},'kt')) % character string.
    0369         kt = varargin{na+1};
    0370         inc = 2;
    0371     end;
    0372     if (strcmp(varargin{na},'ev')) % char. string, or matrix with d columns.
    0373         ev = varargin{na+1};
    0374         if (isnumeric(ev)); ev = ev'; end;
    0375         inc = 2;
    0376     end;
    0377     if (strcmp(varargin{na},'ll')) % row vector of length d.
    0378         ll = varargin{na+1};
    0379         inc = 2;
    0380     end;
    0381     if (strcmp(varargin{na},'ur')) % row vector of length d.
    0382         ur = varargin{na+1};
    0383         inc = 2;
    0384     end;
    0385     if (strcmp(varargin{na},'mg')) % row vector of length d.
    0386         mg = varargin{na+1};
    0387         inc = 2;
    0388     end;
    0389     if (strcmp(varargin{na},'cut')) % positive scalar.
    0390         cut = varargin{na+1};
    0391         inc = 2;
    0392     end;
    0393     if (strcmp(varargin{na},'module')) % string.
    0394         mdl = struct('name',varargin{na+1}, 'directory','', 'parameters',0 );
    0395         inc = 2;
    0396     end;
    0397     if (strcmp(varargin{na},'maxk')) % positive integer.
    0398         maxk = varargin{na+1};
    0399         inc = 2;
    0400     end;
    0401     if (strcmp(varargin{na},'deriv')) % numeric row vector, up to deg elements.
    0402         deriv = varargin{na+1};
    0403         inc = 2;
    0404     end;
    0405     if (strcmp(varargin{na},'renorm')) % density renormalization.
    0406         deren = varargin{na+1};
    0407         inc = 2;
    0408     end;
    0409     if (strcmp(varargin{na},'itype')) % density - integration type.
    0410         deit = varargin{na+1};
    0411         inc = 2;
    0412     end;
    0413     if (strcmp(varargin{na},'mint')) % density - # of integration points.
    0414         demint = varargin{na+1};
    0415         inc = 2;
    0416     end;
    0417     if (strcmp(varargin{na},'debug')) % debug level.
    0418         debug = varargin{na+1};
    0419         inc = 2;
    0420     end;
    0421     if (inc==0)
    0422       disp(varargin{na});
    0423       error('Unknown Input Argument.');
    0424     end;
    0425     na=na+inc;
    0426 end
    0427
    0428
    0429 fit.data.x = xdata;
    0430 fit.data.y = ydata;
    0431 fit.data.weights = wdata;
    0432 fit.data.censor = cdata;
    0433 fit.data.baseline = base;
    0434 fit.data.style = style;
    0435 fit.data.scales = scale;
    0436 fit.data.xlim = xl;
    0437
    0438 fit.evaluation_structure.type = ev;
    0439 fit.evaluation_structure.module = mdl;
    0440 fit.evaluation_structure.lower_left = ll;
    0441 fit.evaluation_structure.upper_right = ur;
    0442 fit.evaluation_structure.grid = mg;
    0443 fit.evaluation_structure.cut = cut;
    0444 fit.evaluation_structure.maxk = maxk;
    0445 fit.evaluation_structure.derivative = deriv;
    0446
    0447 if (alpha==0); alpha = [0.7 0 0]; end;
    0448
    0449 fit.smoothing_parameters.alpha = alpha;
    0450 fit.smoothing_parameters.adaptive_criterion = acri;
    0451 fit.smoothing_parameters.degree = deg;
    0452 fit.smoothing_parameters.family = family;
    0453 fit.smoothing_parameters.link = link;
    0454 fit.smoothing_parameters.kernel = kern;
    0455 fit.smoothing_parameters.kernel_type = kt;
    0456 fit.smoothing_parameters.deren = deren;
    0457 fit.smoothing_parameters.deit = deit;
    0458 fit.smoothing_parameters.demint = demint;
    0459 fit.smoothing_parameters.debug = debug;
    0460
    0461 [fpc pcomp] = mexlf(fit.data,fit.evaluation_structure,fit.smoothing_parameters);
    0462 fit.fit_points = fpc;
    0463 fit.parametric_component = pcomp;
    0464
    0465 return
    0466
    0467
    0468