"""@file matrix_ops.py_in

@brief Help message functions for all matrix operations

@namespace linalg
"""


matrix_arg_str = """
------------------------------------------------------------
                    MATRIX ARGUMENTS
------------------------------------------------------------
A string containing multiple named arguments of the form "name=value".
This argument is used as a container for multiple parameters related to a single
matrix.

The following parameters are supported for this string argument:
    - row: (Default: 'row_num') Name of the column containing row index of the matrix.
    - col: (Default: 'col_num') Name of the column containing column index of the matrix.
    - val: (Default: 'val') Name of the column containing the entries of the matrix.
                            For a dense matrix, this should be of an ARRAY type.

These string arguments can be NULL if the default values are to be used.

If not provided, 'out_args' uses same value as the first input args.
'out_args' can also include an additional formatting argument:
    - fmt: The format (dense/sparse) for output matrix. If not specified output
            format is inferred from the format of input.
"""

output_str = """
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output table ('matrix_r' above) has the following columns
-- Dense format
    '{row}'       -- Row index for each row of the matrix
    '{val}'       -- Each row vector

-- Sparse format
    '{row}'        -- Row index for each element
    '{col}'        -- Column index for each element
    '{val}'        -- Value for each element

The column names in {} are set using the options provided in 'out_args'.
"""


def _get_help_message(schema_madlib, message, function_name, functionality_str,
                      usage_str, **kwargs):
    format_dict = dict(locals().items() + globals().items())
    if not message:
        help_string = """
------------------------------------------------------------
                        SUMMARY
------------------------------------------------------------
Functionality: {functionality_str}

For more details on the function usage:
    SELECT {schema_madlib}.{function_name}('usage');
For more details on the two input formats (dense or sparse):
    SELECT {schema_madlib}.matrix_info();
        """
    elif message.lower().strip() in ['usage', 'help', '?']:
        help_string = usage_str
    else:
        help_string = "No such option. Use {schema_madlib}.{function_name}('usage')"
    return help_string.format(**format_dict)


def matrix_info_help_message(schema_madlib, message, **kwargs):
    """
    Args:
        @param schema_madlib
        @param message
        @param kwargs

    Returns:
        STR.
    """
    message = message.lower()
    if not message:
        help_string = """
            Run "SELECT matrix_info('dense');" or "SELECT matrix_info('sparse');"
            for examples of the specific data format.
        """
    elif message == 'dense':
        help_string = """
A dense matrix is represented as a distributed collection of 1-D arrays.
An example 3x10 matrix would be the below table:

 row_id |         row_vec
--------+-------------------------
   1    | {{9,6,5,8,5,6,6,3,10,8}}
   2    | {{8,2,2,6,6,10,2,1,9,9}}
   3    | {{3,9,9,9,8,6,3,9,5,6}}

The column names above can be user-defined - the matrix functions provide options
to input these column names. The default names expected are 'row_num' and 'val'.
"""
    elif message == 'sparse':
        help_string = """
A sparse matrix is represented using the row and column indices for each
non-zero entry of the matrix. This representation is useful for sparse matrices,
containing multiple zero elements. Given below is an example of a sparse 4x7 matrix
with just 6 out of 28 entries being non-zero.

Note: There should be exactly one tuple that has a NULL for the '<em>value</em>'
column. This tuple gives the dimensionality of the sparse matrix (the
dimensionality cannot be determined just by the entries since the last
row/column could have all zeros).

 row_id | col_id | value
--------+--------+-------
      1 |      1 |     9
      1 |      5 |     6
      1 |      7 |     6
      2 |      1 |     8
      3 |      1 |     3
      3 |      2 |     9
      4 |      7 |     0
(6 rows)

The column names above can be user-defined - the matrix functions provide options
to input these column names. The default names expected are 'row_num', 'col_num'
and 'val'.
    """
    else:
        help_string = "No such option. Use {schema_madlib}.matrix_add('usage')"
    return help_string.format(schema_madlib=schema_madlib)
# ----------------------------------------------------------------------


def matrix_identity_help_message(schema_madlib, message, **kwargs):
    """ Help message for Create an identity matrix
    """
    functionality_str = "Create a square identity matrix of specified dimension"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_identity(
    dim             -- Integer specifying the dimensionality of output.
    'matrix_out'    -- Name of the table to store result matrix
    'out_args'      -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_identity",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_diag_help_message(schema_madlib, message, **kwargs):
    """ Help message for Creating a diagonal matrix
    """
    functionality_str = "Create a diagonal matrix using provided diagonal elements"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_diag(
    diag_elements   -- The array containing diagonal elements.
    'matrix_out'    -- Name of output matrix.
    'out_args'      -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
        """

    return _get_help_message(schema_madlib, message, "matrix_diag",
                             functionality_str, usage_str)
# ------------------------------------------------------------------------------


def matrix_extract_diag_help_message(schema_madlib, message, **kwargs):
    """ Help message for main diagonal of the matrix
    """
    functionality_str = "Extract the main diagonal of a square matrix."
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------
SELECT {schema_madlib}.matrix_extract_diag(
    'matrix_in'     -- Name of the table containing input matrix
    'in_args'       -- String argument containing matrix_in arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}

------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is an array containing the main diagonal.
        """

    return _get_help_message(schema_madlib, message, "matrix_extract_diag",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_add_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix addition
    """
    functionality_str = "Compute addition of two matrices"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_add(
    'matrix_a',     -- Name of the table containing 1st matrix
    'a_args',       -- String argument containing matrix_a specific arguments
                    --     (see matrix arguments below for options)
    'matrix_b',     -- Name of the table containing 2nd matrix
    'b_args',       -- String argument containing matrix_b specific arguments
                    --     (see matrix arguments below for options)
    'matrix_out'    -- Name of the table to store result matrix
    'out_args',     -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_add",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_zeros_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix initialization with zeros
    """
    functionality_str = "Create a matrix with all elements set to zero"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------
SELECT {schema_madlib}.matrix_zeros(
    row_dim,        -- The number of row of matrix initialized with zeros
    col_dim,        -- The number of column of matrix initialized with zeros
    'matrix_out'    -- Name of the table to store result matrix
    'out_args',     -- String argument containing matrix_out specific arguments
                    -- (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_zeros",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_ones_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix initialization with ones
    """
    functionality_str = "Create a matrix with all elements set to one"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------
SELECT {schema_madlib}.matrix_ones(
    row_dim,        -- The row dimension of output matrix
    col_dim,        -- The column dimension of output matrix
    'matrix_out'    -- Name of output matrix
    'out_args',     -- String argument containing matrix_out specific arguments
                    -- (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
    """
    return _get_help_message(schema_madlib, message, "matrix_ones",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_sub_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix subtraction
    """
    functionality_str = "Compute subtraction of two matrices"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_sub(
    'matrix_a',     -- Name of the table containing 1st matrix
    'a_args',       -- String argument containing matrix_a specific arguments
                    --     (see matrix arguments below for options)
    'matrix_b',     -- Name of the table containing 2nd matrix
    'b_args',       -- String argument containing matrix_b specific arguments
                    --     (see matrix arguments below for options)
    'matrix_out'    -- Name of the table to store result matrix
    'out_args',     -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_sub",
                             functionality_str, usage_str)
# ------------------------------------------------------------

def matrix_ndims_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix dimension
    """
    if not message:
        help_string = """
------------------------------------------------------------
                        SUMMARY
------------------------------------------------------------
Functionality: Matrix dimension information

This function provides dimension information of a matrix either in dense or sparse format.

For more details on the function usage:
    SELECT {schema_madlib}.matrix_ndims('usage');
For more details on the two input formats (dense or sparse):
    SELECT {schema_madlib}.matrix_info();
        """
    elif message.lower().strip() in ['usage', 'help', '?']:
        help_string = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_ndims(
    'matrix_in',    -- Name of the table containing input matrix
    'in_args',      -- String argument containing matrix_in arguments
                    --     (see matrix arguments below for options)
    'is_block'      -- where the table is in block format
);

------------------------------------------------------------
                    MATRIX ARGUMENTS
------------------------------------------------------------
A string containing multiple named arguments of the form "name=value".
This argument is used as a container for multiple parameters related to a single
matrix.

The following parameters are supported for this string argument:
    row: (Default: 'row_num') Name of the column containing row index of the matrix.
    col: (Default: 'col_num') Name of the column containing column index of the matrix.
    val: (Default: 'val') Name of the column containing the entries of the matrix.
                          For a dense matrix, this should be of an ARRAY type.

These string arguments can be NULL if the default values are to be used.

If not provided, out_args uses same value as in_args.

------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
        An array with matrix_in dimension information in format of (number of rows,number of columns)
        """
    else:
        help_string = "No such option. Use {schema_madlib}.matrix_trans('usage')"
    return help_string.format(schema_madlib=schema_madlib)
# ------------------------------------------------------------------------------


def matrix_elem_mult_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix multiplication by element
    """
    functionality_str = "Compute element-wise multiplication of two matrices"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_elem_mult(
    'matrix_a',     -- Name of the table containing 1st matrix
    'a_args',       -- String argument containing matrix_a specific arguments
                    --     (see matrix arguments below for options)
    'matrix_b',     -- Name of the table containing 2nd matrix
    'b_args',       -- String argument containing matrix_b specific arguments
                    --     (see matrix arguments below for options)
    'matrix_out'    -- Name of the table to store result matrix
    'out_args',     -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_elem_mult",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_mult_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix Multiplicationn
    """
    functionality_str = "Compute multiplication of two matrices"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_mult(
    'matrix_a',     -- Name of the table containing 1st matrix
    'a_args',       -- String argument containing matrix_a specific arguments
                    --     (see matrix arguments below for options)
    'matrix_b',     -- Name of the table containing 2nd matrix
    'b_args',       -- String argument containing matrix_b specific arguments
                    --     (see matrix arguments below for options)
    'matrix_out'    -- Name of the table to store result matrix
    'out_args',     -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_mult",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_trans_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix transposition
    """
    functionality_str = "Compute transpose of a matrix"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_trans(
    'matrix_in',     -- Name of the table containing the matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                    --     (see matrix arguments below for options)
    'matrix_out'    -- Name of the table to store result matrix
    'out_args',     -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_trans",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_extract_row_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix row extraction
    """
    functionality_str = "Extract row from a matrix"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_extract_row(
    'matrix_in',    -- Name of the table containing input matrix
    'in_args',      -- String argument containing matrix_in specific arguments
                    --     (see matrix arguments below for options)
    'index'         -- Index of the desired row
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_extract_row",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_extract_col_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix column extraction
    """
    functionality_str = "Extract col from a matrix"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_extract_col(
    'matrix_in',    -- Name of the table containing input matrix
    'in_args',      -- String argument containing matrix_in specific arguments
                    --     (see matrix arguments below for options)
    'index'         -- Index of the desired col
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_extract_col",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def _min_max_help_message(schema_madlib, message, suffix, **kwargs):
    """ Common help message for Matrix min and max
    """
    functionality_str = "Compute {0} along a specified dimension".format(suffix)
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {1}.matrix_{0}(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'dim'            -- Dimension. Should either be 1 or 2. This value indicates
                        the dimension to operate along i.e. whose length reduces
                        to 1 in the result
    'matrix_r'       -- Name of the table to store result matrix
    'fetch_index'    -- If true, corresponding index of each {0} value is returned
);

{{matrix_arg_str}}

------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output table ('matrix_r' above) has the following columns

    '{0}'       -- Vector of ordered {0} values
    'index'     -- Vector of ordered corresponding indices of {0} values
        """.format(suffix, schema_madlib)
    return _get_help_message(schema_madlib, message, "matrix_" + suffix,
                             functionality_str, usage_str)


def matrix_max_help_message(schema_madlib, message, **kwargs):
    return _min_max_help_message(schema_madlib, message, 'max')


def matrix_min_help_message(schema_madlib, message, **kwargs):
    return _min_max_help_message(schema_madlib, message, 'min')
# ------------------------------------------------------------

def matrix_norm_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix norm
    """
    if not message:
        help_string = """
------------------------------------------------------------
                        SUMMARY
------------------------------------------------------------
Functionality: Matrix norm

This function computes matrix norm values either in dense or sparse format.

For more details on the function usage:
    SELECT {schema_madlib}.matrix_norm('usage');
For more details on the two input formats (dense or sparse):
    SELECT {schema_madlib}.matrix_info();
        """
    elif message.lower().strip() in ['usage', 'help', '?']:
        help_string = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_norm(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'norm_type'      -- Optional, default 'fro'. It supports
                        'one' or 'o'                1 norm
                        <float(>0)>                 element-wise norm
                        'inf' or 'i'                infinite norm
                        'max' or 'm'                max absolute value norm
                        'fro' or 'f'                F norm
);

------------------------------------------------------------
                    MATRIX ARGUMENTS
------------------------------------------------------------
A string containing multiple named arguments of the form "name=value".
This argument is used as a container for multiple parameters related to a single
matrix.

The following parameters are supported for this string argument:
    - row: (Default: 'row_num') Name of the column containing row index of the matrix.
    - col: (Default: 'col_num') Name of the column containing column index of the matrix.
    - val: (Default: 'val') Name of the column containing the entries of the matrix.
                            For a dense matrix, this should be of an ARRAY type.

These string arguments can be NULL if the default values are to be used.

------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is a value which computes matrix norm.
        """
    else:
        help_string = "No such option. Use {schema_madlib}.matrix_norm('usage')"
    return help_string.format(schema_madlib=schema_madlib)
# ------------------------------------------------------------

def _agg_help_message(schema_madlib, message, suffix, **kwargs):
    """ Common help message for aggregate operations on Matrix
    """
    functionality_str = "Compute the {0} along a specific dimension".format(suffix)

    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {1}.matrix_{0}(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'dim'            -- Dimension. Should either be 1 or 2. This value indicates
                        the dimension to operate along i.e. whose length reduces
                        to 1 in the result
);

{{matrix_arg_str}}

------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is a vector containing the {0} along given dimension.
        """.format(suffix, schema_madlib)
    return _get_help_message(schema_madlib, message, "matrix_" + suffix,
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_sum_help_message(schema_madlib, message, **kwargs):
    return _agg_help_message(schema_madlib, message, "sum")


def matrix_mean_help_message(schema_madlib, message, **kwargs):
    return _agg_help_message(schema_madlib, message, "mean")


def matrix_scalar_mult_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix scalar multiply
    """
    functionality_str = "Compute multiplication of matrix with a scalar"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------
SELECT {schema_madlib}.matrix_scalar_mult(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'scalar'         -- Scalar value used to be multiplied with matrix_in
    'matrix_out',    -- Name of the table containing result
    'out_args',      -- String argument containing matrix_out specific arguments
                     --    (see matrix arguments below for options)
);

{matrix_arg_str}
{output_str}
        """
    return _get_help_message(schema_madlib, message, "matrix_scalar_mult",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_vec_mult_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix vector multiply
    """
    functionality_str = "Compute multiplication of matrix with a vector"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_vec_mult(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'vector'         -- Vector value used to be multiplied with matrix_in
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is an array representing the result of the vector multiplication.
        """
    return _get_help_message(schema_madlib, message, "matrix_vec_mult",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_eigen_help_message(schema_madlib, message, **kwargs):
    """ Help message for Matrix eigen values extraction
    """
    functionality_str = "Extract eigen values of matrix"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_eigen(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'matrix_out'     -- Name of the table to store result matrix
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output are eigen values of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_eigen",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_pinv_help_message(schema_madlib, message, **kwargs):
    """ Help message for generic inverse of matrix
    """
    functionality_str = "Generic inverse of matrix"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_pinv(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'matrix_out',    -- Name of the table to store result matrix
    'out_args'       -- String argument containing matrix_out specific arguments
                     --    (see matrix arguments below for options)
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is generic inverse of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_pinv",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_cholesky_help_message(schema_madlib, message, **kwargs):
    """ Help message for cholesky decomposition of matrix
    """
    functionality_str = "Matrix cholesky decomposition"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_cholesky(
    'matrix_in',        -- Name of the table containing input matrix
    'in_args',          -- String argument containing matrix_in specific arguments
                        --    (see matrix arguments below for options)
    'matrix_out_prefix' -- Name prefix of the table to store result matrix L
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is cholesky decomposition of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_cholesky",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_qr_help_message(schema_madlib, message, **kwargs):
    """ Help message for QR decomposition of matrix
    """
    functionality_str = "Matrix QR decomposition"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_qr(
    'matrix_in',            -- Name of the table containing input matrix
    'in_args',              -- String argument containing matrix_in specific arguments
                            --    (see matrix arguments below for options)
    'matrix_out_prefix',    -- Name prefix of the table to store result matrix
    'out_args'              -- String argument containing matrix_r specific arguments
                            --    (see matrix arguments below for options)
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is QR decomposition of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_qr",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_lu_help_message(schema_madlib, message, **kwargs):
    """ Help message for LU decomposition of matrix
    """
    functionality_str = "Matrix LU decomposition"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_lu(
    'matrix_in',            -- Name of the table containing input matrix
    'in_args',              -- String argument containing matrix_in specific arguments
                            --    (see matrix arguments below for options)
    'matrix_out_prefix',    -- Name of the table to store result matrix P
    'out_args'              -- String argument containing matrix_p specific arguments
                            --    (see matrix arguments below for options)
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is LU decomposition of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_lu",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_nuclear_norm_help_message(schema_madlib, message, **kwargs):
    """ Help message for computing nuclear norm of matrix
    """
    functionality_str = "Matrix nuclear norm computing"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_nuclear_norm(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is nuclear norm computing of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_nuclear_norm",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_rank_help_message(schema_madlib, message, **kwargs):
    """ Help message for computing rank of matrix
    """
    functionality_str = "Matrix rank computing"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_rank(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is rank computing of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_rank",
                             functionality_str, usage_str)
# ------------------------------------------------------------


def matrix_inverse_help_message(schema_madlib, message, **kwargs):
    """ Help message for computing inverse of matrix
    """
    functionality_str = "Matrix inverse computing"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_inverse(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'matrix_out'    -- Name of the table to store result matrix
    'out_args'      -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is inverse of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_inverse",
                             functionality_str, usage_str)
# ------------------------------------------------------------

def matrix_sparsify_help_message(schema_madlib, message, **kwargs):
    """ Help message for sparsifying a matrix
    """
    functionality_str = "Matrix sparsify"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_sparsify(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'matrix_out'    -- Name of the table to store result matrix
    'out_args'      -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is the sparse version of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_sparsify",
                             functionality_str, usage_str)
# ------------------------------------------------------------

def matrix_densify_help_message(schema_madlib, message, **kwargs):
    """ Help message for densifying a matrix
    """
    functionality_str = "Matrix densify"
    usage_str = """
------------------------------------------------------------
                        USAGE
------------------------------------------------------------

SELECT {schema_madlib}.matrix_densify(
    'matrix_in',     -- Name of the table containing input matrix
    'in_args',       -- String argument containing matrix_in specific arguments
                     --    (see matrix arguments below for options)
    'matrix_out'    -- Name of the table to store result matrix
    'out_args'      -- String argument containing matrix_out specific arguments
                    --     (see matrix arguments below for options)
);

{matrix_arg_str}
------------------------------------------------------------
                        OUTPUT
------------------------------------------------------------
The output is the dense version of the matrix.
        """
    return _get_help_message(schema_madlib, message, "matrix_densify",
                             functionality_str, usage_str)
# ------------------------------------------------------------