Math-LOESS

 view release on metacpan or  search on metacpan

lib/Math/LOESS/_swig.pm  view on Meta::CPAN

%OWNER = ();
%ITERATORS = ();
*swig_surface_get = *Math::LOESS::_swigc::loess_control_surface_get;
*swig_surface_set = *Math::LOESS::_swigc::loess_control_surface_set;
*swig_statistics_get = *Math::LOESS::_swigc::loess_control_statistics_get;
*swig_statistics_set = *Math::LOESS::_swigc::loess_control_statistics_set;
*swig_cell_get = *Math::LOESS::_swigc::loess_control_cell_get;
*swig_cell_set = *Math::LOESS::_swigc::loess_control_cell_set;
*swig_trace_hat_get = *Math::LOESS::_swigc::loess_control_trace_hat_get;
*swig_trace_hat_set = *Math::LOESS::_swigc::loess_control_trace_hat_set;
*swig_iterations_get = *Math::LOESS::_swigc::loess_control_iterations_get;
*swig_iterations_set = *Math::LOESS::_swigc::loess_control_iterations_set;
sub new {
    my $pkg = shift;
    my $self = Math::LOESS::_swigc::new_loess_control(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;

loess/_swig_wrap.c  view on Meta::CPAN

    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
    
    XSRETURN(argvi);
  fail:
    
    SWIG_croak_null();
  }
}


XS(_wrap_loess_control_iterations_set) {
  {
    loess_control *arg1 = (loess_control *) 0 ;
    int arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int val2 ;
    int ecode2 = 0 ;
    int argvi = 0;
    dXSARGS;
    
    if ((items < 2) || (items > 2)) {
      SWIG_croak("Usage: loess_control_iterations_set(self,iterations);");
    }
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_loess_control, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loess_control_iterations_set" "', argument " "1"" of type '" "loess_control *""'"); 
    }
    arg1 = (loess_control *)(argp1);
    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "loess_control_iterations_set" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
    if (arg1) (arg1)->iterations = arg2;
    ST(argvi) = &PL_sv_undef;
    
    
    XSRETURN(argvi);
  fail:
    
    
    SWIG_croak_null();
  }
}


XS(_wrap_loess_control_iterations_get) {
  {
    loess_control *arg1 = (loess_control *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int argvi = 0;
    int result;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) {
      SWIG_croak("Usage: loess_control_iterations_get(self);");
    }
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_loess_control, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loess_control_iterations_get" "', argument " "1"" of type '" "loess_control *""'"); 
    }
    arg1 = (loess_control *)(argp1);
    result = (int) ((arg1)->iterations);
    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
    
    XSRETURN(argvi);
  fail:
    
    SWIG_croak_null();
  }
}

loess/_swig_wrap.c  view on Meta::CPAN

{"Math::LOESS::_swigc::new_loess_model", _wrap_new_loess_model},
{"Math::LOESS::_swigc::delete_loess_model", _wrap_delete_loess_model},
{"Math::LOESS::_swigc::loess_control_surface_set", _wrap_loess_control_surface_set},
{"Math::LOESS::_swigc::loess_control_surface_get", _wrap_loess_control_surface_get},
{"Math::LOESS::_swigc::loess_control_statistics_set", _wrap_loess_control_statistics_set},
{"Math::LOESS::_swigc::loess_control_statistics_get", _wrap_loess_control_statistics_get},
{"Math::LOESS::_swigc::loess_control_cell_set", _wrap_loess_control_cell_set},
{"Math::LOESS::_swigc::loess_control_cell_get", _wrap_loess_control_cell_get},
{"Math::LOESS::_swigc::loess_control_trace_hat_set", _wrap_loess_control_trace_hat_set},
{"Math::LOESS::_swigc::loess_control_trace_hat_get", _wrap_loess_control_trace_hat_get},
{"Math::LOESS::_swigc::loess_control_iterations_set", _wrap_loess_control_iterations_set},
{"Math::LOESS::_swigc::loess_control_iterations_get", _wrap_loess_control_iterations_get},
{"Math::LOESS::_swigc::new_loess_control", _wrap_new_loess_control},
{"Math::LOESS::_swigc::delete_loess_control", _wrap_delete_loess_control},
{"Math::LOESS::_swigc::loess_kd_tree_parameter_set", _wrap_loess_kd_tree_parameter_set},
{"Math::LOESS::_swigc::loess_kd_tree_parameter_get", _wrap_loess_kd_tree_parameter_get},
{"Math::LOESS::_swigc::loess_kd_tree_a_set", _wrap_loess_kd_tree_a_set},
{"Math::LOESS::_swigc::loess_kd_tree_a_get", _wrap_loess_kd_tree_a_get},
{"Math::LOESS::_swigc::loess_kd_tree_xi_set", _wrap_loess_kd_tree_xi_set},
{"Math::LOESS::_swigc::loess_kd_tree_xi_get", _wrap_loess_kd_tree_xi_get},
{"Math::LOESS::_swigc::loess_kd_tree_vert_set", _wrap_loess_kd_tree_vert_set},
{"Math::LOESS::_swigc::loess_kd_tree_vert_get", _wrap_loess_kd_tree_vert_get},

loess/linpack_lite.f  view on Meta::CPAN

c     internal variables
c
      integer i,iter,j,jobu,k,kase,kk,l,ll,lls,lm1,lp1,ls,lu,m,maxit,
     *        mm,mm1,mp1,nct,nctp1,ncu,nrt,nrtp1
      double precision ddot,t,r
      double precision b,c,cs,el,emm1,f,g,dnrm2,scale,shift,sl,sm,sn,
     *                 smm1,t1,test,ztest
      logical wantu,wantv
c
c
c     set the maximum number of iterations.
c
      maxit = 30
c
c     determine what is to be computed.
c
      wantu = .false.
      wantv = .false.
      jobu = mod(job,100)/10
      ncu = n
      if (jobu .gt. 1) ncu = min0(n,p)

loess/linpack_lite.f  view on Meta::CPAN

c
      mm = m
      iter = 0
  360 continue
c
c        quit if all the singular values have been found.
c
c     ...exit
         if (m .eq. 0) go to 620
c
c        if too many iterations have been performed, set
c        flag and return.
c
         if (iter .lt. maxit) go to 370
            info = m
c     ......exit
            go to 620
  370    continue
c
c        this section of the program inspects for
c        negligible elements in the s and e arrays.  on

loess/loess.c  view on Meta::CPAN

int error_status = 0;
char *error_message = NULL;

/* Declarations */

static void
loess_(double *y, double *x_, int *size_info, double *weights, double *span,
       int *degree, int *parametric, int *drop_square, int *normalize,
       char **statistics, char **surface, double *cell, char **trace_hat_in,
       int *iterations, double *fitted_values, double *fitted_residuals,
       double *enp, double *residual_scale, double *one_delta, double *two_delta,
       double *pseudovalues, double *trace_hat_out, double *diagonal,
       double *robust, double *divisor, int *parameter, int *a, double *xi,
       double *vert, double *vval);

void F77_SUB(lowesw)(double*, int*, double*, double*);
void F77_SUB(lowesp)(int*, double*, double*, double*,
                     double*, double*, double*);

static void

loess/loess.c  view on Meta::CPAN

   kd_tree->vert = MALLOC(p * 2 * sizeof(double));
   kd_tree->vval = MALLOC((p + 1) * max_kd * sizeof(double));
}

void
loess_control_setup(loess_control *control) {
   control->surface = "interpolate";
   control->statistics = "approximate";
   control->cell = 0.2;
   control->trace_hat = "wait.to.decide";
   control->iterations = 4;
}

void
loess_setup(double *x, double *y, double *w, long n, long p, loess *lo)
{
   loess_inputs_setup(x, y, w, n, p, lo->inputs);
   loess_model_setup(lo->model);
   loess_control_setup(lo->control);
   loess_outputs_setup(n, p, lo->outputs);
   loess_kd_tree_setup(n, p, lo->kd_tree);
}

static void
loess_(double *y, double *x_, int *size_info, double *weights, double *span,
       int *degree, int *parametric, int *drop_square, int *normalize,
       char **statistics, char **surface, double *cell, char **trace_hat_in,
       int *iterations, double *fitted_values, double *fitted_residuals,
       double *enp, double *residual_scale, double *one_delta, double *two_delta,
       double *pseudovalues, double *trace_hat_out, double *diagonal,
       double *robust, double *divisor, int *parameter, int *a, double *xi,
       double *vert, double *vval)
{
    double  *x, *x_tmp, new_cell, trL, delta1, delta2, sum_squares = 0,
            pseudo_resid, *temp, *xi_tmp, *vert_tmp, *vval_tmp,
            *diag_tmp, trL_tmp = 0, d1_tmp = 0, d2_tmp = 0, sum, mean;
    int    i, j, k, p, N, D, sum_drop_sqr = 0, sum_parametric = 0,
            setLf, nonparametric = 0, *order_parametric,

loess/loess.c  view on Meta::CPAN

                         "with only one numeric predictor";
        return;
    }

    if(sum_parametric == D) {
    	error_status = 1;
        error_message = "Specified parametric for all predictors";
        return;
    }

    // Start the iterations .....................
    for(j = 0; j <= (*iterations); j++) {
        new_stat = j ? "none" : *statistics;
        for(i = 0; i < N; i++)
            robust[i] = weights[i] * robust[i];
        condition(surface, new_stat, trace_hat_in);
        setLf = !strcmp(surf_stat, "interpolate/exact");
        loess_raw(y, x, weights, robust, &D, &N, span, degree,
                  &nonparametric, order_drop_sqr, &sum_drop_sqr,
                  &new_cell, &surf_stat, fitted_values, parameter, a,
                  xi, vert, vval, diagonal, &trL, &delta1, &delta2,
                  &setLf);
        if(j == 0) {
            *trace_hat_out = trL;
            *one_delta = delta1;
            *two_delta = delta2;
        }
        for(i = 0; i < N; i++){
            fitted_residuals[i] = y[i] - fitted_values[i];
        };
        if(j < (*iterations))
            F77_SUB(lowesw)(fitted_residuals, &N, robust, temp);
    }

    if((*iterations) > 0) {
        F77_SUB(lowesp)(&N, y, fitted_values, weights, robust, temp,
						pseudovalues);
        loess_raw(pseudovalues, x, weights, weights, &D, &N, span,
                  degree, &nonparametric, order_drop_sqr, &sum_drop_sqr,
                  &new_cell, &surf_stat, temp, param_tmp, a_tmp, xi_tmp,
                  vert_tmp, vval_tmp, diag_tmp, &trL_tmp, &d1_tmp, &d2_tmp,
                  &zero);
        for(i = 0; i < N; i++) {
            pseudo_resid = pseudovalues[i] - temp[i];
            sum_squares = sum_squares + weights[i] * pseudo_resid * pseudo_resid;

loess/loess.c  view on Meta::CPAN

    free(diag_tmp);
    free(a_tmp);
    free(param_tmp);
    free(order_parametric);
    free(order_drop_sqr);
}

void
loess_fit(loess *lo)
{
    int    size_info[2], iterations;

    size_info[0] = lo->inputs->p;
    size_info[1] = lo->inputs->n;

    //Reset the default error status...
    error_status = 0;
    lo->status.err_status = 0;
    lo->status.err_msg = NULL;

    iterations = (!strcmp(lo->model->family, "gaussian")) ? 0 :
    lo->control->iterations;
    if(!strcmp(lo->control->trace_hat, "wait.to.decide")) {
        if(!strcmp(lo->control->surface, "interpolate"))
            lo->control->trace_hat = (lo->inputs->n < 500) ? "exact" : "approximate";
        else
            lo->control->trace_hat = "exact";
    }
    loess_(lo->inputs->y, lo->inputs->x, size_info, lo->inputs->weights,
           &lo->model->span,
           &lo->model->degree,
           lo->model->parametric,
           lo->model->drop_square,
           &lo->model->normalize,
           &lo->control->statistics,
           &lo->control->surface,
           &lo->control->cell,
           &lo->control->trace_hat,
           &iterations,
           lo->outputs->fitted_values,
           lo->outputs->fitted_residuals,
           &lo->outputs->enp,
           &lo->outputs->residual_scale,
           &lo->outputs->one_delta,
           &lo->outputs->two_delta,
           lo->outputs->pseudovalues,
           &lo->outputs->trace_hat,
           lo->outputs->diagonal,
           lo->outputs->robust,

loess/loess.h  view on Meta::CPAN

    int    parametric[8];
    int    drop_square[8];
    char   *family;
    } loess_model;

typedef struct {
    char   *surface;
    char   *statistics;
    double cell;
    char   *trace_hat;
    int    iterations;
    } loess_control;

typedef struct {
    int   *parameter;
    int   *a;
    double *xi;
    double *vert;
    double *vval;
    } loess_kd_tree;