php-armadillo/src/matrix.cc

//
// php-armadillo/matrix.cc
//
// @Author CismonX
//

#include "matrix.hh"
#include "mat.hh"

#include <armadillo>

namespace php_arma
{
    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, nRows, T, T1)
    {
        auto native = THIS_NATIVE;
        RETVAL_LONG(native->n_rows);
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, nCols, T, T1)
    {
        auto native = THIS_NATIVE;
        RETVAL_LONG(native->n_cols);
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, isVec, T, T1)
    {
        auto native = THIS_NATIVE;
        RETVAL_BOOL(native->is_vec());
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, isCol, T, T1)
    {
        auto native = THIS_NATIVE;
        RETVAL_BOOL(native->is_colvec());
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, isRow, T, T1)
    {
        auto native = THIS_NATIVE;
        RETVAL_BOOL(native->is_rowvec());
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, isSquare, T, T1)
    {
        auto native = THIS_NATIVE;
        RETVAL_BOOL(native->is_square());
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, isSymmetric, T, T1)
    {
        zval *tol = nullptr;
        ZEND_PARSE_PARAMETERS_START(0, 1)
            Z_PARAM_OPTIONAL
            Z_PARAM_ZVAL(tol)
        ZEND_PARSE_PARAMETERS_END();

        auto native = THIS_NATIVE;

        if (tol == nullptr) {
            RETURN_BOOL(native->is_symmetric());
        }

        using base_t = typename arma::get_pod_type<T>::result;
        if (!zval_check_scalar<base_t>(tol)) {
            return;
        }
        RETVAL_BOOL(native->is_symmetric(zval_get_scalar<base_t>(tol)));
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, isHermitian, T, T1)
    {
        zval *tol = nullptr;
        ZEND_PARSE_PARAMETERS_START(0, 1)
            Z_PARAM_OPTIONAL
            Z_PARAM_ZVAL(tol)
        ZEND_PARSE_PARAMETERS_END();

        auto native = THIS_NATIVE;

        if (tol == nullptr) {
            RETURN_BOOL(native->is_hermitian());
        }

        using base_t = typename arma::get_pod_type<T>::result;
        if (!zval_check_scalar<base_t>(tol)) {
            return;
        }
        RETVAL_BOOL(native->is_hermitian(zval_get_scalar<base_t>(tol)));
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, inRange, T, T1)
    {
        zend_long row;
        zend_long col;
        ZEND_PARSE_PARAMETERS_START(1, 2)
            Z_PARAM_LONG(row)
            Z_PARAM_OPTIONAL
            Z_PARAM_LONG(col)
        ZEND_PARSE_PARAMETERS_END();

        auto native = THIS_NATIVE;

        if (EX_NUM_ARGS() == 1) {
            RETURN_BOOL(native->in_range(row));
        }
        RETVAL_BOOL(native->in_range(row, col));
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, swapRows, T, T1)
    {
        zend_long row_1;
        zend_long row_2;
        ZEND_PARSE_PARAMETERS_START(2, 2)
            Z_PARAM_LONG(row_1)
            Z_PARAM_LONG(row_2)
        ZEND_PARSE_PARAMETERS_END();

        auto native = THIS_NATIVE;
        native->swap_rows(row_1, row_2);
    }

    template <typename T, typename T1>
    PHP_ARMA_METHOD(matrix, swapCols, T, T1)
    {
        zend_long col_1;
        zend_long col_2;
        ZEND_PARSE_PARAMETERS_START(2, 2)
            Z_PARAM_LONG(col_1)
            Z_PARAM_LONG(col_2)
        ZEND_PARSE_PARAMETERS_END();

        auto native = THIS_NATIVE;
        native->swap_cols(col_1, col_2);
    }

    template <typename T, typename ChildT>
    PHP_ARMA_METHOD(matrix, t, T, ChildT)
    {
        auto native = THIS_NATIVE;
        zend_object *zobj;
        
        if constexpr (std::is_same_v<T, cx_double>) {
            zend_bool conj = true;
            ZEND_PARSE_PARAMETERS_START(0, 1)
                Z_PARAM_OPTIONAL
                Z_PARAM_BOOL(conj)
            ZEND_PARSE_PARAMETERS_END();

            if (conj) {
                zobj = ChildT::create(std::move(native->t().eval()));
            } else {
                zobj = ChildT::create(std::move(native->st().eval()));
            }
        } else {
            zobj = ChildT::create(std::move(native->t().eval()));
        }

        RETVAL_OBJ(zobj);
    }

    template <typename T, typename T1>
    PHP_ARMA_START_ME(matrix, T, T1)
        PHP_ARMA_ME(nRows,       ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(nCols,       ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(isVec,       ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(isCol,       ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(isRow,       ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(isSquare,    ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(isSymmetric, ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(isHermitian, ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(inRange,     ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(swapRows,    ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(swapCols,    ZEND_ACC_PUBLIC)
        PHP_ARMA_ME(t,           ZEND_ACC_PUBLIC)
    PHP_ARMA_END_ME();

    void matrix_init()
    {
        matrix_ce = interface_register<matrix_php_name>();
    }

    PHP_ARMA_INSTANTIATE(matrix, mat);
}