## Regressions

Regressions

## Synopsis

    enum                RegressionResult;
    #define             LOGFIT_C_ACCURACY
    #define             LOGFIT_C_STEP_FACTOR
    #define             LOGFIT_C_RANGE_FACTOR

    RegressionResult    go_linear_regression                (double **xss,
                                                             int dim,
                                                             const double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             double *res,
                                                             go_regression_stat_t *stat);
    RegressionResult    go_exponential_regression           (double **xss,
                                                             int dim,
                                                             const double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             double *res,
                                                             go_regression_stat_t *stat);
    RegressionResult    go_logarithmic_regression           (double **xss,
                                                             int dim,
                                                             const double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             double *res,
                                                             go_regression_stat_t *stat);
    RegressionResult    go_logarithmic_fit                  (double *xs,
                                                             const double *ys,
                                                             int n,
                                                             double *res);
    RegressionResult    go_non_linear_regression            (GORegressionFunction f,
                                                             double **xvals,
                                                             double *par,
                                                             double *yvals,
                                                             double *sigmas,
                                                             int x_dim,
                                                             int p_dim,
                                                             double *chi,
                                                             double *errors);
    go_regression_stat_t* go_regression_stat_new            (void);
    void                go_regression_stat_destroy          (go_regression_stat_t *regression_stat);
    gboolean            go_matrix_invert                    (double **A,
                                                             int n);
    double              go_matrix_determinant               (double **A,
                                                             int n);

    RegressionResult    go_linear_regressionl               (long double **xss,
                                                             int dim,
                                                             long double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             long double *res,
                                                             go_regression_stat_tl *stat);
    RegressionResult    go_exponential_regressionl          (long double **xss,
                                                             int dim,
                                                             long double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             long double *res,
                                                             go_regression_stat_tl *stat);
    RegressionResult    go_logarithmic_regressionl          (long double **xss,
                                                             int dim,
                                                             long double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             long double *res,
                                                             go_regression_stat_tl *stat);
    RegressionResult    go_logarithmic_fitl                 (long double *xs,
                                                             long double *ys,
                                                             int n,
                                                             long double *res);
    RegressionResult    go_non_linear_regressionl           (GORegressionFunctionl f,
                                                             long double **xvals,
                                                             long double *par,
                                                             long double *yvals,
                                                             long double *sigmas,
                                                             int x_dim,
                                                             int p_dim,
                                                             long double *chi,
                                                             long double *errors);
    go_regression_stat_tl* go_regression_stat_newl          (void);
    void                go_regression_stat_destroyl         (go_regression_stat_tl *regression_stat);
    gboolean            go_matrix_invertl                   (long double **A,
                                                             int n);

## Description

## Details

### enum RegressionResult

    typedef enum {
    	REG_ok,
    	REG_invalid_dimensions,
    	REG_invalid_data,
    	REG_not_enough_data,
    	REG_near_singular_good,	/* Probably good result */
    	REG_near_singular_bad, 	/* Probably bad result */
    	REG_singular
    } RegressionResult;

### LOGFIT_C_ACCURACY

    #define LOGFIT_C_ACCURACY 0.000001

### LOGFIT_C_STEP_FACTOR

    #define LOGFIT_C_STEP_FACTOR 0.05

### LOGFIT_C_RANGE_FACTOR

    #define LOGFIT_C_RANGE_FACTOR 100

### go_linear_regression ()

    RegressionResult    go_linear_regression                (double **xss,
                                                             int dim,
                                                             const double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             double *res,
                                                             go_regression_stat_t *stat);

Performs multi-dimensional linear regressions on the input points. Fits to "y = b + a1 * x1 + ... ad * xd".

`xss` : | x-vectors (i.e. independent data)
`dim` : | number of x-vectors.
`ys` : | y-vector. (Dependent data.)
`n` : | number of data points.
`affine` : | if true, a non-zero constant is allowed.
`res` : | output place for constant[0] and slope1[1], slope2[2],... There will be dim+1 results.
`stat` : |
Returns : | RegressionResult as above.

### go_exponential_regression ()

    RegressionResult    go_exponential_regression           (double **xss,
                                                             int dim,
                                                             const double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             double *res,
                                                             go_regression_stat_t *stat);

Performs one-dimensional linear regressions on the input points. Fits to "y = b * m1^x1 * ... * md^xd " or equivalently to "log y = log b + x1 * log m1 + ... + xd * log md".

`xss` : | x-vectors (i.e. independent data)
`dim` : | number of x-vectors
`ys` : | y-vector (dependent data)
`n` : | number of data points
`affine` : | if `TRUE`, a non-one multiplier is allowed
`res` : | output place for constant[0] and root1[1], root2[2],... There will be dim+1 results.
`stat` : |
Returns : | RegressionResult as above.

### go_logarithmic_regression ()

    RegressionResult    go_logarithmic_regression           (double **xss,
                                                             int dim,
                                                             const double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             double *res,
                                                             go_regression_stat_t *stat);

This is almost a copy of linear_regression and produces multi-dimensional linear regressions on the input points after transforming xss to ln(xss). Fits to "y = b + a1 * z1 + ... ad * zd" with "zi = ln (xi)". Problems with arrays in the calling function: see comment to gnumeric_linest, which is also valid for gnumeric_logreg.

(Errors: less than two points, all points on a vertical line, non-positive x data.)

`xss` : | x-vectors (i.e. independent data)
`dim` : | number of x-vectors
`ys` : | y-vector (dependent data)
`n` : | number of data points
`affine` : | if `TRUE`, a non-zero constant is allowed
`res` : | output place for constant[0] and factor1[1], factor2[2],... There will be dim+1 results.
`stat` : |
Returns : | RegressionResult as above.

### go_logarithmic_fit ()

    RegressionResult    go_logarithmic_fit                  (double *xs,
                                                             const double *ys,
                                                             int n,
                                                             double *res);

Performs a two-dimensional non-linear fitting on the input points. Fits to "y = a + b * ln (sign * (x - c))", with sign in {-1, +1}. The graph is a logarithmic curve moved horizontally by c and possibly mirrored across the y-axis (if sign = -1).

Fits c (and sign) by iterative trials, but seems to be fast enough even for automatic recomputation.

Adapts c until a local minimum of squared residuals is reached. For each new c tried out the corresponding a and b are calculated by linear regression. If no local minimum is found, an error is returned. If there is more than one local minimum, the one found is not necessarily the smallest (i.e., there might be cases in which the returned fit is not the best possible). If the shape of the point cloud is to different from ``logarithmic'', either sign can not be determined (error returned) or no local minimum will be found.

(Requires: at least 3 different x values, at least 3 different y values.)

`xs` : | x-vector (i.e. independent data)
`ys` : | y-vector (dependent data)
`n` : | number of data points
`res` : | output place for sign[0], a[1], b[2], c[3], and sum of squared residuals[4].
Returns : | RegressionResult as above.

### go_non_linear_regression ()

    RegressionResult    go_non_linear_regression            (GORegressionFunction f,
                                                             double **xvals,
                                                             double *par,
                                                             double *yvals,
                                                             double *sigmas,
                                                             int x_dim,
                                                             int p_dim,
                                                             double *chi,
                                                             double *errors);

`f` : |
`xvals` : |
`par` : |
`yvals` : |
`sigmas` : |
`x_dim` : |
`p_dim` : |
`chi` : |
`errors` : |
Returns : |

### go_regression_stat_new ()

    go_regression_stat_t* go_regression_stat_new            (void);

Returns : |

### go_regression_stat_destroy ()

    void                go_regression_stat_destroy          (go_regression_stat_t *regression_stat);

`regression_stat` : |

### go_matrix_invert ()

    gboolean            go_matrix_invert                    (double **A,
                                                             int n);

`A` : |
`n` : |
Returns : |

### go_matrix_determinant ()

    double              go_matrix_determinant               (double **A,
                                                             int n);

`A` : |
`n` : |
Returns : |

### go_linear_regressionl ()

    RegressionResult    go_linear_regressionl               (long double **xss,
                                                             int dim,
                                                             long double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             long double *res,
                                                             go_regression_stat_tl *stat);

`xss` : |
`dim` : |
`ys` : |
`n` : |
`affine` : |
`res` : |
`stat` : |
Returns : |

### go_exponential_regressionl ()

    RegressionResult    go_exponential_regressionl          (long double **xss,
                                                             int dim,
                                                             long double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             long double *res,
                                                             go_regression_stat_tl *stat);

`xss` : |
`dim` : |
`ys` : |
`n` : |
`affine` : |
`res` : |
`stat` : |
Returns : |

### go_logarithmic_regressionl ()

    RegressionResult    go_logarithmic_regressionl          (long double **xss,
                                                             int dim,
                                                             long double *ys,
                                                             int n,
                                                             gboolean affine,
                                                             long double *res,
                                                             go_regression_stat_tl *stat);

`xss` : |
`dim` : |
`ys` : |
`n` : |
`affine` : |
`res` : |
`stat` : |
Returns : |

### go_logarithmic_fitl ()

    RegressionResult    go_logarithmic_fitl                 (long double *xs,
                                                             long double *ys,
                                                             int n,
                                                             long double *res);

`xs` : |
`ys` : |
`n` : |
`res` : |
Returns : |

### go_non_linear_regressionl ()

    RegressionResult    go_non_linear_regressionl           (GORegressionFunctionl f,
                                                             long double **xvals,
                                                             long double *par,
                                                             long double *yvals,
                                                             long double *sigmas,
                                                             int x_dim,
                                                             int p_dim,
                                                             long double *chi,
                                                             long double *errors);

`f` : |
`xvals` : |
`par` : |
`yvals` : |
`sigmas` : |
`x_dim` : |
`p_dim` : |
`chi` : |
`errors` : |
Returns : |

### go_regression_stat_newl ()

    go_regression_stat_tl* go_regression_stat_newl          (void);

Returns : |

### go_regression_stat_destroyl ()

    void                go_regression_stat_destroyl         (go_regression_stat_tl *regression_stat);

`regression_stat` : |

### go_matrix_invertl ()

    gboolean            go_matrix_invertl                   (long double **A,
                                                             int n);

`A` : |
`n` : |
Returns : |