clustered_variance.sql_in

m4_include(`SQLCommon.m4')

/**
@addtogroup grp_clustered_errors

@about

Adjusting standard errors for clustering can be important. For
example, replicating a dataset 100 times should not increase the
precision of parameter estimates. However, performing this procedure
with the IID assumption will actually do this. Another example is in
economics of education research, it is reasonable to expect that the
error terms for children in the same class are not
independent. Clustering standard errors can correct for this.

Assume that the data can be separated into \f$m\f$ clusters. Usually this
can be done by grouping the data table according to one or multiple
columns.

The estimator has a similar form to the usual sandwich estimator
\f[
  S(\vec{c}) = B(\vec{c}) M(\vec{c}) B(\vec{c})
\f]

The bread part is the same as Huber-White sandwich estimator
\f{eqnarray}{
  B(\vec{c}) & = & \left(-\sum_{i=1}^{n} H(y_i, \vec{x}_i,
    \vec{c})\right)^{-1}\\
  & = & \left(-\sum_{i=1}^{n}\frac{\partial^2 l(y_i, \vec{x}_i,
      \vec{c})}{\partial c_\alpha \partial c_\beta}\right)^{-1}
\f}
where \f$H\f$ is the hessian matrix, which is the second derivative of the
target function
\f[
  L(\vec{c}) = \sum_{i=1}^n l(y_i, \vec{x}_i, \vec{c})\ .
\f]

The meat part is different
\f[
  M(\vec{c}) = \bf{A}^T\bf{A}
\f]
where the \f$m\f$-th row of \f$\bf{A}\f$ is
\f[
  A_m = \sum_{i\in G_m}\frac{\partial
      l(y_i,\vec{x}_i,\vec{c})}{\partial \vec{c}}
\f]
where \f$G_m\f$ is the set of rows that belong to the same cluster.

We can compute the quantities of \f$B\f$ and \f$A\f$ for each cluster during one scan through
the data table in an aggregate function. Then sum over all clusters to
the full \f$B\f$ and \f$A\f$ in the outside of the aggregate function. At last, the matrix mulplitications
are
done in a separate function on the master node.

When multinomial logistic regression is computed before the multinomial
clustered variance calculation, it uses a default reference category of zero and the regression coefficients are included in the output table.  The
regression coefficients in the output are in the same order as multinomial
logistic regression function, which is described below.
For a problem with
\f$ K \f$ dependent variables \f$ (1, ..., K) \f$ and \f$ J \f$ categories \f$ (0, ..., J-1)
\f$, let \f$ {m_{k,j}} \f$ denote the coefficient for dependent variable \f$ k
\f$ and  category \f$ j \f$.   The output is \f$ {m_{k_1, j_0}, m_{k_1, j_1}
\ldots m_{k_1, j_{J-1}}, m_{k_2, j_0}, m_{k_2, j_1} \ldots m_{k_K, j_{J-1}}} \f$.
The order is NOT CONSISTENT with the  multinomial regression marginal effect
calculation with function <em>marginal_mlogregr</em>.   This is deliberate
because the interfaces of all multinomial regressions (robust, clustered, ...)
will be moved to match that used in marginal.

@usage

\warning The \b 'groupingCol' input parameter for all clustered functions are a
placeholder, and the  \b 'verbose' parameter is a placeholder for \e clustered_variance_mlogregr. These inputs will be implemented in a future release.

<b> The clustered standard errors for linear regression </b>

For a quick help message, run the following commands for linear regression
<pre>
select madlib.clustered_variance_linregr();
select madlib.clustered_variance_linregr('help');
select madlib.clustered_variance_linregr('?');
select madlib.clustered_variance_linregr('usage');
</pre>

For logistic regression, run the following commands to get short help messages inside psql
<pre>
select madlib.clustered_variance_logregr();
select madlib.clustered_variance_logregr('help');
select madlib.clustered_variance_logregr('?');
select madlib.clustered_variance_logregr('usage');
</pre>

For multinomial logistic regression, run the following commands to get short help messages inside psql
<pre>
select madlib.clustered_variance_mlogregr();
select madlib.clustered_variance_mlogregr('help');
select madlib.clustered_variance_mlogregr('?');
select madlib.clustered_variance_mlogregr('usage');
</pre>

<pre>
SELECT madlib.clustered_variance_linregr (
    <em>'tbl_data'</em>,    -- Data table name
    <em>'tbl_output'</em>,  -- The result table
    <em>'depvar'</em>,      -- An expression used as dependent variable
    <em>'indvar'</em>,      -- An expression used as independent variable
    <em>'clustervar'</em>,  -- The columns used as the cluster variables, separated by comma
    <em>'groupingvar'</em>  -- The columns used as the grouping variables, separated by comma
);
</pre>

<pre>
SELECT madlib.clustered_variance_logregr (
    <em>'tbl_data'</em>,    -- Data table name
    <em>'tbl_output'</em>,  -- The result table
    <em>'depvar'</em>,      -- An expression used as dependent variable
    <em>'indvar'</em>,      -- An expression used as independent variable
    <em>'clustervar'</em>,  -- The columns used as the cluster variables, separated by comma
    <em>'groupingvar'</em>, -- The columns used as the grouping variables, separated by comma
    <em>max_iter</em>,      -- Maximum iteration number for logistic regression, default 20
    <em>'optimizer'</em>,   -- Optimization method for logistic regression, default 'irls'
    <em>tolerance</em>,     -- When difference of likelihoods in two consecutive iterations smaller than
                            -- this value, stops the computation. Default 0.0001
    <em>verbose</em>        -- Whether print detailed information when computing logistic regression,
                            -- default is False
);
</pre>

<pre>
SELECT madlib.clustered_variance_mlogregr (
    <em>'tbl_data'</em>,    -- Data table name
    <em>'tbl_output'</em>,  -- The result table
    <em>'depvar'</em>,      -- An expression used as dependent variable
    <em>'indvar'</em>,      -- An expression used as independent variable
    <em>'clustervar'</em>,  -- The columns used as the cluster variables, separated by comma
    <em>ref_category</em>,  -- Reference category in the range of [0, num_category)
    <em>'groupingvar'</em>, -- The columns used as the grouping variables, separated by comma
    <em>max_iter</em>,      -- Maximum iteration number for logistic regression, default 20
    <em>'optimizer'</em>,   -- Optimization method for logistic regression, default 'irls'
    <em>tolerance</em>,     -- When difference of likelihoods in two consecutive iterations smaller than
                            -- this value, stops the computation. Default 0.0001
    <em>verbose</em>        -- Whether print detailed information when computing logistic regression,
                            -- default is False
);
</pre>

@examp

Note that we need to manually include an intercept term in the independent variable expression. The NULL value of <em>groupingvar</em> means that there is no grouping in the calculation.

@verbatim
sql> drop table if exists tbl_output;
sql> select madlib.clustered_variance_linregr ('abalone', 'tbl_output', 'rings', 'array[1, diameter, length, width]', 'sex', NULL);
sql> select * from tbl_output;
sql> ----------------------------------------------
sql> drop table if exists tbl_output;
sql> select madlib.clustered_variance_logregr ('abalone', 'tbl_output', 'rings < 10', 'array[1, diameter, length, width]', 'sex');
sql> select * from tbl_output;
sql> ----------------------------------------------
sql> drop table if exists tbl_output;
sql> select madlib.clustered_variance_mlogregr ('abalone', 'tbl_output', 'case when rings < 10 then 1 else 0 end', 'array[1, diameter, length, width]',  'sex', 0);
sql> select * from tbl_output;
@endverbatim

@literature

[1] Standard, Robust, and Clustered Standard Errors Computed in R, http://diffuseprior.wordpress.com/2012/06/15/standard-robust-and-clustered-standard-errors-computed-in-r/

@sa File clustered_variance.sql_in documenting the SQL function

@internal
@sa Namespace \ref madlib::modules::regress
    documenting the implementation in C++
@endinternal
*/

------------------------------------------------------------------------

/**
 * @brief Compute the clustered errors
 *
 * @param tbl_data Data table name
 * @param tbl_output The result table
 * @param depvar Dependent variable expression
 * @param indvar Independent variable expression
 * @param clustervar The expressions used to clustering
 * @param grouping_col The names of grouping columns
 * @param coef Optional, the fitting coefficients
 */

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_linregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    grouping_col    TEXT
) RETURNS VOID AS $$
    PythonFunction(regress, clustered_variance, clustered_variance_linregr)
$$ LANGUAGE plpythonu;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_linregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_linregr(tbl_data, tbl_output, depvar, indvar, clustervar, NULL);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

-- print quick help messages
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_linregr (
) RETURNS TEXT AS $$
    PythonFunction(regress, clustered_variance, clustered_variance_linregr_help)
$$ LANGUAGE plpythonu;

------------------------------------------------------------------------

-- print quick help messages
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_linregr (
    msg         TEXT
) RETURNS TEXT AS $$
    PythonFunction(regress, clustered_variance, clustered_variance_linregr_help)
$$ LANGUAGE plpythonu;

------------------------------------------------------------------------
-- Aggregate function --

CREATE TYPE MADLIB_SCHEMA.__clustered_agg_result AS (
    meatvec     DOUBLE PRECISION[],
    breadvec    DOUBLE PRECISION[]
);

------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_err_lin_transition (
    state MADLIB_SCHEMA.bytea8,
    y DOUBLE PRECISION,
    x DOUBLE PRECISION[],
    coef DOUBLE PRECISION[]
) RETURNS MADLIB_SCHEMA.bytea8 AS
    'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;

------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_err_lin_merge (
    state1 MADLIB_SCHEMA.bytea8,
    state2 MADLIB_SCHEMA.bytea8
) RETURNS MADLIB_SCHEMA.bytea8 AS
    'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;

------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_err_lin_final (
    state MADLIB_SCHEMA.bytea8
) RETURNS MADLIB_SCHEMA.__clustered_agg_result AS
    'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;

------------------------

CREATE AGGREGATE MADLIB_SCHEMA.__clustered_err_lin_step (
    /* depvar   */      DOUBLE PRECISION,
    /* indvar   */      DOUBLE PRECISION[],
    /* coef     */      DOUBLE PRECISION[]) (
    m4_ifdef(`__GREENPLUM__', `prefunc=MADLIB_SCHEMA.__clustered_err_lin_merge,')
    SFUNC = MADLIB_SCHEMA.__clustered_err_lin_transition,
    STYPE = MADLIB_SCHEMA.bytea8,
    FINALFUNC = MADLIB_SCHEMA.__clustered_err_lin_final,
    INITCOND = ''
);

------------------------------------------------------------------------

CREATE TYPE MADLIB_SCHEMA.__clustered_lin_result AS (
    coef      DOUBLE PRECISION[],
    std_err   DOUBLE PRECISION[],
    t_stats   DOUBLE PRECISION[],
    p_values  DOUBLE PRECISION[]
);

-- Compute the t-stats and p-values
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_lin_compute_stats (
    coef                DOUBLE PRECISION[],
    meatvec             DOUBLE PRECISION[],
    breadvec            DOUBLE PRECISION[],
    mcluster            INTEGER,
    numRows             INTEGER
) RETURNS MADLIB_SCHEMA.__clustered_lin_result AS
    'MODULE_PATHNAME', 'clustered_lin_compute_stats'
LANGUAGE C IMMUTABLE STRICT;

------------------------------------------------------------------------
------------------------------------------------------------------------

-- Supporting PostgreSQL sum over array
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__array_add (
    x                   DOUBLE PRECISION[],
    y                   DOUBLE PRECISION[]
) RETURNS DOUBLE PRECISION[] AS $$
DECLARE
    a int;
    b int;
    i int;
    res double precision[];
BEGIN
    res = x;

    a := array_lower (y, 1);
    b := array_upper (y, 1);

    IF a IS NOT NULL THEN
      FOR i IN a .. b LOOP
        res[i] := coalesce(res[i],0) + y[i];
      END LOOP;
    END IF;

    RETURN res;
END;
$$ LANGUAGE plpgsql STRICT IMMUTABLE;

CREATE AGGREGATE MADLIB_SCHEMA.__array_sum (
    /* x */             DOUBLE PRECISION[]
) (
    SFunc = MADLIB_SCHEMA.__array_add,
    SType = DOUBLE PRECISION[],
    m4_ifdef(`__GREENPLUM__', `prefunc = MADLIB_SCHEMA.__array_add,')
    InitCond = '{}'
);

------------------------------------------------------------------------
------------------------------------------------------------------------
-- Logistic clustered standard errors
------------------------------------------------------------------------
------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_logregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    grouping_col    TEXT,
    max_iter        INTEGER,
    optimizer       TEXT,
    tolerance       DOUBLE PRECISION,
    verbose         BOOLEAN
) RETURNS VOID AS $$
    PythonFunction(regress, clustered_variance, clustered_variance_logregr)
$$ LANGUAGE plpythonu;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_logregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_logregr(tbl_data, tbl_output, depvar, indvar, clustervar,
                                                    NULL, 20, 'irls', 0.0001, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_logregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    grouping_col    TEXT
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_logregr(tbl_data, tbl_output, depvar, indvar, clustervar,
                                                    grouping_col, 20, 'irls', 0.0001, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_logregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    grouping_col    TEXT,
    max_iter        INTEGER
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_logregr(tbl_data, tbl_output, depvar, indvar, clustervar,
                                                    grouping_col, max_iter, 'irls', 0.0001, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_logregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    grouping_col    TEXT,
    max_iter        INTEGER,
    optimizer       TEXT
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_logregr(tbl_data, tbl_output, depvar, indvar, clustervar,
                                                    grouping_col, max_iter, optimizer, 0.0001, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_logregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    grouping_col    TEXT,
    max_iter        INTEGER,
    optimizer       TEXT,
    tolerance       DOUBLE PRECISION
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_logregr(tbl_data, tbl_output, depvar, indvar, clustervar,
                                                    grouping_col, max_iter, optimizer, tolerance, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

-- print quick help messages
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_logregr (
) RETURNS TEXT AS $$
    PythonFunction(regress, clustered_variance, clustered_variance_logregr_help)
$$ LANGUAGE plpythonu;

------------------------------------------------------------------------

-- print quick help messages
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_logregr (
    msg         TEXT
) RETURNS TEXT AS $$
    PythonFunction(regress, clustered_variance, clustered_variance_logregr_help)
$$ LANGUAGE plpythonu;

------------------------------------------------------------------------
-- Aggregate function --

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_err_log_transition (
    state MADLIB_SCHEMA.bytea8,
    y BOOLEAN,
    x DOUBLE PRECISION[],
    coef DOUBLE PRECISION[]
) RETURNS MADLIB_SCHEMA.bytea8 AS
    'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;

------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_err_log_merge (
    state1 MADLIB_SCHEMA.bytea8,
    state2 MADLIB_SCHEMA.bytea8
) RETURNS MADLIB_SCHEMA.bytea8 AS
    'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;

------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_err_log_final (
    state MADLIB_SCHEMA.bytea8
) RETURNS MADLIB_SCHEMA.__clustered_agg_result AS
    'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;

------------------------

CREATE AGGREGATE MADLIB_SCHEMA.__clustered_err_log_step (
    /* depvar   */      BOOLEAN,
    /* indvar   */      DOUBLE PRECISION[],
    /* coef     */      DOUBLE PRECISION[]) (
    m4_ifdef(`__GREENPLUM__', `prefunc=MADLIB_SCHEMA.__clustered_err_log_merge,')
    SFUNC = MADLIB_SCHEMA.__clustered_err_log_transition,
    STYPE = MADLIB_SCHEMA.bytea8,
    FINALFUNC = MADLIB_SCHEMA.__clustered_err_log_final,
    INITCOND = ''
);

------------------------------------------------------------------------

CREATE TYPE MADLIB_SCHEMA.__clustered_log_result AS (
    coef      DOUBLE PRECISION[],
    std_err   DOUBLE PRECISION[],
    z_stats   DOUBLE PRECISION[],
    p_values  DOUBLE PRECISION[]
);

-- Compute the t-stats and p-values
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_log_compute_stats (
    coef                DOUBLE PRECISION[],
    meatvec             DOUBLE PRECISION[],
    breadvec            DOUBLE PRECISION[],
    mcluster            INTEGER,
    numRows             INTEGER
) RETURNS MADLIB_SCHEMA.__clustered_log_result AS
    'MODULE_PATHNAME', 'clustered_log_compute_stats'
LANGUAGE C IMMUTABLE STRICT;


------------------------------------------------------------------------
------------------------------------------------------------------------
-- Multi-Logistic clustered standard errors
------------------------------------------------------------------------
------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_mlogregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    ref_category    INTEGER,
    grouping_col    TEXT,
    max_iter        INTEGER,
    optimizer       TEXT,
    tolerance       DOUBLE PRECISION,
    verbose         BOOLEAN
) RETURNS VOID AS $$
    PythonFunction(regress, clustered_variance, clustered_variance_mlogregr)
$$ LANGUAGE plpythonu;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_mlogregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_mlogregr(tbl_data, tbl_output, depvar, indvar, clustervar, 0,
                                                    NULL, 20, 'irls', 0.0001, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_mlogregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    ref_category    INTEGER
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_mlogregr(tbl_data, tbl_output, depvar, indvar, clustervar, ref_category,
                                                    NULL, 20, 'irls', 0.0001, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_mlogregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    ref_category    INTEGER,
    grouping_col    TEXT
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_mlogregr(tbl_data, tbl_output, depvar, indvar, clustervar, ref_category,
                                                    grouping_col, 20, 'irls', 0.0001, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_mlogregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    ref_category    INTEGER,
    grouping_col    TEXT,
    max_iter        INTEGER
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_mlogregr(tbl_data, tbl_output, depvar, indvar, clustervar, ref_category,
                                                    grouping_col, max_iter, 'irls', 0.0001, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_mlogregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    ref_category    INTEGER,
    grouping_col    TEXT,
    max_iter        INTEGER,
    optimizer       TEXT
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_mlogregr(tbl_data, tbl_output, depvar, indvar, clustervar, ref_category,
                                                    grouping_col, max_iter, optimizer, 0.0001, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_mlogregr (
    tbl_data        TEXT,
    tbl_output      TEXT,
    depvar          TEXT,
    indvar          TEXT,
    clustervar      TEXT,
    ref_category    INTEGER,
    grouping_col    TEXT,
    max_iter        INTEGER,
    optimizer       TEXT,
    tolerance       DOUBLE PRECISION
) RETURNS VOID AS $$
BEGIN
    PERFORM MADLIB_SCHEMA.clustered_variance_mlogregr(tbl_data, tbl_output, depvar, indvar, clustervar, ref_category,
                                                    grouping_col, max_iter, optimizer, tolerance, False);
END;
$$ LANGUAGE plpgsql;

------------------------------------------------------------------------

-- print quick help messages
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_mlogregr (
) RETURNS TEXT AS $$
    PythonFunction(regress, clustered_variance, clustered_variance_mlogregr_help)
$$ LANGUAGE plpythonu;

------------------------------------------------------------------------

-- print quick help messages
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.clustered_variance_mlogregr (
    msg         TEXT
) RETURNS TEXT AS $$
    PythonFunction(regress, clustered_variance, clustered_variance_mlogregr_help)
$$ LANGUAGE plpythonu;

------------------------------------------------------------------------
-- Aggregate function --

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_err_mlog_transition (
    state MADLIB_SCHEMA.bytea8,
    y INTEGER,
    x DOUBLE PRECISION[],
    coef DOUBLE PRECISION[],
    num_cat INTEGER,
    ref_cat INTEGER
) RETURNS MADLIB_SCHEMA.bytea8 AS
    'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;

------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_err_mlog_merge (
    state1 MADLIB_SCHEMA.bytea8,
    state2 MADLIB_SCHEMA.bytea8
) RETURNS MADLIB_SCHEMA.bytea8 AS
    'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;

------------------------

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_err_mlog_final (
    state MADLIB_SCHEMA.bytea8
) RETURNS MADLIB_SCHEMA.__clustered_agg_result AS
    'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;

------------------------

CREATE AGGREGATE MADLIB_SCHEMA.__clustered_err_mlog_step (
    /* depvar   */      INTEGER,
    /* indvar   */      DOUBLE PRECISION[],
    /* coef     */      DOUBLE PRECISION[],
    /* num_cat */       INTEGER,
    /* reference_cat */ INTEGER) (
    m4_ifdef(`__GREENPLUM__', `prefunc=MADLIB_SCHEMA.__clustered_err_mlog_merge,')
    SFUNC = MADLIB_SCHEMA.__clustered_err_mlog_transition,
    STYPE = MADLIB_SCHEMA.bytea8,
    FINALFUNC = MADLIB_SCHEMA.__clustered_err_mlog_final,
    INITCOND = ''
);

------------------------------------------------------------------------

CREATE TYPE MADLIB_SCHEMA.__clustered_mlog_result AS (
    coef      DOUBLE PRECISION[],
    std_err   DOUBLE PRECISION[],
    z_stats   DOUBLE PRECISION[],
    p_values  DOUBLE PRECISION[]
);

-- Compute the t-stats and p-values
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__clustered_mlog_compute_stats (
    coef                DOUBLE PRECISION[],
    meatvec             DOUBLE PRECISION[],
    breadvec            DOUBLE PRECISION[],
    mcluster            INTEGER,
    numRows             INTEGER
) RETURNS MADLIB_SCHEMA.__clustered_mlog_result AS
    'MODULE_PATHNAME', 'clustered_mlog_compute_stats'
LANGUAGE C IMMUTABLE STRICT;