| /* ----------------------------------------------------------------------- *//** |
| * |
| * @file matrix_ops.sql_in |
| * |
| * @brief Implementation of matrix operations in SQL |
| * @date April 2011 |
| * |
| * |
| *//* ----------------------------------------------------------------------- */ |
| |
| m4_include(`SQLCommon.m4') |
| |
| /** |
| @addtogroup grp_matrix |
| |
| <div class="toc"><b>Contents</b> |
| <ul> |
| <li class="level1"><a href="#description">Description</a></li> |
| <li class="level1"><a href="#operations">Matrix Operations</a></li> |
| <li class="level1"><a href="#arguments">Arguments</a></li> |
| <li class="level1"><a href="#examples">Examples</a></li> |
| <li class="level1"><a href="#related">Related Topics</a></li> |
| </ul> |
| </div> |
| |
| @anchor description |
| @brief Provides fast matrix operations supporting other MADlib modules. |
| |
| This module provides a set of basic matrix operations for matrices that are |
| too big to fit in memory. We provide two storage formats for a matrix: |
| |
| - <b>Dense</b>: The matrix is represented as a distributed collection of 1-D arrays. |
| An example 3x10 matrix would be the table below: |
| <pre> |
| 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} |
| </pre> |
| |
| A '<em>row</em>' column (called <em>row_id</em> above) provides the row |
| number of each row and a '<em>val</em>' column (called <em>row_vec</em> |
| above) provides each row as an array. <b>The <em>row</em> column should contain a |
| series of integers from 1 to <em>N</em> with no duplicates, |
| where <em>N</em> is the row dimensionality</b>. |
| |
| - <b>Sparse</b>: The 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. The dimensionality of the matrix is |
| inferred using the max value in <em>row</em> and <em>col</em> columns. Note the |
| last entry is included (even though it is 0) to provide the dimensionality of the |
| matrix, indicating that the 4th row and 7th column contain all zeros. |
| <pre> |
| row_id | col_id | value |
| --------+--------+------- |
| 1 | 1 | 9 |
| 1 | 5 | 6 |
| 1 | 6 | 6 |
| 2 | 1 | 8 |
| 3 | 1 | 3 |
| 3 | 2 | 9 |
| 4 | 7 | 0 |
| (6 rows) |
| </pre> |
| |
| <b>For sparse matrices, the <em>row</em> and <em>col</em> columns together should not |
| contain a duplicate entry and the <em>val</em> column should be of scalar |
| (non-array) data type</b>. |
| <br> |
| For comparison, the dense representation of this matrix is shown below. Note the |
| dimensionality of the dense matrix is 4 x 7 since the max value of <em>row</em> |
| and <em>col</em> is 4 and 7 respectively, leading to all zeros in the last row |
| and last column. |
| |
| <pre> |
| row_id | row_vec |
| --------+------------------------- |
| 1 | {9,0,0,0,6,6,0} |
| 2 | {8,0,0,0,0,0,0} |
| 3 | {3,9,0,0,0,0,0} |
| 4 | {0,0,0,0,0,0,0} |
| </pre> |
| |
| @note The functions below support several numeric types (unless otherwise noted) |
| including SMALLINT, INTEGER, BIGINT, DOUBLE PRECISION (FLOAT8), NUMERIC |
| (internally casted into FLOAT8, so loss of precision can happen). |
| |
| @anchor operations |
| @par Matrix Operations |
| |
| Below are the supported matrix operations. The meaning of the arguments |
| and other terms are common to all functions and are provided at the end of the list |
| in the glossary of arguments. |
| |
| - \b Representation |
| <pre class="syntax"> |
| -- Convert to sparse representation |
| <b>matrix_sparsify</b>( matrix_in, in_args, matrix_out, out_args) |
| |
| -- Convert to dense representation |
| <b>matrix_densify</b>( matrix_in, in_args, matrix_out, out_args) |
| |
| -- Get dimensions of matrix |
| <b>matrix_ndims</b>( matrix_in, in_args ) |
| </pre> |
| |
| - <b>Mathematical operations</b> |
| <pre class="syntax"> |
| -- Matrix transposition |
| <b>matrix_trans</b>( matrix_in, in_args, matrix_out, out_args) |
| |
| -- Matrix addition |
| <b>matrix_add</b>( matrix_a, a_args, matrix_b, b_args, matrix_out, out_args) |
| |
| -- Matrix subtraction |
| <b>matrix_sub</b>( matrix_a, a_args, matrix_b, b_args, matrix_out, out_args) |
| |
| -- Matrix multiplication |
| <b>matrix_mult</b>( matrix_a, a_args, matrix_b, b_args, matrix_out, out_args) |
| |
| -- Element-wise matrix multiplication |
| <b>matrix_elem_mult</b>( matrix_a, a_args, matrix_b, b_args, matrix_out, out_args) |
| |
| -- Multiply matrix with scalar |
| <b>matrix_scalar_mult</b>( matrix_in, in_args, scalar, matrix_out, out_args) |
| |
| -- Multiply matrix with vector |
| <b>matrix_vec_mult</b>( matrix_in, in_args, vector) |
| </pre> |
| |
| - <b>Extraction/visitor methods</b> |
| <pre class="syntax"> |
| -- Extract row from matrix given row index |
| <b>matrix_extract_row</b>( matrix_in, in_args, index) |
| |
| -- Extract column from matrix given column index |
| <b>matrix_extract_col</b>( matrix_in, in_args, index) |
| |
| -- Extract main (principal) diagonal elements |
| <b>matrix_extract_diag</b>( matrix_in, in_args) |
| </pre> |
| |
| - <b>Reduction operations (aggregate across specific dimension)</b> |
| <pre class="syntax"> |
| -- Get max value along dim. Returns corresponding index if <em>fetch_index</em> = True |
| <b>matrix_max</b>( matrix_in, in_args, dim, matrix_out, fetch_index) |
| |
| -- Get min value along dim. Returns corresponding index if <em>fetch_index</em> = True |
| <b>matrix_min</b>( matrix_in, in_args, dim, matrix_out, fetch_index) |
| |
| -- Get sum value along dimension |
| <b>matrix_sum</b>( matrix_in, in_args, dim) |
| |
| -- Get mean value along dimension |
| <b>matrix_mean</b>( matrix_in, in_args, dim) |
| |
| -- Get matrix norm |
| <b>matrix_norm</b>( matrix_in, in_args, norm_type) |
| </pre> |
| |
| - <b>Creation methods</b> |
| <pre class="syntax"> |
| -- Create a matrix initialized with ones of given row and column dimension |
| <b>matrix_ones</b>( row_dim, col_dim, matrix_out, out_args) |
| |
| -- Create a matrix initialized with zeros of given row and column dimension |
| <b>matrix_zeros</b>( row_dim, col_dim, matrix_out, out_args) |
| |
| -- Create an square identity matrix of size dim x dim |
| <b>matrix_identity</b>( dim, matrix_out, out_args) |
| |
| -- Create a diag matrix initialized with given diagonal elements |
| <b>matrix_diag</b>( diag_elements, matrix_out, out_args) |
| -- Create a matrix initialized with values sampled from a distribution |
| -- Supported distributions: normal, uniform, bernoulli |
| <b>matrix_random</b>( distribution, row_dim, col_dim, in_args, matrix_out, out_args ) |
| </pre> |
| |
| - <b>Decomposition operations</b> |
| @note Please note that the decomposition operations below are only implemented for in-memory operations. The matrix |
| data is collected on a single node and the decomposition is computed. This makes the |
| operations applicable to smaller matrices since the calculation is not distributed across multiple nodes. |
| |
| <pre class="syntax"> |
| -- Matrix inverse |
| <b>matrix_inverse</b>( matrix_in, in_args, matrix_out, out_args) |
| |
| -- Matrix generic inverse |
| <b>matrix_pinv</b>( matrix_in, in_args, matrix_out, out_args) |
| |
| -- Matrix eigenvalue extraction |
| <b>matrix_eigen</b>( matrix_in, in_args, matrix_out, out_args) |
| |
| -- Matrix Cholesky decomposition |
| <b>matrix_cholesky</b>( matrix_in, in_args, matrix_out_prefix, out_args) |
| |
| -- Matrix QR decomposition |
| <b>matrix_qr</b>( matrix_in, in_args, matrix_out_prefix, out_args) |
| |
| -- Matrix LU decomposition |
| <b>matrix_lu</b>( matrix_in, in_args, matrix_out_prefix, out_args) |
| |
| -- Matrix nuclear norm computing |
| <b>matrix_nuclear_norm</b>( matrix_in, in_args) |
| |
| -- Matrix rank computing |
| <b>matrix_rank</b>( matrix_in, in_args) |
| </pre> |
| |
| @anchor arguments |
| \b Arguments |
| |
| The table below provides a glossary of the arguments used in the matrix operations. |
| |
| <dl class="arglist"> |
| <dt>matrix_in, matrix_a, matrix_b</dt> |
| <dd>TEXT. Name of the table containing the input matrix. |
| - For functions accepting one matrix, <em>matrix_in</em> denotes the input matrix. |
| - For functions accepting two matrices, <em>matrix_a</em> denotes the first matrix |
| and <em>matrix_b</em> denotes the second matrix. These two matrices can |
| <b>independently</b> be in either dense or sparse format. |
| </dd> |
| |
| <dt>in_args, a_args, b_args</dt> |
| <dd>TEXT. A comma-delimited 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: |
| <table class="output"> |
| <tr> |
| <th>row</th> |
| <td>(Default: 'row_num') Name of the column containing row index of the matrix. </td> |
| </tr> |
| <tr> |
| <th>col</th> |
| <td>(Default: 'col_num') Name of the column containing column index of the matrix.</td> |
| </tr> |
| <tr> |
| <th>val</th> |
| <td>(Default: 'val') Name of the column containing the entries of the matrix.</td> |
| </tr> |
| <tr> |
| <th>trans</th> |
| <td>(Default: False) Boolean flag to indicate if the matrix should be |
| transposed before the operation. This is currently functional only for <em>matrix_mult</em>.</td> |
| </tr> |
| </table> |
| |
| For example, the string argument with default values will be |
| 'row=row_num, col=col_num, val=val, trans=False'. Alternatively, |
| the string argument can be set to <em>NULL</em> or be blank ('') if default |
| values are to be used. |
| </dd> |
| |
| <dt>matrix_out</dt> |
| <dd>TEXT. Name of the table to store the result matrix. |
| |
| For Cholesky, QR and LU decompositions, a prefix (<em>matrix_out_prefix</em>) is used as a basis to |
| build the names of the various output tables. |
| |
| For Cholesky decomposition (\f$ PA = LDL* \f$), the following suffixes are added to <em>matrix_out_prefix</em>: |
| - <em>_p</em> for row permutation matrix P |
| - <em>_l</em> for lower triangular factor L |
| - <em>_d</em> for diagonal matrix D |
| |
| For QR decomposition (\f$ A = QR \f$) the following suffixes are added to <em>matrix_out_prefix</em>: |
| - <em>_q</em> for orthogonal matrix Q |
| - <em>_r</em> for upper triangular factor R |
| |
| For LU decomposition with full pivoting (\f$ PAQ = LU \f$), the following suffixes are added to <em>matrix_out_prefix</em>: |
| - <em>_p</em> for row permutation matrix P |
| - <em>_q</em> for column permutation matrix Q |
| - <em>_l</em> for lower triangular factor L |
| - <em>_u</em> for upper triangular factor U |
| </dd> |
| |
| <dt>out_args</dt> |
| <dd> TEXT. A comma-delimited string containing named arguments of the form |
| "name=value". This is an <b>optional parameter</b> and the default value is set as follows: |
| - For functions with one input matrix, default <em>out_args</em> will the be same as specified in <em>in_args</em>. |
| - For functions with two input matrices, default <em>out_args</em> will be the same as specified in <em>a_args</em>. |
| |
| The following parameters are supported for this string argument: |
| <table class="output"> |
| <tr> |
| <th>row</th> |
| <td> Name of the column containing row index of the matrix. </td> |
| </tr> |
| <tr> |
| <th>col</th> |
| <td> Name of the column containing column index of the matrix.</td> |
| </tr> |
| <tr> |
| <th>val</th> |
| <td> Name of the column containing the entries of the matrix.</td> |
| </tr> |
| <tr> |
| <th>fmt</th> |
| <td>Format of the output matrix. It could be either 'dense' or 'sparse'. |
| When 'fmt' is not provided, the output fmt is inferred from the input matrices.</td> |
| </tr> |
| </table> |
| </dd> |
| |
| @note One exception is for <em>matrix_eigen</em>: the default output column name |
| is <em>’eigen_values’</em> in the format <em>(real, imaginary)</em>. |
| |
| <dt>index</dt> |
| <dd> INTEGER. An integer representing a row or column index of the matrix. |
| Should be a number from 1 to <em>N</em>, where <em>N</em> is the maximum size of the |
| dimension.</dd> |
| |
| <dt>dim</dt> |
| <dd> INTEGER. Should either be 1 or 2. This value indicates the dimension to operate along |
| for the reduction/aggregation operations. <b>The value of <em>dim</em> should be interpreted as |
| the dimension to be flattened i.e. whose length reduces to 1 in the result.</b> |
| |
| For any reduction function applied on an <em>N x M</em> matrix: |
| |
| - if <em>dim=1</em>, operation is applied on successive elements in each column; return value is |
| a single vector with <em>M</em> elements (i.e. matrix with 1 row and <em>M</em> columns). |
| <br> |
| - if <em>dim=2</em>, operation is applied on successive elements in each row; return value is |
| a single vector with <em>N</em> elements (i.e. matrix with <em>N</em> rows and 1 column). |
| </dd> |
| |
| <dt>row_dim</dt> |
| <dd> INTEGER. Should be greater than 0. This value indicates the row dimension of result matrix. |
| </dd> |
| |
| <dt>col_dim</dt> |
| <dd> INTEGER. Should be greater than 0. This value indicates the column dimension of result matrix. |
| </dd> |
| |
| <dt>diag_elements</dt> |
| <dd> ARRAY OF FLOAT. Should not be empty. This value indicates the float array |
| which is used to generate diag elements of result output matrix. |
| </dd> |
| |
| <dt>norm_type</dt> |
| <dd> TEXT. Optional parameter. Defaults to Frobenius norm. |
| Other supported norms for this string argument: |
| |
| <table class="output"> |
| <tr> |
| <th>'one' or 'o'</th> |
| <td> 1 norm </td> |
| </tr> |
| <tr> |
| <th>float > 0</th> |
| <td> Element-wise norm</td> |
| </tr> |
| <tr> |
| <th>'inf' or 'i'</th> |
| <td> Infinite norm</td> |
| </tr> |
| <tr> |
| <th>'max' or 'm'</th> |
| <td>Max absolute value norm</td> |
| </tr> |
| <tr> |
| <th>'fro' or 'f'</th> |
| <td>Frobenius norm (default)</td> |
| </tr> |
| </table> |
| </dd> |
| |
| </dl> |
| |
| @anchor examples |
| @par Examples (Dense Format) |
| |
| Here are some examples of matrix operations in dense format. |
| Later on this page we will show examples of matrix operations in sparse format. |
| |
| -# First let’s create example data tables in dense format: |
| <pre class="syntax"> |
| CREATE TABLE "mat_A" ( |
| row_id integer, |
| row_vec integer[] |
| ); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (1, '{9,6,5,8,5,6,6,3,10,8}'); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (2, '{8,2,2,6,6,10,2,1,9,9}'); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (3, '{3,9,9,9,8,6,3,9,5,6}'); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (4, '{6,4,2,2,2,7,8,8,0,7}'); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (5, '{6,8,9,9,4,6,9,5,7,7}'); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (6, '{4,10,7,3,9,5,9,2,3,4}'); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (7, '{8,10,7,10,1,9,7,9,8,7}'); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (8, '{7,4,5,6,2,8,1,1,4,8}'); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (9, '{8,8,8,5,2,6,9,1,8,3}'); |
| INSERT INTO "mat_A" (row_id, row_vec) VALUES (10, '{4,6,3,2,6,4,1,2,3,8}'); |
| \nbsp |
| CREATE TABLE "mat_B" ( |
| row_id integer, |
| vector integer[] |
| ); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (1, '{9,10,2,4,6,5,3,7,5,6}'); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (2, '{5,3,5,2,8,6,9,7,7,6}'); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (3, '{0,1,2,3,2,7,7,3,10,1}'); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (4, '{2,9,0,4,3,6,8,6,3,4}'); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (5, '{3,8,7,7,0,5,3,9,2,10}'); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (6, '{5,3,1,7,6,3,5,3,6,4}'); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (7, '{4,8,4,4,2,7,10,0,3,3}'); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (8, '{4,6,0,1,3,1,6,6,9,8}'); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (9, '{6,5,1,7,2,7,10,6,0,6}'); |
| INSERT INTO "mat_B" (row_id, vector) VALUES (10, '{1,4,4,4,8,5,2,8,5,5}'); |
| </pre> |
| |
| -# Transpose a matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_trans('"mat_B"', 'row=row_id, val=vector', |
| 'mat_r'); |
| SELECT * FROM mat_r ORDER BY row_id; |
| </pre> |
| <pre class="result"> |
| -- Note that the result matrix has inherited 'vector' as the name of the value column by default |
| row_id | vector |
| \--------+------------------------- |
| 1 | {9,5,0,2,3,5,4,4,6,1} |
| 2 | {10,3,1,9,8,3,8,6,5,4} |
| 3 | {2,5,2,0,7,1,4,0,1,4} |
| 4 | {4,2,3,4,7,7,4,1,7,4} |
| 5 | {6,8,2,3,0,6,2,3,2,8} |
| 6 | {5,6,7,6,5,3,7,1,7,5} |
| 7 | {3,9,7,8,3,5,10,6,10,2} |
| 8 | {7,7,3,6,9,3,0,6,6,8} |
| 9 | {5,7,10,3,2,6,3,9,0,5} |
| 10 | {6,6,1,4,10,4,3,8,6,5} |
| (10 rows) |
| </pre> |
| |
| -# Extract main diagonal of a matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_extract_diag('"mat_B"', 'row=row_id, val=vector'); |
| </pre> |
| <pre class="result"> |
| -- Note the result is an array |
| matrix_extract_diag |
| \--------------------------------- |
| {9,3,2,4,0,3,10,6,0,5} |
| (1 row) |
| </pre> |
| |
| -# Add two matrices |
| <pre class="syntax"> |
| SELECT madlib.matrix_add('"mat_A"', 'row=row_id, val=row_vec', |
| '"mat_B"', 'row=row_id, val=vector', |
| 'mat_r', 'val=vector, fmt=dense'); |
| SELECT * FROM mat_r ORDER BY row_id; |
| </pre> |
| <pre class="result"> |
| row_id | vector |
| \--------+------------------------------- |
| 1 | {18,16,7,12,11,11,9,10,15,14} |
| 2 | {13,5,7,8,14,16,11,8,16,15} |
| 3 | {3,10,11,12,10,13,10,12,15,7} |
| 4 | {8,13,2,6,5,13,16,14,3,11} |
| 5 | {9,16,16,16,4,11,12,14,9,17} |
| 6 | {9,13,8,10,15,8,14,5,9,8} |
| 7 | {12,18,11,14,3,16,17,9,11,10} |
| 8 | {11,10,5,7,5,9,7,7,13,16} |
| 9 | {14,13,9,12,4,13,19,7,8,9} |
| 10 | {5,10,7,6,14,9,3,10,8,13} |
| (10 rows) |
| </pre> |
| |
| -# Multiply two matrices |
| <pre class="syntax"> |
| SELECT madlib.matrix_mult('"mat_A"', 'row=row_id, val=row_vec', |
| '"mat_B"', 'row=row_id, val=vector, trans=true', |
| 'mat_r'); |
| SELECT * FROM mat_r ORDER BY row_id; |
| </pre> |
| <pre class="result"> |
| row_id | row_vec |
| \--------+------------------------------------------- |
| 1 | {380,373,251,283,341,303,302,309,323,281} |
| 2 | {318,318,222,221,269,259,236,249,264,248} |
| 3 | {382,366,216,300,397,276,277,270,313,338} |
| 4 | {275,284,154,244,279,183,226,215,295,204} |
| 5 | {381,392,258,319,394,298,342,302,360,300} |
| 6 | {321,333,189,276,278,232,300,236,281,250} |
| 7 | {443,411,282,365,456,318,360,338,406,330} |
| 8 | {267,240,150,186,270,194,210,184,233,193} |
| 9 | {322,328,234,264,291,245,317,253,291,219} |
| 10 | {246,221,109,173,222,164,167,185,181,189} |
| (10 rows) |
| </pre> |
| |
| -# Create a diagonal matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_diag(array[9,6,3,10], |
| 'mat_r', 'row=row_id, col=col_id, val=val'); |
| SELECT * FROM mat_r ORDER BY row_id::bigint; |
| </pre> |
| <pre class="result"> |
| row_id | col_id | val |
| --------+---------+-------- |
| 1 | 1 | 9 |
| 2 | 2 | 6 |
| 3 | 3 | 3 |
| 4 | 4 | 10 |
| (11 rows) |
| </pre> |
| |
| -# Create an identity matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_identity(4, 'mat_r', 'row=row_id,col=col_id,val=val'); |
| SELECT * FROM mat_r ORDER BY row_id; |
| </pre> |
| <pre class="result"> |
| row_id | col_id | val |
| --------+---------+-------- |
| 1 | 1 | 1 |
| 2 | 2 | 1 |
| 3 | 3 | 1 |
| 4 | 4 | 1 |
| (5 rows) |
| </pre> |
| |
| -# Extract row and column from a matrix by specifying index |
| <pre class="syntax"> |
| SELECT madlib.matrix_extract_row('"mat_A"', 'row=row_id, val=row_vec', 2) as row, |
| madlib.matrix_extract_col('"mat_A"', 'row=row_id, val=row_vec', 3) as col; |
| </pre> |
| <pre class="result"> |
| row | col |
| \------------------------+----------------------- |
| {8,2,2,6,6,10,2,1,9,9} | {5,2,9,2,9,7,7,5,8,3} |
| (1 rows) |
| </pre> |
| |
| -# Get min and max values along a specific dimension, as well as the corresponding indices. |
| Note that in this example <em>dim=2</em> implies that the min and max is computed on each row, |
| returning a column vector i.e. the column (dim=2) is flattened. |
| <pre class="syntax"> |
| SELECT madlib.matrix_max('"mat_A"', 'row=row_id, val=row_vec', 2, 'mat_max_r', true), |
| madlib.matrix_min('"mat_A"', 'row=row_id, val=row_vec', 2, 'mat_min_r', true); |
| SELECT * from mat_max_r; |
| SELECT * from mat_min_r; |
| </pre> |
| <pre class="result"> |
| index | max |
| -----------------------+--------------------------- |
| {9,6,2,7,3,2,2,6,7,10} | {10,10,9,8,9,10,10,8,9,8} |
| (1 rows) |
| |
| index | min |
| -----------------------+----------------------- |
| {8,8,1,9,5,8,5,7,8,7} | {3,1,3,0,4,2,1,1,1,1} |
| (1 rows) |
| </pre> |
| |
| -# Initialize matrix with zeros in sparse format |
| <pre class="syntax"> |
| SELECT madlib.matrix_zeros(5, 4, 'mat_r', 'row=row_id, col=col_id, val=entry'); |
| SELECT * FROM mat_r; |
| </pre> |
| <pre class="result"> |
| row_id | col_id | entry |
| --------+---------+-------- |
| 5 | 4 | 0 |
| (1 rows) |
| </pre> |
| |
| -# Initialize matrix with zeros in dense format |
| </pre> |
| <pre class="syntax"> |
| SELECT madlib.matrix_zeros(5, 4, 'mat_r', 'fmt=dense'); |
| SELECT * FROM mat_r ORDER BY row; |
| </pre> |
| <pre class="result"> |
| row | val |
| -----+----------- |
| 1 | {0,0,0,0} |
| 2 | {0,0,0,0} |
| 3 | {0,0,0,0} |
| 4 | {0,0,0,0} |
| 5 | {0,0,0,0} |
| (5 rows) |
| </pre> |
| |
| -# Initialize matrix with ones |
| </pre> |
| <pre class="syntax"> |
| SELECT madlib.matrix_ones(5, 4, 'mat_r', 'row=row,col=col, val=val'); |
| SELECT * FROM mat_r; |
| </pre> |
| <pre class="result"> |
| row | col | val |
| -----+-----+----- |
| 1 | 1 | 1 |
| 1 | 2 | 1 |
| 1 | 3 | 1 |
| 1 | 4 | 1 |
| 2 | 1 | 1 |
| 2 | 2 | 1 |
| 2 | 3 | 1 |
| 2 | 4 | 1 |
| 3 | 1 | 1 |
| 3 | 2 | 1 |
| 3 | 3 | 1 |
| 3 | 4 | 1 |
| 4 | 1 | 1 |
| 4 | 2 | 1 |
| 4 | 3 | 1 |
| 4 | 4 | 1 |
| 5 | 1 | 1 |
| 5 | 2 | 1 |
| 5 | 3 | 1 |
| 5 | 4 | 1 |
| (20 rows) |
| </pre> |
| |
| -# Initialize matrix with ones in dense format |
| </pre> |
| <pre class="syntax"> |
| SELECT madlib.matrix_ones(5, 4, 'mat_r', 'fmt=dense'); |
| SELECT * FROM mat_r ORDER BY row; |
| </pre> |
| <pre class="result"> |
| row | val |
| -----+----------- |
| 1 | {1,1,1,1} |
| 2 | {1,1,1,1} |
| 3 | {1,1,1,1} |
| 4 | {1,1,1,1} |
| 5 | {1,1,1,1} |
| (5 rows) |
| </pre> |
| |
| -# Element-wise multiplication between two matrices |
| <pre class="syntax"> |
| SELECT madlib.matrix_elem_mult('"mat_A"', 'row=row_id, val=row_vec', |
| '"mat_B"', 'row=row_id, val=vector', |
| 'mat_r', 'val=vector'); |
| SELECT * FROM mat_r ORDER BY row_id; |
| </pre> |
| <pre class="result"> |
| row_id | vector |
| \--------+--------------------------------- |
| 1 | {81,60,10,32,30,30,18,21,50,48} |
| 2 | {40,6,10,12,48,60,18,7,63,54} |
| 3 | {0,9,18,27,16,42,21,27,50,6} |
| 4 | {12,36,0,8,6,42,64,48,0,28} |
| 5 | {18,64,63,63,0,30,27,45,14,70} |
| 6 | {20,30,7,21,54,15,45,6,18,16} |
| 7 | {32,80,28,40,2,63,70,0,24,21} |
| 8 | {28,24,0,6,6,8,6,6,36,64} |
| 9 | {48,40,8,35,4,42,90,6,0,18} |
| 10 | {4,24,12,8,48,20,2,16,15,40} |
| </pre> |
| |
| -# Get sum values along a dimension. In this example, the sum is |
| computed for each row (i.e. column is flattened since dim=2). |
| <pre class="syntax"> |
| SELECT madlib.matrix_sum('"mat_A"', 'row=row_id, val=row_vec', 2); |
| </pre> |
| <pre class="result"> |
| matrix_sum |
| \--------------------------------- |
| {66,55,67,46,70,56,76,46,58,39} |
| (1 rows) |
| </pre> |
| |
| -# Get mean values along dimension |
| <pre class="syntax"> |
| SELECT madlib.matrix_mean('"mat_A"', 'row=row_id, val=row_vec', 2); |
| </pre> |
| <pre class="result"> |
| matrix_mean |
| \----------------------------------------- |
| {6.6,5.5,6.7,4.6,7,5.6,7.6,4.6,5.8,3.9} |
| (1 rows) |
| </pre> |
| |
| -# Compute matrix norm. In this example, we ask for the Euclidean norm: |
| <pre class="syntax"> |
| SELECT madlib.matrix_norm('"mat_A"', 'row=row_id, val=row_vec', '2'); |
| </pre> |
| <pre class="result"> |
| matrix_norm |
| \--------------- |
| 64.1014820421 |
| (1 row) |
| </pre> |
| |
| -# Multiply matrix with scalar |
| <pre class="syntax"> |
| SELECT madlib.matrix_scalar_mult('"mat_A"', 'row=row_id, val=row_vec', 3, 'mat_r'); |
| SELECT * FROM mat_r ORDER BY row_id; |
| </pre> |
| <pre class="result"> |
| row_id | row_vec |
| \--------+--------------------------------- |
| 1 | {27,18,15,24,15,18,18,9,30,24} |
| 2 | {24,6,6,18,18,30,6,3,27,27} |
| 3 | {9,27,27,27,24,18,9,27,15,18} |
| 4 | {18,12,6,6,6,21,24,24,0,21} |
| 5 | {18,24,27,27,12,18,27,15,21,21} |
| 6 | {12,30,21,9,27,15,27,6,9,12} |
| 7 | {24,30,21,30,3,27,21,27,24,21} |
| 8 | {21,12,15,18,6,24,3,3,12,24} |
| 9 | {24,24,24,15,6,18,27,3,24,9} |
| 10 | {12,18,9,6,18,12,3,6,9,24} |
| (10 rows) |
| </pre> |
| |
| -# Get the row dimension and column dimension of matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_ndims('"mat_A"', 'row=row_id, val=row_vec'); |
| </pre> |
| <pre class="result"> |
| matrix_ndims |
| \-------------- |
| {10,10} |
| (1 row) |
| </pre> |
| |
| -# Multiply matrix with vector |
| <pre class="syntax"> |
| SELECT madlib.matrix_vec_mult('"mat_A"', 'row=row_id, val=row_vec', |
| array[1,2,3,4,5,6,7,8,9,10]); |
| </pre> |
| <pre class="result"> |
| matrix_vec_mult |
| \------------------------------------------- |
| {365,325,358,270,377,278,411,243,287,217} |
| (10 rows) |
| </pre> |
| |
| -# Inverse of matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_inverse('"mat_A"', 'row=row_id, val=row_vec', 'mat_r'); |
| SELECT row_vec FROM mat_r ORDER BY row_id; |
| </pre> |
| |
| -# Generic inverse of matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_pinv('"mat_A"', 'row=row_id, val=row_vec', 'mat_r'); |
| SELECT row_vec FROM mat_r ORDER BY row_id; |
| </pre> |
| |
| -# Eigenvalues of matrix (note default column name of eigenvalues) |
| <pre class="syntax"> |
| SELECT madlib.matrix_eigen('"mat_A"', 'row=row_id, val=row_vec', 'mat_r'); |
| SELECT eigen_values FROM mat_r ORDER BY row_id; |
| </pre> |
| |
| -# Cholesky decomposition of matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_cholesky('"mat_A"', 'row=row_id, val=row_vec', 'matrix_out_prefix'); |
| SELECT row_vec FROM matrix_out_prefix_p ORDER BY row_id; |
| SELECT row_vec FROM matrix_out_prefix_l ORDER BY row_id; |
| SELECT row_vec FROM matrix_out_prefix_d ORDER BY row_id; |
| </pre> |
| |
| -# QR decomposition of matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_qr('"mat_A"', 'row=row_id, val=row_vec', 'matrix_out_prefix'); |
| SELECT row_vec FROM matrix_out_prefix_q ORDER BY row_id; |
| SELECT row_vec FROM matrix_out_prefix_r ORDER BY row_id; |
| </pre> |
| |
| -# LU decomposition of matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_lu('"mat_A"', 'row=row_id, val=row_vec', 'matrix_out_prefix'); |
| SELECT row_vec FROM matrix_out_prefix_l ORDER BY row_id; |
| SELECT row_vec FROM matrix_out_prefix_u ORDER BY row_id; |
| SELECT row_vec FROM matrix_out_prefix_p ORDER BY row_id; |
| SELECT row_vec FROM matrix_out_prefix_q ORDER BY row_id; |
| </pre> |
| |
| -# Nuclear norm of matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_nuclear_norm('"mat_A"', 'row=row_id, val=row_vec'); |
| </pre> |
| <pre class="result"> |
| matrix_nuclear_norm |
| \--------------------- |
| 118.852685995 |
| (1 row) |
| </pre> |
| |
| -# Rank of matrix |
| <pre class="syntax"> |
| SELECT madlib.matrix_rank('"mat_A"', 'row=row_id, val=row_vec'); |
| </pre> |
| <pre class="result"> |
| matrix_rank |
| \------------- |
| 10 |
| (1 row) |
| </pre> |
| |
| @par Examples (Sparse Format) |
| |
| Below are some examples of matrix operations in sparse format. |
| |
| -# Convert a matrix from dense to sparse format |
| <pre class="syntax"> |
| SELECT madlib.matrix_sparsify('"mat_B"', 'row=row_id, val=vector', |
| '"mat_B_sparse"', 'col=col_id, val=val'); |
| SELECT * FROM "mat_B_sparse" ORDER BY row_id, col_id; |
| </pre> |
| |
| -# Create a matrix in sparse format. |
| <pre class="syntax"> |
| CREATE TABLE "mat_A_sparse" ( |
| "rowNum" integer, |
| col_num integer, |
| entry integer |
| ); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (1, 1, 9); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (1, 2, 6); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (1, 7, 3); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (1, 8, 10); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (1, 9, 8); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (2, 1, 8); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (2, 2, 2); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (2, 3, 6); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (3, 5, 6); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (3, 6, 3); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (7, 1, 7); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (8, 2, 8); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (8, 3, 5); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (9, 1, 6); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (9, 2, 3); |
| INSERT INTO "mat_A_sparse" ("rowNum", col_num, entry) VALUES (10, 10, 0); |
| </pre> |
| |
| -# Get the row_dims and col_dims of a matrix in sparse format |
| <pre class="syntax"> |
| SELECT madlib.matrix_ndims('"mat_A_sparse"', 'row="rowNum", val=entry') |
| </pre> |
| <pre class="result"> |
| matrix_ndims |
| \-------------- |
| {10,10} |
| (1 row) |
| </pre> |
| |
| -# Transpose a matrix in sparse format |
| <pre class="syntax"> |
| -- Note the double quotes for "rowNum" are required as per PostgreSQL rules since “N” is capitalized |
| SELECT madlib.matrix_trans('"mat_A_sparse"', 'row="rowNum", val=entry', |
| 'matrix_r_sparse'); |
| SELECT "rowNum", col_num, entry FROM matrix_r_sparse ORDER BY col_num; |
| </pre> |
| <pre class="result"> |
| rowNum | col_num | entry |
| \--------+---------+------- |
| 1 | 1 | 9 |
| 2 | 1 | 6 |
| 7 | 1 | 3 |
| 8 | 1 | 10 |
| 9 | 1 | 8 |
| 1 | 2 | 8 |
| 2 | 2 | 2 |
| 3 | 2 | 6 |
| 5 | 3 | 6 |
| 6 | 3 | 3 |
| 1 | 7 | 7 |
| 2 | 8 | 8 |
| 3 | 8 | 5 |
| 1 | 9 | 6 |
| 2 | 9 | 3 |
| 10 | 10 | 0 |
| (16 rows) |
| </pre> |
| |
| -# Main diagonal of a matrix in sparse format |
| <pre class="syntax"> |
| SELECT madlib.matrix_extract_diag('"mat_A_sparse"', 'row="rowNum", val=entry'); |
| </pre> |
| <pre class="result"> |
| matrix_extract_diag |
| \----------------- |
| {9,2,0,0,0,0,0,0,0,0} |
| (1 row) |
| </pre> |
| |
| -# Add two sparse matrices then convert to dense format |
| <pre class="syntax"> |
| SELECT madlib.matrix_add('"mat_A_sparse"', 'row="rowNum", val=entry', |
| '"mat_B_sparse"', 'row=row_id, col=col_id, val=val', |
| 'matrix_r_sparse', 'col=col_out'); |
| SELECT madlib.matrix_densify('matrix_r_sparse', 'row="rowNum", col=col_out, val=entry', |
| 'matrix_r'); |
| SELECT * FROM matrix_r ORDER BY "rowNum"; |
| </pre> |
| <pre class="result"> |
| rowNum | entry |
| \--------+--------------------------- |
| 1 | {18,16,2,4,6,5,6,17,13,6} |
| 2 | {13,5,11,2,8,6,9,7,7,6} |
| 3 | {0,1,2,3,8,10,7,3,10,1} |
| 4 | {2,9,0,4,3,6,8,6,3,4} |
| 5 | {3,8,7,7,0,5,3,9,2,10} |
| 6 | {5,3,1,7,6,3,5,3,6,4} |
| 7 | {11,8,4,4,2,7,10,0,3,3} |
| 8 | {4,14,5,1,3,1,6,6,9,8} |
| 9 | {12,8,1,7,2,7,10,6,0,6} |
| 10 | {1,4,4,4,8,5,2,8,5,5} |
| (10 rows) |
| </pre> |
| |
| -# Multiply two sparse matrices |
| <pre class="syntax"> |
| SELECT madlib.matrix_mult('"mat_A_sparse"', 'row="rowNum", col=col_num, val=entry', |
| '"mat_B_sparse"', 'row=row_id, col=col_id, val=val, trans=true', |
| 'matrix_r'); |
| SELECT * FROM matrix_r ORDER BY "rowNum"; |
| </pre> |
| <pre class="result"> |
| rowNum | entry |
| \--------+------------------------------------------- |
| 1 | {260,216,137,180,190,156,138,222,174,159} |
| 2 | {104,76,14,34,82,52,72,44,64,40} |
| 3 | {51,66,33,36,15,45,33,21,33,63} |
| 4 | {0,0,0,0,0,0,0,0,0,0} |
| 5 | {0,0,0,0,0,0,0,0,0,0} |
| 6 | {0,0,0,0,0,0,0,0,0,0} |
| 7 | {63,35,0,14,21,35,28,28,42,7} |
| 8 | {90,49,18,72,99,29,84,48,45,52} |
| 9 | {84,39,3,39,42,39,48,42,51,18} |
| 10 | {0,0,0,0,0,0,0,0,0,0} |
| (10 rows) |
| </pre> |
| |
| -# Initialize matrix with ones |
| </pre> |
| <pre class="syntax"> |
| SELECT madlib.matrix_ones(5, 4, 'mat_r', 'row=row,col=col, val=val'); |
| SELECT * FROM mat_r ORDER BY row, col; |
| </pre> |
| <pre class="result"> |
| row | col | val |
| \-----+-----+----- |
| 1 | 1 | 1 |
| 1 | 2 | 1 |
| 1 | 3 | 1 |
| 1 | 4 | 1 |
| 2 | 1 | 1 |
| 2 | 2 | 1 |
| 2 | 3 | 1 |
| 2 | 4 | 1 |
| 3 | 1 | 1 |
| 3 | 2 | 1 |
| 3 | 3 | 1 |
| 3 | 4 | 1 |
| 4 | 1 | 1 |
| 4 | 2 | 1 |
| 4 | 3 | 1 |
| 4 | 4 | 1 |
| 5 | 1 | 1 |
| 5 | 2 | 1 |
| 5 | 3 | 1 |
| 5 | 4 | 1 |
| (20 rows) |
| </pre> |
| |
| -# Initialize matrix with zeros in sparse format |
| </pre> |
| <pre class="syntax"> |
| SELECT madlib.matrix_zeros(5, 4, 'mat_r', 'row=row_id, col=col_id, val=entry'); |
| SELECT * FROM mat_r; |
| </pre> |
| <pre class="result"> |
| row_id | col_id | entry |
| \--------+---------+-------- |
| 5 | 4 | 0 |
| (1 rows) |
| </pre> |
| |
| -# Compute matrix norm on sparse matrix. In this example, we ask for the Euclidean norm: |
| <pre class="syntax"> |
| SELECT madlib.matrix_norm('"mat_A_sparse"', 'row="rowNum", col=col_num, val=entry', '2'); |
| </pre> |
| <pre class="result"> |
| matrix_norm |
| \--------------- |
| 24.9399278267 |
| (1 row) |
| </pre> |
| |
| |
| @anchor related |
| @par Related Topics |
| |
| File array_ops.sql_in documents the array operations |
| \ref grp_array |
| |
| File matrix_ops.sql_in for list of functions and usage. |
| */ |
| ------------------------------------------------------------------------- |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_info( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_info_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_info() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_info(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| DROP TYPE IF EXISTS MADLIB_SCHEMA.matrix_result CASCADE; |
| CREATE TYPE MADLIB_SCHEMA.matrix_result AS( |
| output_table TEXT |
| ); |
| |
| DROP TYPE IF EXISTS MADLIB_SCHEMA.complex CASCADE; |
| CREATE TYPE MADLIB_SCHEMA.complex AS( |
| real DOUBLE PRECISION, |
| imag DOUBLE PRECISION |
| ); |
| |
| /** |
| * @brief Multiplies two matrices. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column index. |
| * |
| * @param matrix_a Name of the table containing the first matrix |
| * @param a_row Name of the column containing the row index for the first matrix |
| * @param a_col Name of the column containing the column index for the first matrix |
| * @param a_val Name of the column containing the matrix values for the first matrix |
| * @param a_trans Boolean to indicate if first matrix should be transposed before multiplication |
| * @param matrix_b Name of the table containing the second matrix |
| * @param b_row Name of the column containing the row index for the second matrix |
| * @param b_col Name of the column containing the column index for the second matrix |
| * @param b_val Name of the column containing the matrix values for the second matrix |
| * @param b_trans Boolean to indicate if second matrix should be transposed before multiplication |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_mult |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_mult(schema_madlib, |
| matrix_a, a_args, |
| matrix_b, b_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_mult |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT |
| MADLIB_SCHEMA.matrix_mult( |
| $1, $2, $3, $4, $5, NULL); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_mult( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_mult_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_mult() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_mult(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief get the ndims of a matrix in an array format |
| * |
| * @param matrix Name of the table containing the input matrix |
| * @param in_row Name of the column containing the row index for the input matrix |
| * @param in_col Name of the column containing the column index for the input matrix |
| * @param in_val Name of the column containing the matrix values for the input matrix |
| * @returns an array including row_dims and col_dims |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_ndims |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| is_block BOOLEAN |
| ) |
| RETURNS INTEGER[] AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_ndims(schema_madlib, |
| matrix_in, in_args, is_block) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_ndims |
| ( |
| matrix_in TEXT, |
| in_args TEXT |
| ) |
| RETURNS INTEGER[] AS $$ |
| SELECT MADLIB_SCHEMA.matrix_ndims($1, $2, FALSE); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_ndims( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_ndims_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_ndims() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_ndims(''); |
| END; |
| |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief Adds two matrices. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column index. |
| * |
| * @param matrix_a Name of the table containing the first matrix |
| * @param a_row Name of the column containing the row index for the first matrix |
| * @param a_col Name of the column containing the column index for the first matrix |
| * @param a_val Name of the column containing the matrix values for the first matrix |
| * @param matrix_b Name of the table containing the second matrix |
| * @param b_row Name of the column containing the row index for the second matrix |
| * @param b_col Name of the column containing the column index for the second matrix |
| * @param b_val Name of the column containing the matrix values for the second matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_add |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_add(schema_madlib, |
| matrix_a, a_args, |
| matrix_b, b_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_add |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_add($1, $2, $3, $4, $5, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_add( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_add_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_add() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_add(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief Subs two matrices. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column id. |
| * |
| * @param matrix_a Name of the table containing the first matrix |
| * @param a_row Name of the column containing the row id for the first matrix |
| * @param a_col Name of the column containing the column id for the first matrix |
| * @param a_val Name of the column containing the matrix values for the first matrix |
| * @param matrix_b Name of the table containing the second matrix |
| * @param b_row Name of the column containing the row id for the second matrix |
| * @param b_col Name of the column containing the column id for the second matrix |
| * @param b_val Name of the column containing the matrix values for the second matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_sub |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_sub(schema_madlib, |
| matrix_a, a_args, |
| matrix_b, b_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_sub |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_sub($1, $2, $3, $4, $5, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_sub( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_sub_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_sub |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT |
| MADLIB_SCHEMA.matrix_sub( |
| $1, $2, $3, $4, $5, NULL); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_sub() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_sub(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief Extract row from matrix given row index. It requires that all the values |
| * are NON-NULL. This is the dense or sparse representation of the matrix where the |
| * matrix elements are indexed by row id for dense and by the row and column id for |
| * sparse. |
| * |
| * @param matrix_in Name of the table containing the matrix |
| * @param in_args 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. |
| * @param index Row index for wanted. |
| * @returns Vector containing given row elements. |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_extract_row |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| index INTEGER |
| ) |
| RETURNS FLOAT8[] AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_extract(schema_madlib, matrix_in, in_args, 1, index) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_extract_row( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_extract_row_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_extract_row() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_extract_row(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| |
| /** |
| * @brief Extract column from matrix given column index. It requires that all the values |
| * are NON-NULL. This is the dense or sparse representation of the matrix where the |
| * matrix elements are indexed by row id for dense and by the row and column id for |
| * sparse. |
| * |
| * @param matrix_in Name of the table containing the matrix |
| * @param in_args 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. |
| * @param index Column index for wanted. |
| * @returns Vector containing given column elements. |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_extract_col |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| index INTEGER |
| ) |
| RETURNS FLOAT8[] AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_extract(schema_madlib, matrix_in, in_args, 2, index) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_extract_col( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_extract_col_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_extract_col() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_extract_col(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| /** |
| * @brief Initializes matrix with zeros. It requires that all the values are NON-NULL. |
| * @param row_id Name of the column containing the row index for the zero matrix |
| * @param col_id Name of the column containing the column index for the zero matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_zeros |
| ( |
| row_dim INTEGER, |
| col_dim INTEGER, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_zeros(schema_madlib, |
| row_dim, col_dim, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_zeros |
| ( |
| row_dim INTEGER, |
| col_dim INTEGER, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_zeros($1, $2, $3, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_zeros( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_zeros_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_zeros() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_zeros(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief Get max value along dimension from matrix. Also returns corresponding index if set fetch_index. |
| * It requires that all the values are NON-NULL. This is the dense or sparse representation of |
| * the matrix where the matrix elements are indexed by row id for dense and by the row and column id for |
| * sparse. |
| * |
| * @param matrix_in Name of the table containing the matrix |
| * @param in_args 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. |
| * @param dim Which dimension to collapse. 1 means row wise, and 2 means column wise |
| * @param matrix_out Result matrix which contains one column: max, and another column: index if fetch_index is set. |
| * The type of column is array |
| * @param fetch_index True when want to get corresponding index of max value. Default is false |
| * @returns matrix_out. |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_max |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| dim INTEGER, |
| matrix_out TEXT, |
| fetch_index BOOLEAN |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_max(schema_madlib, |
| matrix_in, in_args, dim, matrix_out, fetch_index) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_max |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| dim INTEGER, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_max($1, $2, $3, $4, FALSE); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_max( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_max_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_max() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_max(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| |
| /** |
| * @brief Get min value along dimension from matrix. Also returns corresponding index if set fetch_index. |
| * It requires that all the values are NON-NULL. This is the dense or sparse representation of |
| * the matrix where the matrix elements are indexed by row id for dense and by the row and column id for |
| * sparse. |
| * |
| * @param matrix_in Name of the table containing the matrix |
| * @param in_args 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. |
| * @param dim Which dimension to collapse. 1 means row wise, and 2 means column wise |
| * @param matrix_out Result matrix which contains one column: min, and another column: index if fetch_index is set. |
| * The type of column is array |
| * @param fetch_index True when want to get corresponding index of min value. Default is false |
| * @returns matrix_out. |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_min |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| dim INTEGER, |
| matrix_out TEXT, |
| fetch_index BOOLEAN |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_min(schema_madlib, |
| matrix_in, in_args, dim, matrix_out, fetch_index) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_min |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| dim INTEGER, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_min($1, $2, $3, $4, FALSE); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_min( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_min_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_min() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_min(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| |
| /** |
| * @brief Calculate sum along dimension for matrix. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column id. |
| * |
| * @param matrix_in Name of the table containing the matrix |
| * @param in_args Name-value pair string containing options for matrix_in |
| * @param dim Which dimension to collapse. 1 means row wise, and 2 means column wise |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_sum |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| dim INTEGER |
| ) |
| RETURNS FLOAT8[] AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_sum(schema_madlib, |
| matrix_in, in_args, dim) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_sum |
| ( |
| matrix_in TEXT, |
| in_args TEXT |
| ) |
| RETURNS FLOAT8[] AS $$ |
| SELECT MADLIB_SCHEMA.matrix_sum($1, $2, 1); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_sum( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_sum_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_sum() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_sum(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| |
| /** |
| * @brief Calculate mean along dimension for matrix. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column id. |
| * |
| * @param matrix_in Name of the table containing the matrix |
| * @param in_args Name-value pair string containing options for matrix_in |
| * @param dim Which dimension to collapse. 1 means row wise, and 2 means column wise |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_mean |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| dim INTEGER |
| ) |
| RETURNS FLOAT8[] AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_mean(schema_madlib, |
| matrix_in, in_args, dim) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_mean |
| ( |
| matrix_in TEXT, |
| in_args TEXT |
| ) |
| RETURNS FLOAT8[] AS $$ |
| SELECT MADLIB_SCHEMA.matrix_mean($1, $2, 1); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_mean( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_mean_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_mean() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_mean(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| |
| /** |
| * @brief Multiplies one matrix with scalar. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column id. |
| * |
| * @param matrix_in Name of the table containing the matrix |
| * @param in_args Name-value pair string containing options for matrix_in |
| * @param scalar Scalar value used to be multiplied with matrix_in |
| * @param matrix_out Name of the table where to output the result matrix |
| * @param out_args Name-value pair string containing options for matrix_in |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_scalar_mult |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| scalar FLOAT8, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_scalar_mult(schema_madlib, |
| matrix_in, in_args, scalar, matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_scalar_mult( |
| matrix_in TEXT, |
| in_args TEXT, |
| scalar FLOAT8, |
| matrix_out TEXT |
| ) RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_scalar_mult($1, $2, $3, $4, ''::text); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_scalar_mult( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_scalar_mult_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_scalar_mult() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_scalar_mult(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief Multiplies one matrix with vector. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column id. |
| * |
| * @param matrix_in Name of the table containing the matrix |
| * @param in_args Name-value pair string containing options for matrix_in |
| * @param vector Vector value used to be multiplied with matrix_in |
| * @returns Column vector which is the result of matrix_in * vector |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_vec_mult |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| vector FLOAT8[] |
| ) |
| RETURNS FLOAT8[] AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_vec_mult(schema_madlib, |
| matrix_in, in_args, vector) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_vec_mult( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_vec_mult_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_vec_mult() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_vec_mult(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| |
| /** |
| * @brief Multiplies two matrices by element. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column id. |
| * |
| * @param matrix_a Name of the table containing the first matrix |
| * @param a_row Name of the column containing the row id for the first matrix |
| * @param a_col Name of the column containing the column id for the first matrix |
| * @param a_val Name of the column containing the matrix values for the first matrix |
| * @param matrix_b Name of the table containing the second matrix |
| * @param b_row Name of the column containing the row id for the second matrix |
| * @param b_col Name of the column containing the column id for the second matrix |
| * @param b_val Name of the column containing the matrix values for the second matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_elem_mult |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_elem_mult(schema_madlib, |
| matrix_a, a_args, |
| matrix_b, b_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_elem_mult |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_elem_mult($1, $2, $3, $4, $5, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_elem_mult( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_elem_mult_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_elem_mult() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_elem_mult(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief Transpose matrix. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param in_row Name of the column containing the row index for the input matrix |
| * @param in_col Name of the column containing the column index for the input matrix |
| * @param in_val Name of the column containing the matrix values for the input matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_trans |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_trans(schema_madlib, |
| matrix_in, in_args, matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_trans |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_trans($1, $2, $3, ''::TEXT); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_trans( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_trans_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_trans() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_trans(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| /** |
| * @brief Converts matrix to sparse representation. It requires that all the values are NON-NULL. |
| * This is the dense representation of the matrix where the matrix elements |
| * are indexed by the row and column index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_sparsify |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_sparsify(schema_madlib, matrix_in, in_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| /* Overloaded function */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_sparsify |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_sparsify($1, $2, $3, ''::TEXT); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_sparsify( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_sparsify_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_sparsify() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_sparsify(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| /** |
| * @brief Converts matrix to dense representation. It requires that all the values are NON-NULL. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param in_row Name of the column containing the row index for the input matrix |
| * @param in_col Name of the column containing the column index for the input matrix |
| * @param in_val Name of the column containing the matrix values for the input matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_densify |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_densify(schema_madlib, |
| matrix_in, in_args, matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_densify |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_densify($1, $2, $3, ''::TEXT); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_densify( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_densify_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_densify() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_densify(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| ------------------ Scale and add matrices ------------------------------ |
| /** |
| * @brief Scale and add matrix operation ( R <- A + sB) |
| * |
| * @param matrix_a Source matrix table A (dense matrix format) |
| * @param matrix_b Source matrix table B (dense matrix format) |
| * @param scale Scale for matrix B |
| * @param matrix_out Output table for matrix R <- A + sB |
| * |
| * @return VOID |
| * |
| * @usage |
| * For matrix addition and subtration, you can use the same function |
| * with different values of scalar |
| * <pre> |
| * SELECT matrix_scale_and_add('matrix_a', 'matrix_b', 1, 'matrix_out'); |
| * SELECT matrix_scale_and_add('matrix_a', 'matrix_b', -1, 'matrix_out'); |
| * </pre> |
| */ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_scale_and_add( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| scale DOUBLE PRECISION, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS VOID AS $$ |
| PythonFunction(linalg, matrix_ops, matrix_scale_and_add) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_scale_and_add( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| scale DOUBLE PRECISION, |
| matrix_out TEXT |
| ) |
| RETURNS VOID AS $$ |
| SELECT MADLIB_SCHEMA.matrix_scale_and_add( |
| $1, $2, $3, $4, $5, $6, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| ------------------ Matrix Norms ------------------------------ |
| |
| /** |
| * @brief Compute matrix norm (of various types) |
| * |
| * @param matrix_a Source matrix table (dense matrix format) |
| * @param norm_type Type of norm used (default: fro) |
| * |
| * @return DOUBLE PRECISION |
| * |
| * @usage Currenty, we support the following norms |
| * (a) 'fro': Computes the frobenius norm |
| * (b) 'one': Computes the one norm |
| * (c) 'inf': Computes the infinity norm |
| * (d) 'max': Computes the max norm |
| * (e) 'spec': Computes the spectral norm |
| * (f) '<positive float>': Computes the element-wise norm |
| * |
| * <pre> |
| * SELECT matrix_norm('<em>matrix_table_name</em>', 'fro'); |
| * </pre> |
| */ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_norm( |
| matrix_in TEXT, |
| in_args TEXT, |
| norm_type TEXT |
| ) |
| RETURNS DOUBLE PRECISION AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_norm(schema_madlib, |
| matrix_in, in_args, norm_type) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `READS SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_norm( |
| matrix_in TEXT, |
| in_args TEXT |
| ) |
| RETURNS DOUBLE PRECISION AS $$ |
| SELECT MADLIB_SCHEMA.matrix_norm($1, $2, 'fro'::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `READS SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_norm( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_norm_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_norm() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_norm(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_block_mult |
| ( |
| matrix_a TEXT, |
| a_args TEXT, |
| matrix_b TEXT, |
| b_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_block_mult(schema_madlib, matrix_a, a_args, |
| matrix_b, b_args, matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_block_square |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_block_square(schema_madlib, matrix_in, in_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_block_trans |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_block_trans(schema_madlib, matrix_in, in_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| /** |
| * @brief Calculate square of matrix. It requires that all the values are NON-NULL. |
| * This is the dense representation of the matrix where the matrix elements |
| * are indexed by the row index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_square |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_square(schema_madlib, matrix_in, in_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_square |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_square($1, $2, $3, ''::TEXT); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| /** |
| * @brief Create a diagonal matrix with a specified vector on the main diagonal. |
| * It always creates the sparse representation of the diagonal matrix where the matrix elements |
| * are indexed by the row and column index. |
| * @param diag_elements Name of the array containing the diagonal elements. |
| * It requaires Not NULL, Not empty, Not containing NULL elements |
| * @param matrix_out Name of the table where to output the result diagonal matrix |
| * @returns Name of the table containing the result diagonal matrix |
| */ |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_diag |
| ( |
| diag_elements FLOAT8[], |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_diag(schema_madlib, |
| diag_elements, matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_diag |
| ( |
| diag_elements FLOAT8[], |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_diag($1, $2, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_diag( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_diag_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_diag() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_diag(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief main diagonal matrix. It requires that all the matrix must be the square matrix. |
| * This is the sparse representation of the matrix where the matrix elements |
| * are indexed by the row and column index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param in_row Name of the column containing the row index for the input matrix |
| * @param in_col Name of the column containing the column index for the input matrix |
| * @param in_val Name of the column containing the matrix values for the input matrix |
| * @param use_temp_table Specify if use temp table for result |
| * @returns Array of main diagonal |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_extract_diag |
| ( |
| matrix_in TEXT, |
| in_args TEXT |
| ) |
| RETURNS float[] AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_extract_diag(schema_madlib, matrix_in, in_args) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_extract_diag( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_extract_diag_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_extract_diag() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_extract_diag(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief Create an identity matrix with the dimensionality specified by an integer. |
| * It can specify the sparse or dense representation of the result matrix. |
| * @param dim Name of a integer specifing the dimensinality. It requaires Not NULL, dim > 0. |
| * @param matrix_out Name of the table where to output the result identity matrix |
| * @param out_args Name-value pair string containing options for matrix_out |
| * @returns Name of the table containing the result identity matrix |
| */ |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_identity |
| ( |
| row_dim INTEGER, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_identity(schema_madlib, |
| row_dim, matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_identity |
| ( |
| row_dim INTEGER, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_identity($1, $2, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_identity( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_identity_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_identity() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_identity(''); |
| END |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| /** |
| * @brief Initializes matrix with random distribution. It requires that all the values are NON-NULL. |
| * @param distribution Name of the distribution to use (normal or uniform) |
| * @param row_dim Name of the column containing the row index for the one matrix |
| * @param col_dim Name of the column containing the column index for the one matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_random |
| ( |
| row_dim INTEGER, |
| col_dim INTEGER, |
| in_args TEXT, |
| distribution TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_random(schema_madlib, distribution, |
| row_dim, col_dim, in_args, matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_random |
| ( |
| row_id INTEGER, |
| col_id INTEGER, |
| distribution TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_random($1, $2, ''::TEXT, $3, $4, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_random |
| ( |
| row_id INTEGER, |
| col_id INTEGER, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_random($1, $2, 'uniform', $3) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| /** |
| * @brief Initializes matrix with ones. It requires that all the values are NON-NULL. |
| * @param row_dim Name of the column containing the row index for the one matrix |
| * @param col_dim Name of the column containing the column index for the one matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_ones |
| ( |
| row_dim INTEGER, |
| col_dim INTEGER, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_ones(schema_madlib, |
| row_dim, col_dim, matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_ones |
| ( |
| row_id INTEGER, |
| col_id INTEGER, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_ones($1, $2, $3, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_ones( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_ones_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_ones() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_ones(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| |
| /** |
| * @brief Initializes matrix with zeros. It requires that all the values are NON-NULL. |
| * @param row_id Name of the column containing the row index for the zero matrix |
| * @param col_id Name of the column containing the column index for the zero matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_zeros |
| ( |
| row_dim INTEGER, |
| col_dim INTEGER, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_zeros(schema_madlib, |
| row_dim, col_dim, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_zeros |
| ( |
| row_dim INTEGER, |
| col_dim INTEGER, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_zeros($1, $2, $3, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_zeros( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_zeros_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_zeros() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_zeros(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| /** |
| * @brief Calculate inverse of matrix. It requires that all the values are NON-NULL. |
| * This is the dense representation of the matrix where the matrix elements |
| * are indexed by the row index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_inverse |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_inverse(schema_madlib, matrix_in, in_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_inverse |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_inverse($1, $2, $3, ''::TEXT); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_inverse( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_inverse_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_inverse() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_inverse(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| /** |
| * @brief Calculate generalized inverse of matrix. It requires that all the |
| * values are NON-NULL. This is the dense representation of the matrix where |
| * the matrix elements are indexed by the row index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_pinv |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_pinv(schema_madlib, matrix_in, in_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_pinv |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_pinv($1, $2, $3, ''::TEXT); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_pinv( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_pinv_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_pinv() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_pinv(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| /** |
| * @brief Calculate full pivoting LU decomposition of matrix. It requires that all |
| * the values are NON-NULL. This is the dense representation of the matrix where the |
| * matrix elements are indexed by the row index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param matrix_p Name of the table where to output the result p matrix |
| * @param matrix_l Name of the table where to output the result l matrix |
| * @param matrix_u Name of the table where to output the result u matrix |
| * @param matrix_q Name of the table where to output the result q matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_lu |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out_prefix TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_lu(schema_madlib, matrix_in, in_args, |
| matrix_out_prefix, out_args) |
| result = """ |
| For LU decomposition with full pivoting (PAQ = LU), |
| the corresponding matrices can be obtained by appending following suffixes |
| to {0}: |
| _p for row permutation matrix P |
| _q for column permutation matrix Q |
| _l for lower triangular factor L |
| _u for upper triangular factor U |
| """.format(matrix_out_prefix) |
| return [result] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_lu |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out_prefix TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_lu($1, $2, $3, ''::TEXT); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_lu( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_lu_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_lu() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_lu(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| /** |
| * @brief Calculate eigenvalues of matrix. It requires that all the values are NON-NULL. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_eigen |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_eigen(schema_madlib, matrix_in, in_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_eigen |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_eigen($1, $2, $3, ''::TEXT) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_eigen( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_eigen_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_eigen() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_eigen(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| |
| /** |
| * @brief Cholesky decompose of matrix. |
| * Because it is required that input matrix should be symmetric, it is |
| * only the lower triangular part that will be used for the decompositon. |
| * The upper triangular part won't be read. |
| * It requires that all the values are NON-NULL. |
| * This is the dense representation of the matrix where the matrix elements |
| * are indexed by the row index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param matrix_out Name of the table where to output the result matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_cholesky |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out_prefix TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_cholesky(schema_madlib, matrix_in, in_args, |
| matrix_out_prefix, out_args) |
| result = """ |
| For Cholesky decomposition with left pivoting (PA = LDL*), |
| the corresponding matrices can be obtained by appending following suffixes |
| to {0}: |
| _p for row permutation matrix P |
| _l for lower triangular factor L |
| _d for diagonal matrix D |
| """.format(matrix_out_prefix) |
| return [result] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_cholesky |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out_prefix TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_cholesky($1, $2, $3, ''::TEXT); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_cholesky( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_cholesky_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_cholesky() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_cholesky(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| /** |
| * @brief QR decompose of matrix. It requires that all the values are NON-NULL. |
| * This is the dense representation of the matrix where the matrix elements |
| * are indexed by the row index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @param matrix_q Name of the table where to output the q matrix of QR decomposition |
| * @param matrix_r Name of the table where to output the r matrix of QR decomposition |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_qr |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out_prefix TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_qr(schema_madlib, matrix_in, in_args, |
| matrix_out_prefix, out_args) |
| result = """ |
| For QR decomposition (A = QR), |
| the corresponding matrices can be obtained by appending following suffixes |
| to {0}: |
| _q for orthogonal matrix Q |
| _r for upper triangular factor R |
| """.format(matrix_out_prefix) |
| return [result] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_qr |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out_prefix TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_qr($1, $2, $3, ''::TEXT); |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_qr( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_qr_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_qr() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_qr(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| /** |
| * @brief rank of matrix. It requires that all the values are NON-NULL. |
| * This is the dense representation of the matrix where the matrix elements |
| * are indexed by the row index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_rank |
| ( |
| matrix_in TEXT, |
| in_args TEXT |
| ) |
| RETURNS INT8 AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_rank(schema_madlib, matrix_in, in_args) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_rank( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_rank_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_rank() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_rank(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| /** |
| * @brief nuclear norm of matrix. It requires that all the values are NON-NULL. |
| * This is the dense representation of the matrix where the matrix elements |
| * are indexed by the row index. |
| * |
| * @param matrix_in Name of the table containing the input matrix |
| * @returns Name of the table containing the result matrix |
| * |
| */ |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_nuclear_norm |
| ( |
| matrix_in TEXT, |
| in_args TEXT |
| ) |
| RETURNS DOUBLE PRECISION AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| return matrix_ops.matrix_nuclear_norm(schema_madlib, matrix_in, in_args) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_nuclear_norm( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(linalg, matrix_help_message, matrix_nuclear_norm_help_message) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.matrix_nuclear_norm() |
| RETURNS TEXT AS $$ |
| BEGIN |
| RETURN MADLIB_SCHEMA.matrix_nuclear_norm(''); |
| END; |
| $$ LANGUAGE plpgsql IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| ------------------------------------------------------------------------- |
| ------------------------------------------------------------------------- |
| ------------------------------------------------------------------------- |
| |
| /* Internal functions */ |
| |
| /* |
| * @brief In-memory multiplication of a vector with a matrix |
| * @param vec a 1 x r vector |
| * @param mat a r x n matrix |
| * @return vec * mat |
| */ |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_vec_mult_in_mem( |
| vector FLOAT8[], |
| matrix FLOAT8[][] |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'matrix_vec_mult_in_mem_2d' |
| LANGUAGE C STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| /* |
| * @brief In-memory broadcast multiplication of a vector with a vector |
| * @param vec1 a vector with r elements |
| * @param vec2 a vector with multiples (n) of r elements |
| * @note first cast vec2 to r x n matrix mat in column-major, then return trans(mat) * vec1 |
| */ |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_vec_mult_in_mem( |
| vector FLOAT8[], |
| matrix FLOAT8[] |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'matrix_vec_mult_in_mem_1d' |
| LANGUAGE C STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| /** |
| * @brief The function folds (through multiplication) array x according to |
| * the pattern in array y, producing an array of the same length as array y. |
| * @param row Array x |
| * @param pattern Array y |
| * @param folded array |
| */ |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__row_fold( |
| row_in FLOAT8[], |
| pattern INTEGER[] |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'row_fold' |
| LANGUAGE C STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__bernoulli_vector |
| ( |
| dim INTEGER, |
| pos_val FLOAT8, |
| neg_val FLOAT8, |
| prob FLOAT8, |
| seed INTEGER |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'bernoulli_vector' |
| LANGUAGE C STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__bernoulli_vector |
| ( |
| dim INTEGER |
| ) |
| RETURNS FLOAT8[] AS $$ |
| SELECT MADLIB_SCHEMA.__bernoulli_vector($1, 1::FLOAT8, 0::FLOAT8, 0.5::FLOAT8, 42::INTEGER) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__uniform_vector |
| ( |
| dim INTEGER, |
| a FLOAT8, |
| b FLOAT8, |
| seed INTEGER |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'uniform_vector' |
| LANGUAGE C STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__uniform_vector |
| ( |
| dim INTEGER, |
| a FLOAT8, |
| b FLOAT8 |
| ) |
| RETURNS FLOAT8[] AS $$ |
| SELECT MADLIB_SCHEMA.__uniform_vector($1, $2, $3, 42::INTEGER) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__normal_vector |
| ( |
| dim INTEGER, |
| mu FLOAT8, |
| sigma FLOAT8, |
| seed INTEGER |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'normal_vector' |
| LANGUAGE C STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__normal_vector |
| ( |
| dim INTEGER, |
| mu FLOAT8, |
| sigma FLOAT8 |
| ) |
| RETURNS FLOAT8[] AS $$ |
| SELECT MADLIB_SCHEMA.__normal_vector($1, $2, $3, 42::INTEGER) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__rand_vector |
| ( |
| dim INTEGER |
| ) |
| RETURNS INTEGER[] |
| AS 'MODULE_PATHNAME', 'rand_vector' |
| LANGUAGE C STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__rand_block |
| ( |
| row_dim INTEGER, |
| col_dim INTEGER |
| ) |
| RETURNS INTEGER[] |
| AS 'MODULE_PATHNAME', 'rand_block' |
| LANGUAGE C STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__rand_block |
| ( |
| dim INTEGER |
| ) |
| RETURNS INTEGER[] AS $$ |
| SELECT MADLIB_SCHEMA.__rand_block($1, $1); |
| $$ LANGUAGE sql STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__matrix_row_split |
| ( |
| row_in FLOAT8[], |
| size INTEGER |
| ) |
| RETURNS SETOF FLOAT8[] |
| AS 'MODULE_PATHNAME', 'row_split' |
| LANGUAGE C STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__matrix_densify_sfunc |
| ( |
| state FLOAT8[], |
| col_dim INTEGER, |
| col_id INTEGER, |
| val FLOAT8 |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'matrix_densify_sfunc' |
| LANGUAGE C |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| DROP AGGREGATE IF EXISTS |
| MADLIB_SCHEMA.__matrix_densify_agg |
| ( |
| INTEGER, -- col_dim |
| INTEGER, -- col_id |
| FLOAT8 -- value |
| ); |
| |
| CREATE AGGREGATE |
| MADLIB_SCHEMA.__matrix_densify_agg |
| ( |
| INTEGER, -- col_dim |
| INTEGER, -- col_id |
| FLOAT8 -- value |
| ) |
| ( |
| stype = FLOAT8[], |
| sfunc = MADLIB_SCHEMA.__matrix_densify_sfunc |
| ); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__array_abs_add_sfunc |
| ( |
| x anyarray, |
| y anyarray |
| ) |
| RETURNS anyarray AS $$ |
| SELECT MADLIB_SCHEMA.array_add(MADLIB_SCHEMA.array_abs($1), MADLIB_SCHEMA.array_abs($2)); |
| $$ LANGUAGE sql STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| DROP AGGREGATE IF EXISTS |
| MADLIB_SCHEMA.__matrix_column_abs_sum_agg |
| ( |
| anyarray -- row array |
| ); |
| |
| CREATE AGGREGATE |
| MADLIB_SCHEMA.__matrix_column_abs_sum_agg |
| ( |
| anyarray -- row array |
| ) |
| ( |
| stype = anyarray, |
| sfunc = MADLIB_SCHEMA.__array_abs_add_sfunc |
| ); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__matrix_blockize_sfunc |
| ( |
| state FLOAT8[], |
| row_id INTEGER, |
| row_vec FLOAT8[], |
| rsize INTEGER |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'matrix_blockize_sfunc' |
| LANGUAGE C |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| DROP AGGREGATE IF EXISTS |
| MADLIB_SCHEMA.__matrix_blockize_agg |
| ( |
| INTEGER, -- row_id |
| FLOAT8[], -- row_vec |
| INTEGER -- row_dim |
| ); |
| |
| CREATE AGGREGATE |
| MADLIB_SCHEMA.__matrix_blockize_agg |
| ( |
| INTEGER, -- row_id |
| FLOAT8[], -- row_vec |
| INTEGER -- row_dim |
| ) |
| ( |
| stype = FLOAT8[], |
| sfunc = MADLIB_SCHEMA.__matrix_blockize_sfunc |
| ); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__matrix_unblockize_sfunc |
| ( |
| state FLOAT8[], |
| total_col_dim INTEGER, |
| col_id INTEGER, |
| row_vec FLOAT8[] |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'matrix_unblockize_sfunc' |
| LANGUAGE C |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| DROP AGGREGATE IF EXISTS |
| MADLIB_SCHEMA.__matrix_unblockize_agg |
| ( |
| INTEGER, -- col_dim |
| INTEGER, -- col_id |
| FLOAT8[] -- row_vec |
| ); |
| |
| CREATE AGGREGATE |
| MADLIB_SCHEMA.__matrix_unblockize_agg |
| ( |
| INTEGER, -- col_dim |
| INTEGER, -- col_id |
| FLOAT8[] -- row_vec |
| ) |
| ( |
| stype = FLOAT8[], |
| sfunc = MADLIB_SCHEMA.__matrix_unblockize_sfunc |
| ); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_mem_mult |
| ( |
| matrix_a FLOAT[], |
| matrix_b FLOAT[], |
| trans_b BOOLEAN |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'matrix_mem_mult' |
| LANGUAGE C |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_mem_mult |
| ( |
| matrix_a FLOAT[], |
| matrix_b FLOAT[] |
| ) |
| RETURNS FLOAT8[] AS $$ |
| SELECT MADLIB_SCHEMA.matrix_mem_mult($1, $2, false); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| -- CREATE OR REPLACE FUNCTION |
| -- MADLIB_SCHEMA.matrix_vec_mem_mult |
| -- ( |
| -- matrix_a FLOAT[], |
| -- vector_b FLOAT[] |
| -- ) |
| -- RETURNS FLOAT8[] |
| -- AS 'MODULE_PATHNAME', 'matrix_vec_mem_mult' |
| -- $$ LANGUAGE C; |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_mem_trans |
| ( |
| matrix FLOAT[] |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'matrix_mem_trans' |
| LANGUAGE C |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__matrix_mem_sum_sfunc |
| ( |
| state FLOAT[], |
| matrix FLOAT[] |
| ) |
| RETURNS FLOAT8[] |
| AS 'MODULE_PATHNAME', 'matrix_mem_sum_sfunc' |
| LANGUAGE C |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| DROP AGGREGATE IF EXISTS |
| MADLIB_SCHEMA.__matrix_mem_sum |
| ( |
| FLOAT8[] |
| ); |
| |
| CREATE AGGREGATE |
| MADLIB_SCHEMA.__matrix_mem_sum |
| ( |
| FLOAT8[] |
| ) |
| ( |
| stype = FLOAT8[], |
| sfunc = MADLIB_SCHEMA.__matrix_mem_sum_sfunc |
| ); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__matrix_column_to_array_format |
| ( |
| matrix_in TEXT, |
| row_id TEXT, |
| matrix_out TEXT, |
| istemp BOOLEAN |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops._matrix_column_to_array_format(matrix_in, row_id, matrix_out, istemp) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_blockize |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| rsize INTEGER, |
| csize INTEGER, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_blockize(schema_madlib, matrix_in, in_args, rsize, csize, matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_blockize |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| rsize INTEGER, |
| csize INTEGER, |
| matrix_out TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| SELECT MADLIB_SCHEMA.matrix_blockize($1, $2, $3, $4, $5, ''::text) |
| $$ LANGUAGE SQL |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.matrix_unblockize |
| ( |
| matrix_in TEXT, |
| in_args TEXT, |
| matrix_out TEXT, |
| out_args TEXT |
| ) |
| RETURNS MADLIB_SCHEMA.matrix_result AS $$ |
| PythonFunctionBodyOnly(`linalg', `matrix_ops') |
| with AOControl(False): |
| matrix_ops.matrix_unblockize(schema_madlib, matrix_in, in_args, |
| matrix_out, out_args) |
| return [matrix_out] |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| CREATE OR REPLACE FUNCTION |
| MADLIB_SCHEMA.__matrix_unnest_block |
| ( |
| block FLOAT8[] |
| ) |
| RETURNS SETOF FLOAT8[] |
| AS 'MODULE_PATHNAME', 'unnest_block' |
| LANGUAGE C IMMUTABLE STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| ------------------------------------------------------------------------- |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_compose_dense_transition( |
| state DOUBLE PRECISION[], |
| numRows INTEGER, |
| row_id INTEGER, |
| x DOUBLE PRECISION[] |
| ) RETURNS DOUBLE PRECISION[] |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_compose_dense_transition' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_compose_sparse_transition( |
| state DOUBLE PRECISION[], |
| numRows INTEGER, |
| numCols INTEGER, |
| row_id INTEGER, |
| col_id INTEGER, |
| x DOUBLE PRECISION |
| ) RETURNS DOUBLE PRECISION[] |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_compose_sparse_transition' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_compose_merge( |
| stateLeft DOUBLE PRECISION[], |
| stateRight DOUBLE PRECISION[] |
| ) RETURNS DOUBLE PRECISION[] |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_compose_merge' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_inv_final( |
| state DOUBLE PRECISION[] |
| ) RETURNS DOUBLE PRECISION[] |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_inv' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_pinv_final( |
| state DOUBLE PRECISION[] |
| ) RETURNS DOUBLE PRECISION[] |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_pinv' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_eigen_final( |
| state DOUBLE PRECISION[] |
| ) RETURNS DOUBLE PRECISION[] |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_eigen' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_cholesky_final( |
| state DOUBLE PRECISION[] |
| ) RETURNS DOUBLE PRECISION[] |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_cholesky' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_qr_final( |
| state DOUBLE PRECISION[] |
| ) RETURNS DOUBLE PRECISION[] |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_qr' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_rank_final( |
| state DOUBLE PRECISION[] |
| ) RETURNS INT8 |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_rank' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_lu_final( |
| state DOUBLE PRECISION[] |
| ) RETURNS DOUBLE PRECISION[] |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_lu' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__matrix_nuclear_norm_final( |
| state DOUBLE PRECISION[] |
| ) RETURNS DOUBLE PRECISION |
| LANGUAGE c |
| IMMUTABLE |
| STRICT |
| AS 'MODULE_PATHNAME', 'matrix_nuclear_norm' |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL'); |
| |
| /** |
| * @brief Compute inverse of a dense matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_dense_inverse( |
| INTEGER, INTEGER, DOUBLE PRECISION []); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_dense_inverse( |
| /*+ numRows */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION[] |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_dense_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_inv_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute inverse of a sparse matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_sparse_inverse( |
| INTEGER, INTEGER, INTEGER, INTEGER, DOUBLE PRECISION); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_sparse_inverse( |
| /*+ numRows */ INTEGER, |
| /*+ numCols */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ col_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_sparse_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_inv_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute generalized inverse of a dense matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_dense_pinv( |
| INTEGER, INTEGER, DOUBLE PRECISION []); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_dense_pinv( |
| /*+ numRows */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION[] |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_dense_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_pinv_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute generalized inverse of a sparse matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_sparse_pinv( |
| INTEGER, INTEGER, INTEGER, INTEGER, DOUBLE PRECISION); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_sparse_pinv( |
| /*+ numRows */ INTEGER, |
| /*+ numCols */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ col_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_sparse_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_pinv_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute eigen values of a dense matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_dense_eigen( |
| INTEGER, INTEGER, DOUBLE PRECISION []); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_dense_eigen( |
| /*+ numRows */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION[] |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_dense_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_eigen_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute inverse of a sparse matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_sparse_eigen( |
| INTEGER, INTEGER, INTEGER, INTEGER, DOUBLE PRECISION); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_sparse_eigen( |
| /*+ numRows */ INTEGER, |
| /*+ numCols */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ col_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_sparse_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_eigen_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Cholesky decompose of a dense matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_dense_cholesky( |
| INTEGER, INTEGER, DOUBLE PRECISION []); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_dense_cholesky( |
| /*+ numRows */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION[] |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_dense_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_cholesky_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Cholesky decompose of a sparse matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_sparse_cholesky( |
| INTEGER, INTEGER, INTEGER, INTEGER, DOUBLE PRECISION); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_sparse_cholesky( |
| /*+ numRows */ INTEGER, |
| /*+ numCols */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ col_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_sparse_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_cholesky_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief QR decompose of a dense matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_dense_qr( |
| INTEGER, INTEGER, DOUBLE PRECISION []); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_dense_qr( |
| /*+ numRows */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION[] |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_dense_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_qr_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief QR decompose of a sparse matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_sparse_qr( |
| INTEGER, INTEGER, INTEGER, INTEGER, DOUBLE PRECISION); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_sparse_qr( |
| /*+ numRows */ INTEGER, |
| /*+ numCols */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ col_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_sparse_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_qr_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute rank of a dense matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_dense_rank( |
| INTEGER, INTEGER, DOUBLE PRECISION []); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_dense_rank( |
| /*+ numRows */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION[] |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_dense_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_rank_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute rank of a sparse matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_sparse_rank( |
| INTEGER, INTEGER, INTEGER, INTEGER, DOUBLE PRECISION); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_sparse_rank( |
| /*+ numRows */ INTEGER, |
| /*+ numCols */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ col_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_sparse_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_rank_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute full pivoting LU decomposition of a dense matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_dense_lu( |
| INTEGER, INTEGER, DOUBLE PRECISION []); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_dense_lu( |
| /*+ numRows */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION[] |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_dense_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_lu_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute full pivoting LU decomposition of a sparse matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_sparse_lu( |
| INTEGER, INTEGER, INTEGER, INTEGER, DOUBLE PRECISION); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_sparse_lu( |
| /*+ numRows */ INTEGER, |
| /*+ numCols */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ col_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_sparse_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_lu_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute nuclear norm of a dense matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_dense_nuclear_norm( |
| INTEGER, INTEGER, DOUBLE PRECISION []); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_dense_nuclear_norm( |
| /*+ numRows */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION[] |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_dense_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_nuclear_norm_final, |
| INITCOND='{0,0,0}' |
| ); |
| |
| /** |
| * @brief Compute nuclear norm of a sparse matrix |
| */ |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__matrix_sparse_nuclear_norm( |
| INTEGER, INTEGER, INTEGER, INTEGER, DOUBLE PRECISION); |
| CREATE AGGREGATE MADLIB_SCHEMA.__matrix_sparse_nuclear_norm( |
| /*+ numRows */ INTEGER, |
| /*+ numCols */ INTEGER, |
| /*+ row_id */ INTEGER, |
| /*+ col_id */ INTEGER, |
| /*+ x */ DOUBLE PRECISION |
| |
| ) ( |
| STYPE=DOUBLE PRECISION[], |
| SFUNC=MADLIB_SCHEMA.__matrix_compose_sparse_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `PREFUNC=MADLIB_SCHEMA.__matrix_compose_merge,') |
| FINALFUNC=MADLIB_SCHEMA.__matrix_nuclear_norm_final, |
| INITCOND='{0,0,0}' |
| ); |