222 lines
8.2 KiB
C++
222 lines
8.2 KiB
C++
//
|
|
// php-armadillo/base.hh
|
|
//
|
|
// @Author CismonX
|
|
//
|
|
|
|
#ifndef PHP_ARMA_BASE_HH
|
|
#define PHP_ARMA_BASE_HH
|
|
|
|
#include "php_arma.hh"
|
|
#include "complex.hh"
|
|
|
|
#ifdef PHP_ARMA_OPERATORS
|
|
|
|
#define PHP_ARMA_BASE_OPERATOR_EX2(cls, type, func) \
|
|
PHP_ARMA_OPERATOR_EX2((base<type, cls<type>>), cls<type>, func)
|
|
|
|
#define PHP_ARMA_BASE_OPERATOR_EX(cls, func) \
|
|
PHP_ARMA_BASE_OPERATOR_EX2(cls, double, func) \
|
|
PHP_ARMA_BASE_OPERATOR_EX2(cls, zend_long, func) \
|
|
PHP_ARMA_BASE_OPERATOR_EX2(cls, cx_double, func)
|
|
|
|
#define PHP_ARMA_BASE_OPERATOR(func) \
|
|
PHP_ARMA_OPERATOR_BEGIN(base_ce) \
|
|
PHP_ARMA_BASE_OPERATOR_EX(mat, func) \
|
|
PHP_ARMA_BASE_OPERATOR_EX(subview_mat, func) \
|
|
PHP_ARMA_OPERATOR_END()
|
|
|
|
#define PHP_ARMA_BASE_ASSIGN_OPERATOR_EX2(cls, type, func) \
|
|
PHP_ARMA_ASSIGN_OPERATOR_EX2((base<type, cls<type>>), cls<type>, func)
|
|
|
|
#define PHP_ARMA_BASE_ASSIGN_OPERATOR_EX(cls, func) \
|
|
PHP_ARMA_BASE_ASSIGN_OPERATOR_EX2(cls, double, func) \
|
|
PHP_ARMA_BASE_ASSIGN_OPERATOR_EX2(cls, zend_long, func) \
|
|
PHP_ARMA_BASE_ASSIGN_OPERATOR_EX2(cls, cx_double, func)
|
|
|
|
#define PHP_ARMA_BASE_ASSIGN_OPERATOR(func) \
|
|
PHP_ARMA_OPERATOR_BEGIN(base_ce) \
|
|
PHP_ARMA_BASE_ASSIGN_OPERATOR_EX(mat, func) \
|
|
PHP_ARMA_BASE_ASSIGN_OPERATOR_EX(subview_mat, func) \
|
|
PHP_ARMA_OPERATOR_END()
|
|
|
|
#endif // PHP_ARMA_OPERATORS
|
|
|
|
namespace php_arma
|
|
{
|
|
template <typename T, typename ChildT>
|
|
struct base
|
|
{
|
|
using native_t = typename ChildT::native_t;
|
|
|
|
struct operators;
|
|
|
|
template <bool AcceptScalar, typename F>
|
|
zend_always_inline
|
|
static bool arithmetic_op(zval *zv1, zval *zv2, zval *return_value, F&& func)
|
|
{
|
|
bool zv2_is_scalar = false;
|
|
if (Z_TYPE_P(zv2) != IS_OBJECT) {
|
|
if constexpr (AcceptScalar && !std::is_same_v<T, cx_double>) {
|
|
if (EXPECTED(zval_is_scalar<T>(zv2))) {
|
|
zv2_is_scalar = true;
|
|
goto op_body;
|
|
}
|
|
}
|
|
throw_exception_ex(zend_ce_type_error, "bad arithmetic operation, unsupported type");
|
|
return false;
|
|
}
|
|
|
|
op_body:
|
|
using n_orig_t = typename ChildT::orig_t::native_t;
|
|
using n_subview_t = typename ChildT::subview_t::native_t;
|
|
try {
|
|
std::optional<n_orig_t> ret;
|
|
auto o1 = Z_OBJ_P(zv1);
|
|
decltype(o1) o2;
|
|
if (zv2_is_scalar) {
|
|
if constexpr (AcceptScalar) {
|
|
auto scalar_val = zval_get_scalar<T>(zv2);
|
|
if (Z_OBJCE_P(zv1) == ChildT::orig_t::ce) {
|
|
ret = func(to_native_object<n_orig_t>(o1), &scalar_val);
|
|
} else if (EXPECTED(Z_OBJCE_P(zv1) == ChildT::subview_t::ce)) {
|
|
ret = func(to_native_object<n_subview_t>(o1), &scalar_val);
|
|
} else {
|
|
goto not_orig_or_subview;
|
|
}
|
|
} else {
|
|
__builtin_unreachable();
|
|
}
|
|
} else {
|
|
o2 = Z_OBJ_P(zv2);
|
|
if (Z_OBJCE_P(zv1) == ChildT::orig_t::ce) {
|
|
if (Z_OBJCE_P(zv2) == ChildT::orig_t::ce) {
|
|
ret = func(to_native_object<n_orig_t>(o1), to_native_object<n_orig_t>(o2));
|
|
} else if (EXPECTED(Z_OBJCE_P(zv2) == ChildT::subview_t::ce)) {
|
|
ret = func(to_native_object<n_orig_t>(o1), to_native_object<n_subview_t>(o2));
|
|
} else {
|
|
goto not_orig_or_subview;
|
|
}
|
|
} else if (EXPECTED(Z_OBJCE_P(zv1) == ChildT::subview_t::ce)) {
|
|
if (Z_OBJCE_P(zv2) == ChildT::orig_t::ce) {
|
|
ret = func(to_native_object<n_subview_t>(o1), to_native_object<n_orig_t>(o2));
|
|
} else if (EXPECTED(Z_OBJCE_P(zv2) == ChildT::subview_t::ce)) {
|
|
ret = func(to_native_object<n_subview_t>(o1), to_native_object<n_subview_t>(o2));
|
|
} else {
|
|
goto not_orig_or_subview;
|
|
}
|
|
} else {
|
|
not_orig_or_subview:
|
|
throw_exception_ex(zend_ce_type_error, "bad arithmetic operation, object types should be the same");
|
|
return false;
|
|
}
|
|
}
|
|
if (zv1 == return_value) {
|
|
// Release first operand in case of assign operator to prevent memory leak.
|
|
zval_ptr_dtor(zv1);
|
|
}
|
|
RETVAL_OBJ(ChildT::orig_t::create(std::move(*ret)));
|
|
return true;
|
|
} catch (const std::logic_error& err) {
|
|
throw_error(err.what());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
zend_always_inline
|
|
static int count_elements(zval *zv, zend_long *count)
|
|
{
|
|
*count = Z_NATIVE_OBJ_P(zv)->n_elem;
|
|
return SUCCESS;
|
|
}
|
|
|
|
PHP_ARMA_COMMON_DECLARE();
|
|
|
|
private:
|
|
static PHP_FUNCTION(nElem);
|
|
static PHP_FUNCTION(add);
|
|
static PHP_FUNCTION(sub);
|
|
static PHP_FUNCTION(neg);
|
|
static PHP_FUNCTION(mul);
|
|
static PHP_FUNCTION(dotMul);
|
|
static PHP_FUNCTION(div);
|
|
static PHP_FUNCTION(replace);
|
|
static PHP_FUNCTION(transform);
|
|
static PHP_FUNCTION(forEach);
|
|
static PHP_FUNCTION(min);
|
|
static PHP_FUNCTION(max);
|
|
static PHP_FUNCTION(indexMin);
|
|
static PHP_FUNCTION(indexMax);
|
|
static PHP_FUNCTION(isEmpty);
|
|
static PHP_FUNCTION(isFinite);
|
|
static PHP_FUNCTION(hasInf);
|
|
static PHP_FUNCTION(hasNan);
|
|
static PHP_FUNCTION(print);
|
|
static PHP_FUNCTION(rawPrint);
|
|
static PHP_FUNCTION(__toString);
|
|
static PHP_FUNCTION(__debugInfo);
|
|
};
|
|
|
|
void base_init();
|
|
|
|
constexpr const char base_php_name[] = "Base";
|
|
|
|
inline zend_class_entry *base_ce;
|
|
|
|
template <typename T, typename ChildT>
|
|
struct base<T, ChildT>::operators
|
|
{
|
|
static bool add(zval *zv1, zval *zv2, zval *retval)
|
|
{
|
|
return arithmetic_op<true>(zv1, zv2, retval, [](auto v1, auto v2) {
|
|
return (*v1 + *v2).eval();
|
|
});
|
|
}
|
|
|
|
static bool sub(zval *zv1, zval *zv2, zval *retval)
|
|
{
|
|
return arithmetic_op<true>(zv1, zv2, retval, [](auto v1, auto v2) {
|
|
return (*v1 - *v2).eval();
|
|
});
|
|
}
|
|
|
|
static bool neg(zval *zv, zval *retval)
|
|
{
|
|
return arithmetic_op<false>(zv, zv, retval, [](auto v1, auto v2) {
|
|
return (-*v1).eval();
|
|
});
|
|
}
|
|
|
|
static bool mul(zval *zv1, zval *zv2, zval *retval)
|
|
{
|
|
#if PHP_VERSION_ID >= 70300
|
|
if (Z_TYPE_P(zv2) == IS_LONG && Z_LVAL_P(zv2) == -1) {
|
|
return neg(zv1, retval);
|
|
#else
|
|
if (Z_TYPE_P(zv1) == IS_LONG && Z_LVAL_P(zv1) == -1) {
|
|
return neg(zv2, retval);
|
|
#endif
|
|
}
|
|
return arithmetic_op<true>(zv1, zv2, retval, [](auto v1, auto v2) {
|
|
return (*v1 * *v2).eval();
|
|
});
|
|
}
|
|
|
|
static bool dotMul(zval *zv1, zval *zv2, zval *retval)
|
|
{
|
|
return arithmetic_op<false>(zv1, zv2, retval, [](auto v1, auto v2) {
|
|
return (*v1 % *v2).eval();
|
|
});
|
|
}
|
|
|
|
static bool div(zval *zv1, zval *zv2, zval *retval)
|
|
{
|
|
return arithmetic_op<true>(zv1, zv2, retval, [](auto v1, auto v2) {
|
|
return (*v1 / *v2).eval();
|
|
});
|
|
}
|
|
};
|
|
}
|
|
|
|
#endif // !PHP_ARMA_BASE_HH
|