diff options
Diffstat (limited to 'ext/gmp')
51 files changed, 4210 insertions, 0 deletions
diff --git a/ext/gmp/CREDITS b/ext/gmp/CREDITS new file mode 100644 index 0000000..7e0346d --- /dev/null +++ b/ext/gmp/CREDITS @@ -0,0 +1,2 @@ +GNU GMP support +Stanislav Malyshev diff --git a/ext/gmp/README b/ext/gmp/README new file mode 100644 index 0000000..e142e2e --- /dev/null +++ b/ext/gmp/README @@ -0,0 +1,5 @@ +Arbitrary length number support with GNU MP library. +Please see the PGP manual for more documentation. +See also GNU MP home page at http://www.swox.com/gmp/. +GNU MP library is available under the tems of GNU LGPL +license. Please see http://www.swox.com/gmp/lgpl.html diff --git a/ext/gmp/TODO b/ext/gmp/TODO new file mode 100644 index 0000000..81098a9 --- /dev/null +++ b/ext/gmp/TODO @@ -0,0 +1,22 @@ +mpz_mul_2exp +mpz_[ft]div_[qr]_2exp + +V 3: +mpz_nextprime +mpz_addmul +mpz_root +mpz_perfect_power_p +mpz_lcm +mpz_si_kronecker +mpz_kronecker_si +mpz_remove +mpz_bin_ui +mpz_fib_ui +mpz_cmpabs +mpz_xor +mpz_tstbit +mpz_urandom[bm] +mpz_fits_slong_p +mpz_mul_si +mpz_odd_p +mpz_even_p diff --git a/ext/gmp/config.m4 b/ext/gmp/config.m4 new file mode 100644 index 0000000..9606b2f --- /dev/null +++ b/ext/gmp/config.m4 @@ -0,0 +1,36 @@ +dnl +dnl $Id$ +dnl + +PHP_ARG_WITH(gmp, for GNU MP support, +[ --with-gmp[=DIR] Include GNU MP support]) + +if test "$PHP_GMP" != "no"; then + + for i in $PHP_GMP /usr/local /usr; do + test -f $i/include/gmp.h && GMP_DIR=$i && break + done + + if test -z "$GMP_DIR"; then + AC_MSG_ERROR(Unable to locate gmp.h) + fi + + PHP_CHECK_LIBRARY(gmp, __gmp_randinit_lc_2exp_size, + [],[ + PHP_CHECK_LIBRARY(gmp, gmp_randinit_lc_2exp_size, + [],[ + AC_MSG_ERROR([GNU MP Library version 4.1.2 or greater required.]) + ],[ + -L$GMP_DIR/$PHP_LIBDIR + ]) + ],[ + -L$GMP_DIR/$PHP_LIBDIR + ]) + + PHP_ADD_LIBRARY_WITH_PATH(gmp, $GMP_DIR/$PHP_LIBDIR, GMP_SHARED_LIBADD) + PHP_ADD_INCLUDE($GMP_DIR/include) + + PHP_NEW_EXTENSION(gmp, gmp.c, $ext_shared) + PHP_SUBST(GMP_SHARED_LIBADD) + AC_DEFINE(HAVE_GMP, 1, [ ]) +fi diff --git a/ext/gmp/config.w32 b/ext/gmp/config.w32 new file mode 100644 index 0000000..8c863f9 --- /dev/null +++ b/ext/gmp/config.w32 @@ -0,0 +1,15 @@ +// $Id$ +// vim:ft=javascript + +ARG_WITH("gmp", "Include GNU MP support.", "no"); + +if (PHP_GMP != "no") { + if (CHECK_LIB("mpir_a.lib", "gmp", PHP_GMP) && + CHECK_HEADER_ADD_INCLUDE("gmp.h", "CFLAGS_GMP", PHP_GMP + ";" + PHP_PHP_BUILD + "\\include\\mpir")) { + EXTENSION("gmp", "gmp.c"); + AC_DEFINE('HAVE_GMP', 1, 'GMP support'); + AC_DEFINE('HAVE_MPIR', 1, 'MPIR support'); + } else { + WARNING("GMP not enabled; libraries and headers not found"); + } +} diff --git a/ext/gmp/gmp.c b/ext/gmp/gmp.c new file mode 100644 index 0000000..c9da09b --- /dev/null +++ b/ext/gmp/gmp.c @@ -0,0 +1,1643 @@ +/* + +----------------------------------------------------------------------+ + | PHP Version 5 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997-2013 The PHP Group | + +----------------------------------------------------------------------+ + | This source file is subject to version 3.01 of the PHP license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.php.net/license/3_01.txt | + | If you did not receive a copy of the PHP license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@php.net so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Author: Stanislav Malyshev <stas@php.net> | + +----------------------------------------------------------------------+ + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "php.h" +#include "php_ini.h" +#include "php_gmp.h" +#include "ext/standard/info.h" + +#if HAVE_GMP + +#include <gmp.h> + +/* Needed for gmp_random() */ +#include "ext/standard/php_rand.h" +#include "ext/standard/php_lcg.h" +#define GMP_ABS(x) ((x) >= 0 ? (x) : -(x)) + +/* True global resources - no need for thread safety here */ +static int le_gmp; + +/* {{{ arginfo */ +ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_init, 0, 0, 1) + ZEND_ARG_INFO(0, number) + ZEND_ARG_INFO(0, base) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_intval, 0) + ZEND_ARG_INFO(0, gmpnumber) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_strval, 0, 0, 1) + ZEND_ARG_INFO(0, gmpnumber) + ZEND_ARG_INFO(0, base) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_add, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_sub, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_mul, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_div_qr, 0, 0, 2) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) + ZEND_ARG_INFO(0, round) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_div_r, 0, 0, 2) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) + ZEND_ARG_INFO(0, round) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_div_q, 0, 0, 2) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) + ZEND_ARG_INFO(0, round) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_mod, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_divexact, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_neg, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_abs, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_fact, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_pow, 0) + ZEND_ARG_INFO(0, base) + ZEND_ARG_INFO(0, exp) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_powm, 0) + ZEND_ARG_INFO(0, base) + ZEND_ARG_INFO(0, exp) + ZEND_ARG_INFO(0, mod) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_sqrt, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_sqrtrem, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_perfect_square, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_prob_prime, 0, 0, 1) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, reps) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_gcd, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_gcdext, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_invert, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_jacobi, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_legendre, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_cmp, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_sign, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_random, 0, 0, 0) + ZEND_ARG_INFO(0, limiter) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_and, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_or, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_com, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_xor, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_setbit, 0, 0, 2) + ZEND_ARG_INFO(1, a) + ZEND_ARG_INFO(0, index) + ZEND_ARG_INFO(0, set_clear) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_clrbit, 0) + ZEND_ARG_INFO(1, a) + ZEND_ARG_INFO(0, index) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_testbit, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, index) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_popcount, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_hamdist, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_scan0, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, start) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_scan1, 0) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, start) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_gmp_nextprime, 0) + ZEND_ARG_INFO(0, a) +ZEND_END_ARG_INFO() + +/* }}} */ + +ZEND_DECLARE_MODULE_GLOBALS(gmp) +static ZEND_GINIT_FUNCTION(gmp); + +/* {{{ gmp_functions[] + */ +const zend_function_entry gmp_functions[] = { + ZEND_FE(gmp_init, arginfo_gmp_init) + ZEND_FE(gmp_intval, arginfo_gmp_intval) + ZEND_FE(gmp_strval, arginfo_gmp_strval) + ZEND_FE(gmp_add, arginfo_gmp_add) + ZEND_FE(gmp_sub, arginfo_gmp_sub) + ZEND_FE(gmp_mul, arginfo_gmp_mul) + ZEND_FE(gmp_div_qr, arginfo_gmp_div_qr) + ZEND_FE(gmp_div_q, arginfo_gmp_div_q) + ZEND_FE(gmp_div_r, arginfo_gmp_div_r) + ZEND_FALIAS(gmp_div, gmp_div_q, arginfo_gmp_div_q) + ZEND_FE(gmp_mod, arginfo_gmp_mod) + ZEND_FE(gmp_divexact, arginfo_gmp_divexact) + ZEND_FE(gmp_neg, arginfo_gmp_neg) + ZEND_FE(gmp_abs, arginfo_gmp_abs) + ZEND_FE(gmp_fact, arginfo_gmp_fact) + ZEND_FE(gmp_sqrt, arginfo_gmp_sqrt) + ZEND_FE(gmp_sqrtrem, arginfo_gmp_sqrtrem) + ZEND_FE(gmp_pow, arginfo_gmp_pow) + ZEND_FE(gmp_powm, arginfo_gmp_powm) + ZEND_FE(gmp_perfect_square, arginfo_gmp_perfect_square) + ZEND_FE(gmp_prob_prime, arginfo_gmp_prob_prime) + ZEND_FE(gmp_gcd, arginfo_gmp_gcd) + ZEND_FE(gmp_gcdext, arginfo_gmp_gcdext) + ZEND_FE(gmp_invert, arginfo_gmp_invert) + ZEND_FE(gmp_jacobi, arginfo_gmp_jacobi) + ZEND_FE(gmp_legendre, arginfo_gmp_legendre) + ZEND_FE(gmp_cmp, arginfo_gmp_cmp) + ZEND_FE(gmp_sign, arginfo_gmp_sign) + ZEND_FE(gmp_random, arginfo_gmp_random) + ZEND_FE(gmp_and, arginfo_gmp_and) + ZEND_FE(gmp_or, arginfo_gmp_or) + ZEND_FE(gmp_com, arginfo_gmp_com) + ZEND_FE(gmp_xor, arginfo_gmp_xor) + ZEND_FE(gmp_setbit, arginfo_gmp_setbit) + ZEND_FE(gmp_clrbit, arginfo_gmp_clrbit) + ZEND_FE(gmp_scan0, arginfo_gmp_scan0) + ZEND_FE(gmp_scan1, arginfo_gmp_scan1) + ZEND_FE(gmp_testbit,arginfo_gmp_testbit) + ZEND_FE(gmp_popcount, arginfo_gmp_popcount) + ZEND_FE(gmp_hamdist, arginfo_gmp_hamdist) + ZEND_FE(gmp_nextprime, arginfo_gmp_nextprime) + PHP_FE_END +}; +/* }}} */ + +/* {{{ gmp_module_entry + */ +zend_module_entry gmp_module_entry = { + STANDARD_MODULE_HEADER, + "gmp", + gmp_functions, + ZEND_MODULE_STARTUP_N(gmp), + NULL, + NULL, + ZEND_MODULE_DEACTIVATE_N(gmp), + ZEND_MODULE_INFO_N(gmp), + NO_VERSION_YET, + ZEND_MODULE_GLOBALS(gmp), + ZEND_GINIT(gmp), + NULL, + NULL, + STANDARD_MODULE_PROPERTIES_EX +}; +/* }}} */ + +#ifdef COMPILE_DL_GMP +ZEND_GET_MODULE(gmp) +#endif + +static void _php_gmpnum_free(zend_rsrc_list_entry *rsrc TSRMLS_DC); + +#define GMP_RESOURCE_NAME "GMP integer" + +#define GMP_ROUND_ZERO 0 +#define GMP_ROUND_PLUSINF 1 +#define GMP_ROUND_MINUSINF 2 + +/* The maximum base for input and output conversions is 62 from GMP 4.2 + * onwards. */ +#if (__GNU_MP_VERSION >= 5) || (__GNU_MP_VERSION >= 4 && __GNU_MP_VERSION_MINOR >= 2) +# define MAX_BASE 62 +#else +# define MAX_BASE 36 +#endif + +/* {{{ gmp_emalloc + */ +static void *gmp_emalloc(size_t size) +{ + return emalloc(size); +} +/* }}} */ + +/* {{{ gmp_erealloc + */ +static void *gmp_erealloc(void *ptr, size_t old_size, size_t new_size) +{ + return erealloc(ptr, new_size); +} +/* }}} */ + +/* {{{ gmp_efree + */ +static void gmp_efree(void *ptr, size_t size) +{ + efree(ptr); +} +/* }}} */ + +/* {{{ ZEND_GINIT_FUNCTION + */ +static ZEND_GINIT_FUNCTION(gmp) +{ + gmp_globals->rand_initialized = 0; +} +/* }}} */ + +/* {{{ ZEND_MINIT_FUNCTION + */ +ZEND_MODULE_STARTUP_D(gmp) +{ + le_gmp = zend_register_list_destructors_ex(_php_gmpnum_free, NULL, GMP_RESOURCE_NAME, module_number); + REGISTER_LONG_CONSTANT("GMP_ROUND_ZERO", GMP_ROUND_ZERO, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("GMP_ROUND_PLUSINF", GMP_ROUND_PLUSINF, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("GMP_ROUND_MINUSINF", GMP_ROUND_MINUSINF, CONST_CS | CONST_PERSISTENT); +#ifdef mpir_version + REGISTER_STRING_CONSTANT("GMP_MPIR_VERSION", (char *)mpir_version, CONST_CS | CONST_PERSISTENT); +#endif + REGISTER_STRING_CONSTANT("GMP_VERSION", (char *)gmp_version, CONST_CS | CONST_PERSISTENT); + + mp_set_memory_functions(gmp_emalloc, gmp_erealloc, gmp_efree); + + return SUCCESS; +} +/* }}} */ + +/* {{{ ZEND_RSHUTDOWN_FUNCTION + */ +ZEND_MODULE_DEACTIVATE_D(gmp) +{ + if (GMPG(rand_initialized)) { + gmp_randclear(GMPG(rand_state)); + GMPG(rand_initialized) = 0; + } + + return SUCCESS; +} +/* }}} */ + +/* {{{ ZEND_MINFO_FUNCTION + */ +ZEND_MODULE_INFO_D(gmp) +{ + php_info_print_table_start(); + php_info_print_table_row(2, "gmp support", "enabled"); +#ifdef mpir_version + php_info_print_table_row(2, "MPIR version", mpir_version); +#else + php_info_print_table_row(2, "GMP version", gmp_version); +#endif + php_info_print_table_end(); +} +/* }}} */ + +/* Fetch zval to be GMP number. + Initially, zval can be also number or string */ +#define FETCH_GMP_ZVAL(gmpnumber, zval, tmp_resource) \ +if (Z_TYPE_PP(zval) == IS_RESOURCE) { \ + ZEND_FETCH_RESOURCE(gmpnumber, mpz_t *, zval, -1, GMP_RESOURCE_NAME, le_gmp); \ + tmp_resource = 0; \ +} else { \ + if (convert_to_gmp(&gmpnumber, zval, 0 TSRMLS_CC) == FAILURE) { \ + RETURN_FALSE; \ + } \ + tmp_resource = ZEND_REGISTER_RESOURCE(NULL, gmpnumber, le_gmp); \ +} + +#define FREE_GMP_TEMP(tmp_resource) \ + if(tmp_resource) { \ + zend_list_delete(tmp_resource); \ + } + + +/* create a new initialized GMP number */ +#define INIT_GMP_NUM(gmpnumber) { gmpnumber=emalloc(sizeof(mpz_t)); mpz_init(*gmpnumber); } +#define FREE_GMP_NUM(gmpnumber) { mpz_clear(*gmpnumber); efree(gmpnumber); } + +/* {{{ convert_to_gmp + * Convert zval to be gmp number */ +static int convert_to_gmp(mpz_t * *gmpnumber, zval **val, int base TSRMLS_DC) +{ + int ret = 0; + int skip_lead = 0; + + *gmpnumber = emalloc(sizeof(mpz_t)); + + switch (Z_TYPE_PP(val)) { + case IS_LONG: + case IS_BOOL: + case IS_CONSTANT: + { + convert_to_long_ex(val); + mpz_init_set_si(**gmpnumber, Z_LVAL_PP(val)); + } + break; + case IS_STRING: + { + char *numstr = Z_STRVAL_PP(val); + + if (Z_STRLEN_PP(val) > 2) { + if (numstr[0] == '0') { + if (numstr[1] == 'x' || numstr[1] == 'X') { + base = 16; + skip_lead = 1; + } else if (base != 16 && (numstr[1] == 'b' || numstr[1] == 'B')) { + base = 2; + skip_lead = 1; + } + } + } + ret = mpz_init_set_str(**gmpnumber, (skip_lead ? &numstr[2] : numstr), base); + } + break; + default: + php_error_docref(NULL TSRMLS_CC, E_WARNING,"Unable to convert variable to GMP - wrong type"); + efree(*gmpnumber); + return FAILURE; + } + + if (ret) { + FREE_GMP_NUM(*gmpnumber); + return FAILURE; + } + + return SUCCESS; +} +/* }}} */ + +/* {{{ typedefs + */ +typedef void (*gmp_unary_op_t)(mpz_ptr, mpz_srcptr); +typedef int (*gmp_unary_opl_t)(mpz_srcptr); + +typedef void (*gmp_unary_ui_op_t)(mpz_ptr, unsigned long); + +typedef void (*gmp_binary_op_t)(mpz_ptr, mpz_srcptr, mpz_srcptr); +typedef int (*gmp_binary_opl_t)(mpz_srcptr, mpz_srcptr); + +typedef unsigned long (*gmp_binary_ui_op_t)(mpz_ptr, mpz_srcptr, unsigned long); +typedef void (*gmp_binary_op2_t)(mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr); +typedef unsigned long (*gmp_binary_ui_op2_t)(mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long); +/* }}} */ + +#define gmp_zval_binary_ui_op(r, a, b, o, u) gmp_zval_binary_ui_op_ex(r, a, b, o, u, 0, 0, 0 TSRMLS_CC) +#define gmp_zval_binary_ui_op2(r, a, b, o, u) gmp_zval_binary_ui_op2_ex(r, a, b, o, u, 0, 0, 0 TSRMLS_CC) + +#define gmp_binary_ui_op(op, uop) _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op, uop) +#define gmp_binary_op(op) _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op, NULL) +#define gmp_binary_opl(op) _gmp_binary_opl(INTERNAL_FUNCTION_PARAM_PASSTHRU, op) + +/* Unary operations */ +#define gmp_unary_op(op) _gmp_unary_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op) +#define gmp_unary_opl(op) _gmp_unary_opl(INTERNAL_FUNCTION_PARAM_PASSTHRU, op) +#define gmp_unary_ui_op(op) _gmp_unary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op) + +/* {{{ gmp_zval_binary_ui_op_ex + Execute GMP binary operation. + May return GMP resource or long if operation allows this +*/ +static inline void gmp_zval_binary_ui_op_ex(zval *return_value, zval **a_arg, zval **b_arg, gmp_binary_op_t gmp_op, gmp_binary_ui_op_t gmp_ui_op, int allow_ui_return, int check_b_zero, int use_sign TSRMLS_DC) +{ + mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result; + unsigned long long_result = 0; + int use_ui = 0; + int arga_tmp = 0, argb_tmp = 0; + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, arga_tmp); + + if (gmp_ui_op && Z_TYPE_PP(b_arg) == IS_LONG && Z_LVAL_PP(b_arg) >= 0) { + use_ui = 1; + } else { + FETCH_GMP_ZVAL(gmpnum_b, b_arg, argb_tmp); + } + + if(check_b_zero) { + int b_is_zero = 0; + if(use_ui) { + b_is_zero = (Z_LVAL_PP(b_arg) == 0); + } else { + b_is_zero = !mpz_cmp_ui(*gmpnum_b, 0); + } + + if(b_is_zero) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zero operand not allowed"); + FREE_GMP_TEMP(arga_tmp); + FREE_GMP_TEMP(argb_tmp); + RETURN_FALSE; + } + } + + INIT_GMP_NUM(gmpnum_result); + + if (use_ui && gmp_ui_op) { + if (allow_ui_return) { + long_result = gmp_ui_op(*gmpnum_result, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg)); + if (use_sign && mpz_sgn(*gmpnum_a) == -1) { + long_result = -long_result; + } + } else { + gmp_ui_op(*gmpnum_result, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg)); + } + } else { + gmp_op(*gmpnum_result, *gmpnum_a, *gmpnum_b); + } + + FREE_GMP_TEMP(arga_tmp); + FREE_GMP_TEMP(argb_tmp); + + if (use_ui && allow_ui_return) { + FREE_GMP_NUM(gmpnum_result); + RETURN_LONG((long)long_result); + } else { + ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp); + } +} +/* }}} */ + +/* {{{ gmp_zval_binary_ui_op2_ex + Execute GMP binary operation which returns 2 values. + May return GMP resources or longs if operation allows this. +*/ +static inline void gmp_zval_binary_ui_op2_ex(zval *return_value, zval **a_arg, zval **b_arg, gmp_binary_op2_t gmp_op, gmp_binary_ui_op2_t gmp_ui_op, int allow_ui_return, int check_b_zero TSRMLS_DC) +{ + mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result1, *gmpnum_result2; + zval r; + int use_ui = 0; + unsigned long long_result = 0; + int arga_tmp = 0, argb_tmp = 0; + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, arga_tmp); + + if (gmp_ui_op && Z_TYPE_PP(b_arg) == IS_LONG && Z_LVAL_PP(b_arg) >= 0) { + /* use _ui function */ + use_ui = 1; + } else { + FETCH_GMP_ZVAL(gmpnum_b, b_arg, argb_tmp); + } + + if(check_b_zero) { + int b_is_zero = 0; + if(use_ui) { + b_is_zero = (Z_LVAL_PP(b_arg) == 0); + } else { + b_is_zero = !mpz_cmp_ui(*gmpnum_b, 0); + } + + if(b_is_zero) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zero operand not allowed"); + FREE_GMP_TEMP(arga_tmp); + FREE_GMP_TEMP(argb_tmp); + RETURN_FALSE; + } + } + + INIT_GMP_NUM(gmpnum_result1); + INIT_GMP_NUM(gmpnum_result2); + + if (use_ui && gmp_ui_op) { + if (allow_ui_return) { + long_result = gmp_ui_op(*gmpnum_result1, *gmpnum_result2, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg)); + } else { + gmp_ui_op(*gmpnum_result1, *gmpnum_result2, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg)); + } + } else { + gmp_op(*gmpnum_result1, *gmpnum_result2, *gmpnum_a, *gmpnum_b); + } + + FREE_GMP_TEMP(arga_tmp); + FREE_GMP_TEMP(argb_tmp); + + array_init(return_value); + ZEND_REGISTER_RESOURCE(&r, gmpnum_result1, le_gmp); + add_index_resource(return_value, 0, Z_LVAL(r)); + if (use_ui && allow_ui_return) { + mpz_clear(*gmpnum_result2); + add_index_long(return_value, 1, long_result); + } else { + ZEND_REGISTER_RESOURCE(&r, gmpnum_result2, le_gmp); + add_index_resource(return_value, 1, Z_LVAL(r)); + } +} +/* }}} */ + +/* {{{ _gmp_binary_ui_op + */ +static inline void _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAMETERS, gmp_binary_op_t gmp_op, gmp_binary_ui_op_t gmp_ui_op) +{ + zval **a_arg, **b_arg; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + gmp_zval_binary_ui_op(return_value, a_arg, b_arg, gmp_op, gmp_ui_op); +} +/* }}} */ + +/* Unary operations */ + +/* {{{ gmp_zval_unary_op + */ +static inline void gmp_zval_unary_op(zval *return_value, zval **a_arg, gmp_unary_op_t gmp_op TSRMLS_DC) +{ + mpz_t *gmpnum_a, *gmpnum_result; + int temp_a; + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + + INIT_GMP_NUM(gmpnum_result); + gmp_op(*gmpnum_result, *gmpnum_a); + + FREE_GMP_TEMP(temp_a); + ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp); +} +/* }}} */ + +/* {{{ gmp_zval_unary_ui_op + */ +static inline void gmp_zval_unary_ui_op(zval *return_value, zval **a_arg, gmp_unary_ui_op_t gmp_op TSRMLS_DC) +{ + mpz_t *gmpnum_result; + + convert_to_long_ex(a_arg); + + INIT_GMP_NUM(gmpnum_result); + gmp_op(*gmpnum_result, Z_LVAL_PP(a_arg)); + + ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp); +} +/* }}} */ + +/* {{{ _gmp_unary_ui_op + Execute GMP unary operation. +*/ +static inline void _gmp_unary_ui_op(INTERNAL_FUNCTION_PARAMETERS, gmp_unary_ui_op_t gmp_op) +{ + zval **a_arg; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &a_arg) == FAILURE){ + return; + } + + gmp_zval_unary_ui_op(return_value, a_arg, gmp_op TSRMLS_CC); +} +/* }}} */ + +/* {{{ _gmp_unary_op + */ +static inline void _gmp_unary_op(INTERNAL_FUNCTION_PARAMETERS, gmp_unary_op_t gmp_op) +{ + zval **a_arg; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &a_arg) == FAILURE){ + return; + } + + gmp_zval_unary_op(return_value, a_arg, gmp_op TSRMLS_CC); +} +/* }}} */ + +/* {{{ _gmp_unary_opl + */ +static inline void _gmp_unary_opl(INTERNAL_FUNCTION_PARAMETERS, gmp_unary_opl_t gmp_op) +{ + zval **a_arg; + mpz_t *gmpnum_a; + int temp_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &a_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + RETVAL_LONG(gmp_op(*gmpnum_a)); + FREE_GMP_TEMP(temp_a); +} +/* }}} */ + +/* {{{ _gmp_binary_opl + */ +static inline void _gmp_binary_opl(INTERNAL_FUNCTION_PARAMETERS, gmp_binary_opl_t gmp_op) +{ + zval **a_arg, **b_arg; + mpz_t *gmpnum_a, *gmpnum_b; + int temp_a, temp_b; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + FETCH_GMP_ZVAL(gmpnum_b, b_arg, temp_b); + + RETVAL_LONG(gmp_op(*gmpnum_a, *gmpnum_b)); + + FREE_GMP_TEMP(temp_a); + FREE_GMP_TEMP(temp_b); +} +/* }}} */ + +/* {{{ proto resource gmp_init(mixed number [, int base]) + Initializes GMP number */ +ZEND_FUNCTION(gmp_init) +{ + zval **number_arg; + mpz_t * gmpnumber; + long base=0; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|l", &number_arg, &base) == FAILURE) { + return; + } + + if (base && (base < 2 || base > MAX_BASE)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad base for conversion: %ld (should be between 2 and %d)", base, MAX_BASE); + RETURN_FALSE; + } + + if (convert_to_gmp(&gmpnumber, number_arg, base TSRMLS_CC) == FAILURE) { + RETURN_FALSE; + } + + /* Write your own code here to handle argument number. */ + ZEND_REGISTER_RESOURCE(return_value, gmpnumber, le_gmp); +} +/* }}} */ + +/* {{{ proto int gmp_intval(resource gmpnumber) + Gets signed long value of GMP number */ +ZEND_FUNCTION(gmp_intval) +{ + zval **gmpnumber_arg; + mpz_t * gmpnum; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &gmpnumber_arg) == FAILURE){ + return; + } + + if (Z_TYPE_PP(gmpnumber_arg) == IS_RESOURCE) { + ZEND_FETCH_RESOURCE(gmpnum, mpz_t *, gmpnumber_arg, -1, GMP_RESOURCE_NAME, le_gmp); + RETVAL_LONG(mpz_get_si(*gmpnum)); + } else { + convert_to_long_ex(gmpnumber_arg); + RETVAL_LONG(Z_LVAL_PP(gmpnumber_arg)); + } +} +/* }}} */ + +/* {{{ proto string gmp_strval(resource gmpnumber [, int base]) + Gets string representation of GMP number */ +ZEND_FUNCTION(gmp_strval) +{ + zval **gmpnumber_arg; + int num_len; + long base = 10; + mpz_t * gmpnum; + char *out_string; + int temp_a; + + if( zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "Z|l", &gmpnumber_arg, &base ) == FAILURE ) { + return; + } + +#if MAX_BASE == 62 + /* Although the maximum base in general in GMP >= 4.2 is 62, mpz_get_str() + * is explicitly limited to -36 when dealing with negative bases. */ + if ((base < 2 && base > -2) || base > MAX_BASE || base < -36) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad base for conversion: %ld (should be between 2 and %d or -2 and -36)", base, MAX_BASE); +#else + if (base < 2 || base > MAX_BASE) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad base for conversion: %ld (should be between 2 and %d)", base, MAX_BASE); +#endif + RETURN_FALSE; + } + + FETCH_GMP_ZVAL(gmpnum, gmpnumber_arg, temp_a); + + num_len = mpz_sizeinbase(*gmpnum, abs(base)); + out_string = emalloc(num_len+2); + if (mpz_sgn(*gmpnum) < 0) { + num_len++; + } + mpz_get_str(out_string, base, *gmpnum); + + FREE_GMP_TEMP(temp_a); + + /* + From GMP documentation for mpz_sizeinbase(): + The returned value will be exact or 1 too big. If base is a power of + 2, the returned value will always be exact. + + So let's check to see if we already have a \0 byte... + */ + + if (out_string[num_len-1] == '\0') { + num_len--; + } else { + out_string[num_len] = '\0'; + } + RETVAL_STRINGL(out_string, num_len, 0); +} +/* }}} */ + +/* {{{ proto resource gmp_add(resource a, resource b) + Add a and b */ +ZEND_FUNCTION(gmp_add) +{ + gmp_binary_ui_op(mpz_add, (gmp_binary_ui_op_t)mpz_add_ui); +} +/* }}} */ + +/* {{{ proto resource gmp_sub(resource a, resource b) + Subtract b from a */ +ZEND_FUNCTION(gmp_sub) +{ + gmp_binary_ui_op(mpz_sub, (gmp_binary_ui_op_t)mpz_sub_ui); +} +/* }}} */ + +/* {{{ proto resource gmp_mul(resource a, resource b) + Multiply a and b */ +ZEND_FUNCTION(gmp_mul) +{ + gmp_binary_ui_op(mpz_mul, (gmp_binary_ui_op_t)mpz_mul_ui); +} +/* }}} */ + +/* {{{ proto array gmp_div_qr(resource a, resource b [, int round]) + Divide a by b, returns quotient and reminder */ +ZEND_FUNCTION(gmp_div_qr) +{ + zval **a_arg, **b_arg; + long round = GMP_ROUND_ZERO; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ|l", &a_arg, &b_arg, &round) == FAILURE) { + return; + } + + switch (round) { + case GMP_ROUND_ZERO: + gmp_zval_binary_ui_op2_ex(return_value, a_arg, b_arg, mpz_tdiv_qr, (gmp_binary_ui_op2_t)mpz_tdiv_qr_ui, 0, 1 TSRMLS_CC); + break; + case GMP_ROUND_PLUSINF: + gmp_zval_binary_ui_op2_ex(return_value, a_arg, b_arg, mpz_cdiv_qr, (gmp_binary_ui_op2_t)mpz_cdiv_qr_ui, 0, 1 TSRMLS_CC); + break; + case GMP_ROUND_MINUSINF: + gmp_zval_binary_ui_op2_ex(return_value, a_arg, b_arg, mpz_fdiv_qr, (gmp_binary_ui_op2_t)mpz_fdiv_qr_ui, 0, 1 TSRMLS_CC); + break; + } + +} +/* }}} */ + +/* {{{ proto resource gmp_div_r(resource a, resource b [, int round]) + Divide a by b, returns reminder only */ +ZEND_FUNCTION(gmp_div_r) +{ + zval **a_arg, **b_arg; + long round = GMP_ROUND_ZERO; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ|l", &a_arg, &b_arg, &round) == FAILURE) { + return; + } + + switch (round) { + case GMP_ROUND_ZERO: + gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_tdiv_r, (gmp_binary_ui_op_t)mpz_tdiv_r_ui, 1, 1, 1 TSRMLS_CC); + break; + case GMP_ROUND_PLUSINF: + gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_cdiv_r, (gmp_binary_ui_op_t)mpz_cdiv_r_ui, 1, 1, 1 TSRMLS_CC); + break; + case GMP_ROUND_MINUSINF: + gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_fdiv_r, (gmp_binary_ui_op_t)mpz_fdiv_r_ui, 1, 1, 1 TSRMLS_CC); + break; + } +} +/* }}} */ + +/* {{{ proto resource gmp_div_q(resource a, resource b [, int round]) + Divide a by b, returns quotient only */ +ZEND_FUNCTION(gmp_div_q) +{ + zval **a_arg, **b_arg; + long round = GMP_ROUND_ZERO; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ|l", &a_arg, &b_arg, &round) == FAILURE) { + return; + } + + switch (round) { + case GMP_ROUND_ZERO: + gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_tdiv_q, (gmp_binary_ui_op_t)mpz_tdiv_q_ui, 0, 1, 1 TSRMLS_CC); + break; + case GMP_ROUND_PLUSINF: + gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_cdiv_q, (gmp_binary_ui_op_t)mpz_cdiv_q_ui, 0, 1, 1 TSRMLS_CC); + break; + case GMP_ROUND_MINUSINF: + gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_fdiv_q, (gmp_binary_ui_op_t)mpz_fdiv_q_ui, 0, 1, 1 TSRMLS_CC); + break; + } + +} +/* }}} */ + +/* {{{ proto resource gmp_mod(resource a, resource b) + Computes a modulo b */ +ZEND_FUNCTION(gmp_mod) +{ + zval **a_arg, **b_arg; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_mod, (gmp_binary_ui_op_t)mpz_mod_ui, 1, 1, 0 TSRMLS_CC); +} +/* }}} */ + +/* {{{ proto resource gmp_divexact(resource a, resource b) + Divide a by b using exact division algorithm */ +ZEND_FUNCTION(gmp_divexact) +{ + zval **a_arg, **b_arg; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_divexact, NULL, 0, 1, 1 TSRMLS_CC); +} +/* }}} */ + +/* {{{ proto resource gmp_neg(resource a) + Negates a number */ +ZEND_FUNCTION(gmp_neg) +{ + gmp_unary_op(mpz_neg); +} +/* }}} */ + +/* {{{ proto resource gmp_abs(resource a) + Calculates absolute value */ +ZEND_FUNCTION(gmp_abs) +{ + gmp_unary_op(mpz_abs); +} +/* }}} */ + +/* {{{ proto resource gmp_fact(int a) + Calculates factorial function */ +ZEND_FUNCTION(gmp_fact) +{ + zval **a_arg; + mpz_t *gmpnum_tmp; + int temp_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &a_arg) == FAILURE){ + return; + } + + if (Z_TYPE_PP(a_arg) == IS_RESOURCE) { + FETCH_GMP_ZVAL(gmpnum_tmp, a_arg, temp_a); /* no need to free this since it's IS_RESOURCE */ + if (mpz_sgn(*gmpnum_tmp) < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number has to be greater than or equal to 0"); + RETURN_FALSE; + } + } else { + convert_to_long_ex(a_arg); + if (Z_LVAL_PP(a_arg) < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number has to be greater than or equal to 0"); + RETURN_FALSE; + } + } + + gmp_zval_unary_ui_op(return_value, a_arg, mpz_fac_ui TSRMLS_CC); +} +/* }}} */ + +/* {{{ proto resource gmp_pow(resource base, int exp) + Raise base to power exp */ +ZEND_FUNCTION(gmp_pow) +{ + zval **base_arg; + mpz_t *gmpnum_result, *gmpnum_base; + int use_ui = 0; + int temp_base; + long exp; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zl", &base_arg, &exp) == FAILURE) { + return; + } + + if (Z_TYPE_PP(base_arg) == IS_LONG && Z_LVAL_PP(base_arg) >= 0) { + use_ui = 1; + } else { + FETCH_GMP_ZVAL(gmpnum_base, base_arg, temp_base); + } + + if (exp < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Negative exponent not supported"); + RETURN_FALSE; + } + + INIT_GMP_NUM(gmpnum_result); + if (use_ui) { + mpz_ui_pow_ui(*gmpnum_result, Z_LVAL_PP(base_arg), exp); + } else { + mpz_pow_ui(*gmpnum_result, *gmpnum_base, exp); + FREE_GMP_TEMP(temp_base); + } + ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp); +} +/* }}} */ + +/* {{{ proto resource gmp_powm(resource base, resource exp, resource mod) + Raise base to power exp and take result modulo mod */ +ZEND_FUNCTION(gmp_powm) +{ + zval **base_arg, **exp_arg, **mod_arg; + mpz_t *gmpnum_base, *gmpnum_exp, *gmpnum_mod, *gmpnum_result; + int use_ui = 0; + int temp_base, temp_exp, temp_mod; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ", &base_arg, &exp_arg, &mod_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_base, base_arg, temp_base); + + if (Z_TYPE_PP(exp_arg) == IS_LONG && Z_LVAL_PP(exp_arg) >= 0) { + use_ui = 1; + } else { + FETCH_GMP_ZVAL(gmpnum_exp, exp_arg, temp_exp); + if (mpz_sgn(*gmpnum_exp) < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING,"Second parameter cannot be less than 0"); + RETURN_FALSE; + } + } + FETCH_GMP_ZVAL(gmpnum_mod, mod_arg, temp_mod); + + if (!mpz_cmp_ui(*gmpnum_mod, 0)) { + FREE_GMP_TEMP(temp_base); + if (use_ui) { + FREE_GMP_TEMP(temp_exp); + } + FREE_GMP_TEMP(temp_mod); + RETURN_FALSE; + } + + INIT_GMP_NUM(gmpnum_result); + if (use_ui) { + mpz_powm_ui(*gmpnum_result, *gmpnum_base, (unsigned long)Z_LVAL_PP(exp_arg), *gmpnum_mod); + } else { + mpz_powm(*gmpnum_result, *gmpnum_base, *gmpnum_exp, *gmpnum_mod); + FREE_GMP_TEMP(temp_exp); + } + + FREE_GMP_TEMP(temp_base); + FREE_GMP_TEMP(temp_mod); + + ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp); + +} +/* }}} */ + +/* {{{ proto resource gmp_sqrt(resource a) + Takes integer part of square root of a */ +ZEND_FUNCTION(gmp_sqrt) +{ + zval **a_arg; + mpz_t *gmpnum_a, *gmpnum_result; + int temp_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &a_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + + if (mpz_sgn(*gmpnum_a) < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number has to be greater than or equal to 0"); + FREE_GMP_TEMP(temp_a); + RETURN_FALSE; + } + + INIT_GMP_NUM(gmpnum_result); + mpz_sqrt(*gmpnum_result, *gmpnum_a); + FREE_GMP_TEMP(temp_a); + + ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp); +} +/* }}} */ + +/* {{{ proto array gmp_sqrtrem(resource a) + Square root with remainder */ +ZEND_FUNCTION(gmp_sqrtrem) +{ + zval **a_arg; + mpz_t *gmpnum_a, *gmpnum_result1, *gmpnum_result2; + zval r; + int temp_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &a_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + + if (mpz_sgn(*gmpnum_a) < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING,"Number has to be greater than or equal to 0"); + RETURN_FALSE; + } + + INIT_GMP_NUM(gmpnum_result1); + INIT_GMP_NUM(gmpnum_result2); + + mpz_sqrtrem(*gmpnum_result1, *gmpnum_result2, *gmpnum_a); + FREE_GMP_TEMP(temp_a); + + array_init(return_value); + ZEND_REGISTER_RESOURCE(&r, gmpnum_result1, le_gmp); + add_index_resource(return_value, 0, Z_LVAL(r)); + ZEND_REGISTER_RESOURCE(&r, gmpnum_result2, le_gmp); + add_index_resource(return_value, 1, Z_LVAL(r)); +} +/* }}} */ + +/* {{{ proto bool gmp_perfect_square(resource a) + Checks if a is an exact square */ +ZEND_FUNCTION(gmp_perfect_square) +{ + zval **a_arg; + mpz_t *gmpnum_a; + int temp_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &a_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + + RETVAL_BOOL((mpz_perfect_square_p(*gmpnum_a)!=0)); + FREE_GMP_TEMP(temp_a); +} +/* }}} */ + +/* {{{ proto int gmp_prob_prime(resource a[, int reps]) + Checks if a is "probably prime" */ +ZEND_FUNCTION(gmp_prob_prime) +{ + zval **gmpnumber_arg; + mpz_t *gmpnum_a; + long reps = 10; + int temp_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|l", &gmpnumber_arg, &reps) == FAILURE) { + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, gmpnumber_arg, temp_a); + + RETVAL_LONG(mpz_probab_prime_p(*gmpnum_a, reps)); + FREE_GMP_TEMP(temp_a); +} +/* }}} */ + +/* {{{ proto resource gmp_gcd(resource a, resource b) + Computes greatest common denominator (gcd) of a and b */ +ZEND_FUNCTION(gmp_gcd) +{ + zval **a_arg, **b_arg; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_gcd, (gmp_binary_ui_op_t)mpz_gcd_ui, 0, 0, 1 TSRMLS_CC); +} +/* }}} */ + +/* {{{ proto array gmp_gcdext(resource a, resource b) + Computes G, S, and T, such that AS + BT = G = `gcd' (A, B) */ +ZEND_FUNCTION(gmp_gcdext) +{ + zval **a_arg, **b_arg; + mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_t, *gmpnum_s, *gmpnum_g; + zval r; + int temp_a, temp_b; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + FETCH_GMP_ZVAL(gmpnum_b, b_arg, temp_b); + + INIT_GMP_NUM(gmpnum_g); + INIT_GMP_NUM(gmpnum_s); + INIT_GMP_NUM(gmpnum_t); + + mpz_gcdext(*gmpnum_g, *gmpnum_s, *gmpnum_t, *gmpnum_a, *gmpnum_b); + FREE_GMP_TEMP(temp_a); + FREE_GMP_TEMP(temp_b); + + array_init(return_value); + + ZEND_REGISTER_RESOURCE(&r, gmpnum_g, le_gmp); + add_assoc_resource(return_value, "g", Z_LVAL(r)); + ZEND_REGISTER_RESOURCE(&r, gmpnum_s, le_gmp); + add_assoc_resource(return_value, "s", Z_LVAL(r)); + ZEND_REGISTER_RESOURCE(&r, gmpnum_t, le_gmp); + add_assoc_resource(return_value, "t", Z_LVAL(r)); +} +/* }}} */ + +/* {{{ proto resource gmp_invert(resource a, resource b) + Computes the inverse of a modulo b */ +ZEND_FUNCTION(gmp_invert) +{ + zval **a_arg, **b_arg; + mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result; + int temp_a, temp_b; + int res; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + FETCH_GMP_ZVAL(gmpnum_b, b_arg, temp_b); + + INIT_GMP_NUM(gmpnum_result); + res=mpz_invert(*gmpnum_result, *gmpnum_a, *gmpnum_b); + FREE_GMP_TEMP(temp_a); + FREE_GMP_TEMP(temp_b); + if (res) { + ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp); + } else { + FREE_GMP_NUM(gmpnum_result); + RETURN_FALSE; + } +} +/* }}} */ + +/* {{{ proto int gmp_jacobi(resource a, resource b) + Computes Jacobi symbol */ +ZEND_FUNCTION(gmp_jacobi) +{ + gmp_binary_opl(mpz_jacobi); +} +/* }}} */ + +/* {{{ proto int gmp_legendre(resource a, resource b) + Computes Legendre symbol */ +ZEND_FUNCTION(gmp_legendre) +{ + gmp_binary_opl(mpz_legendre); +} +/* }}} */ + +/* {{{ proto int gmp_cmp(resource a, resource b) + Compares two numbers */ +ZEND_FUNCTION(gmp_cmp) +{ + zval **a_arg, **b_arg; + mpz_t *gmpnum_a, *gmpnum_b; + int use_si = 0, res; + int temp_a, temp_b; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + + if (Z_TYPE_PP(b_arg) == IS_LONG) { + use_si = 1; + } else { + FETCH_GMP_ZVAL(gmpnum_b, b_arg, temp_b); + } + + if (use_si) { + res = mpz_cmp_si(*gmpnum_a, Z_LVAL_PP(b_arg)); + } else { + res = mpz_cmp(*gmpnum_a, *gmpnum_b); + } + FREE_GMP_TEMP(temp_a); + + RETURN_LONG(res); +} +/* }}} */ + +/* {{{ proto int gmp_sign(resource a) + Gets the sign of the number */ +ZEND_FUNCTION(gmp_sign) +{ + zval **a_arg; + mpz_t *gmpnum_a; + int temp_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &a_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + + RETVAL_LONG(mpz_sgn(*gmpnum_a)); + FREE_GMP_TEMP(temp_a); +} +/* }}} */ + +/* {{{ proto resource gmp_random([int limiter]) + Gets random number */ +ZEND_FUNCTION(gmp_random) +{ + long limiter = 20; + mpz_t *gmpnum_result; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &limiter) == FAILURE) { + return; + } + + INIT_GMP_NUM(gmpnum_result); + + if (!GMPG(rand_initialized)) { + /* Initialize */ + gmp_randinit_lc_2exp_size(GMPG(rand_state), 32L); + + /* Seed */ + gmp_randseed_ui(GMPG(rand_state), GENERATE_SEED()); + + GMPG(rand_initialized) = 1; + } +#ifdef GMP_LIMB_BITS + mpz_urandomb(*gmpnum_result, GMPG(rand_state), GMP_ABS (limiter) * GMP_LIMB_BITS); +#else + mpz_urandomb(*gmpnum_result, GMPG(rand_state), GMP_ABS (limiter) * __GMP_BITS_PER_MP_LIMB); +#endif + ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp); +} +/* }}} */ + +/* {{{ proto resource gmp_and(resource a, resource b) + Calculates logical AND of a and b */ +ZEND_FUNCTION(gmp_and) +{ + gmp_binary_op(mpz_and); +} +/* }}} */ + +/* {{{ proto resource gmp_or(resource a, resource b) + Calculates logical OR of a and b */ +ZEND_FUNCTION(gmp_or) +{ + gmp_binary_op(mpz_ior); +} +/* }}} */ + +/* {{{ proto resource gmp_com(resource a) + Calculates one's complement of a */ +ZEND_FUNCTION(gmp_com) +{ + gmp_unary_op(mpz_com); +} +/* }}} */ + +/* {{{ proto resource gmp_nextprime(resource a) + Finds next prime of a */ +ZEND_FUNCTION(gmp_nextprime) +{ + gmp_unary_op(mpz_nextprime); +} +/* }}} */ + +/* {{{ proto resource gmp_xor(resource a, resource b) + Calculates logical exclusive OR of a and b */ +ZEND_FUNCTION(gmp_xor) +{ + /* use formula: a^b = (a|b)&^(a&b) */ + zval **a_arg, **b_arg; + mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result, *gmpnum_t; + int temp_a, temp_b; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + FETCH_GMP_ZVAL(gmpnum_b, b_arg, temp_b); + + INIT_GMP_NUM(gmpnum_result); + INIT_GMP_NUM(gmpnum_t); + + mpz_and(*gmpnum_t, *gmpnum_a, *gmpnum_b); + mpz_com(*gmpnum_t, *gmpnum_t); + + mpz_ior(*gmpnum_result, *gmpnum_a, *gmpnum_b); + mpz_and(*gmpnum_result, *gmpnum_result, *gmpnum_t); + + FREE_GMP_NUM(gmpnum_t); + + FREE_GMP_TEMP(temp_a); + FREE_GMP_TEMP(temp_b); + ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp); +} +/* }}} */ + +/* {{{ proto void gmp_setbit(resource &a, int index[, bool set_clear]) + Sets or clear bit in a */ +ZEND_FUNCTION(gmp_setbit) +{ + zval **a_arg; + long index; + zend_bool set = 1; + mpz_t *gmpnum_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zl|b", &a_arg, &index, &set) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE(gmpnum_a, mpz_t *, a_arg, -1, GMP_RESOURCE_NAME, le_gmp); + + if (index < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Index must be greater than or equal to zero"); + return; + } + + if (set) { + mpz_setbit(*gmpnum_a, index); + } else { + mpz_clrbit(*gmpnum_a, index); + } +} +/* }}} */ + +/* {{{ proto void gmp_clrbit(resource &a, int index) + Clears bit in a */ +ZEND_FUNCTION(gmp_clrbit) +{ + zval **a_arg; + long index; + mpz_t *gmpnum_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zl", &a_arg, &index) == FAILURE){ + return; + } + + ZEND_FETCH_RESOURCE(gmpnum_a, mpz_t *, a_arg, -1, GMP_RESOURCE_NAME, le_gmp); + + if (index < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Index must be greater than or equal to zero"); + return; + } + + mpz_clrbit(*gmpnum_a, index); +} +/* }}} */ + +/* {{{ proto bool gmp_testbit(resource a, int index) + Tests if bit is set in a */ +ZEND_FUNCTION(gmp_testbit) +{ + zval **a_arg; + long index; + mpz_t *gmpnum_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zl", &a_arg, &index) == FAILURE){ + return; + } + + ZEND_FETCH_RESOURCE(gmpnum_a, mpz_t *, a_arg, -1, GMP_RESOURCE_NAME, le_gmp); + + if (index < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Index must be greater than or equal to zero"); + RETURN_FALSE; + } + + if (mpz_tstbit(*gmpnum_a, index)) { + RETURN_TRUE; + } + RETURN_FALSE; +} +/* }}} */ + +/* {{{ proto int gmp_popcount(resource a) + Calculates the population count of a */ +ZEND_FUNCTION(gmp_popcount) +{ + zval **a_arg; + mpz_t *gmpnum_a; + int temp_a; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &a_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + + RETVAL_LONG(mpz_popcount(*gmpnum_a)); + FREE_GMP_TEMP(temp_a); +} +/* }}} */ + +/* {{{ proto int gmp_hamdist(resource a, resource b) + Calculates hamming distance between a and b */ +ZEND_FUNCTION(gmp_hamdist) +{ + zval **a_arg, **b_arg; + mpz_t *gmpnum_a, *gmpnum_b; + int temp_a, temp_b; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ", &a_arg, &b_arg) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + FETCH_GMP_ZVAL(gmpnum_b, b_arg, temp_b); + + RETVAL_LONG(mpz_hamdist(*gmpnum_a, *gmpnum_b)); + FREE_GMP_TEMP(temp_a); + FREE_GMP_TEMP(temp_b); +} +/* }}} */ + +/* {{{ proto int gmp_scan0(resource a, int start) + Finds first zero bit */ +ZEND_FUNCTION(gmp_scan0) +{ + zval **a_arg; + mpz_t *gmpnum_a; + int temp_a; + long start; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zl", &a_arg, &start) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + + if (start < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Starting index must be greater than or equal to zero"); + RETURN_FALSE; + } + + RETVAL_LONG(mpz_scan0(*gmpnum_a, start)); + FREE_GMP_TEMP(temp_a); +} +/* }}} */ + +/* {{{ proto int gmp_scan1(resource a, int start) + Finds first non-zero bit */ +ZEND_FUNCTION(gmp_scan1) +{ + zval **a_arg; + mpz_t *gmpnum_a; + int temp_a; + long start; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zl", &a_arg, &start) == FAILURE){ + return; + } + + FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a); + if (start < 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Starting index must be greater than or equal to zero"); + RETURN_FALSE; + } + + RETVAL_LONG(mpz_scan1(*gmpnum_a, start)); + FREE_GMP_TEMP(temp_a); +} +/* }}} */ + +/* {{{ _php_gmpnum_free + */ +static void _php_gmpnum_free(zend_rsrc_list_entry *rsrc TSRMLS_DC) +{ + mpz_t *gmpnum = (mpz_t *)rsrc->ptr; + + FREE_GMP_NUM(gmpnum); +} +/* }}} */ + +#endif /* HAVE_GMP */ + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + * vim600: noet sw=4 ts=4 fdm=marker + * vim<600: noet sw=4 ts=4 + */ diff --git a/ext/gmp/php_gmp.h b/ext/gmp/php_gmp.h new file mode 100644 index 0000000..e1aaef8 --- /dev/null +++ b/ext/gmp/php_gmp.h @@ -0,0 +1,99 @@ +/* + +----------------------------------------------------------------------+ + | PHP Version 5 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997-2013 The PHP Group | + +----------------------------------------------------------------------+ + | This source file is subject to version 3.01 of the PHP license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.php.net/license/3_01.txt | + | If you did not receive a copy of the PHP license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@php.net so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Author: Stanislav Malyshev <stas@php.net> | + +----------------------------------------------------------------------+ + */ + +#ifndef PHP_GMP_H +#define PHP_GMP_H + +#if HAVE_GMP + +#include <gmp.h> + +extern zend_module_entry gmp_module_entry; +#define phpext_gmp_ptr &gmp_module_entry + +ZEND_MODULE_STARTUP_D(gmp); +ZEND_MODULE_DEACTIVATE_D(gmp); +ZEND_MODULE_INFO_D(gmp); + +ZEND_FUNCTION(gmp_init); +ZEND_FUNCTION(gmp_intval); +ZEND_FUNCTION(gmp_strval); +ZEND_FUNCTION(gmp_add); +ZEND_FUNCTION(gmp_sub); +ZEND_FUNCTION(gmp_mul); +ZEND_FUNCTION(gmp_div_qr); +ZEND_FUNCTION(gmp_div_q); +ZEND_FUNCTION(gmp_div_r); +ZEND_FUNCTION(gmp_mod); +ZEND_FUNCTION(gmp_divexact); +ZEND_FUNCTION(gmp_neg); +ZEND_FUNCTION(gmp_abs); +ZEND_FUNCTION(gmp_fact); +ZEND_FUNCTION(gmp_sqrt); +ZEND_FUNCTION(gmp_pow); +ZEND_FUNCTION(gmp_powm); +ZEND_FUNCTION(gmp_sqrtrem); +ZEND_FUNCTION(gmp_perfect_square); +ZEND_FUNCTION(gmp_prob_prime); +ZEND_FUNCTION(gmp_gcd); +ZEND_FUNCTION(gmp_gcdext); +ZEND_FUNCTION(gmp_invert); +ZEND_FUNCTION(gmp_jacobi); +ZEND_FUNCTION(gmp_legendre); +ZEND_FUNCTION(gmp_cmp); +ZEND_FUNCTION(gmp_sign); +ZEND_FUNCTION(gmp_and); +ZEND_FUNCTION(gmp_or); +ZEND_FUNCTION(gmp_com); +ZEND_FUNCTION(gmp_xor); +ZEND_FUNCTION(gmp_random); +ZEND_FUNCTION(gmp_setbit); +ZEND_FUNCTION(gmp_clrbit); +ZEND_FUNCTION(gmp_scan0); +ZEND_FUNCTION(gmp_scan1); +ZEND_FUNCTION(gmp_testbit); +ZEND_FUNCTION(gmp_popcount); +ZEND_FUNCTION(gmp_hamdist); +ZEND_FUNCTION(gmp_nextprime); + +ZEND_BEGIN_MODULE_GLOBALS(gmp) + zend_bool rand_initialized; + gmp_randstate_t rand_state; +ZEND_END_MODULE_GLOBALS(gmp) + +#ifdef ZTS +#define GMPG(v) TSRMG(gmp_globals_id, zend_gmp_globals *, v) +#else +#define GMPG(v) (gmp_globals.v) +#endif + +#else + +#define phpext_gmp_ptr NULL + +#endif + +#endif /* PHP_GMP_H */ + + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + */ diff --git a/ext/gmp/tests/001.phpt b/ext/gmp/tests/001.phpt new file mode 100644 index 0000000..5126f73 --- /dev/null +++ b/ext/gmp/tests/001.phpt @@ -0,0 +1,21 @@ +--TEST-- +Check for gmp presence +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php +echo "gmp extension is available"; +/* + you can add regression tests for your extension here + + the output of your test code has to be equal to the + text in the --EXPECT-- section below for the tests + to pass, differences between the output and the + expected text are interpreted as failure + + see php5/tests/README for further information on + writing regression tests +*/ +?> +--EXPECT-- +gmp extension is available diff --git a/ext/gmp/tests/002.phpt b/ext/gmp/tests/002.phpt new file mode 100644 index 0000000..ac2a7a5 --- /dev/null +++ b/ext/gmp/tests/002.phpt @@ -0,0 +1,17 @@ +--TEST-- +GMP functionality test - factorial +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php +function fact($x) { + if($x <= 1) + return 1; + else + return gmp_mul($x,fact($x-1)); +} + +print gmp_strval(fact(1000))."\n"; +?> +--EXPECT-- +402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 diff --git a/ext/gmp/tests/003.phpt b/ext/gmp/tests/003.phpt new file mode 100644 index 0000000..3798330 --- /dev/null +++ b/ext/gmp/tests/003.phpt @@ -0,0 +1,47 @@ +--TEST-- +Check for number base recognition +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + /* Binary */ + $test[] = gmp_init("0b10011010010"); + $test[] = gmp_init("0b10011010010", 2); + $test[] = gmp_init("10011010010"); + $test[] = gmp_init("10011010010", 2); + + /* Octal */ + $test[] = gmp_init("02322"); + $test[] = gmp_init("02322", 8); + $test[] = gmp_init("2322"); + $test[] = gmp_init("2322", 8); + + /* Decimal */ + $test[] = gmp_init("1234"); + $test[] = gmp_init("1234", 10); + + /* Hexidecimal */ + $test[] = gmp_init("0x4d2"); + $test[] = gmp_init("0x4d2", 16); + $test[] = gmp_init("4d2"); + $test[] = gmp_init("4d2", 16); + + for ($i = 0; $i < count($test); $i++) { + printf("%s\n", gmp_strval($test[$i])); + } +?> +--EXPECT-- +1234 +1234 +10011010010 +1234 +1234 +1234 +2322 +1234 +1234 +1234 +1234 +1234 +0 +1234 diff --git a/ext/gmp/tests/004.phpt b/ext/gmp/tests/004.phpt new file mode 100644 index 0000000..a0fa1cd --- /dev/null +++ b/ext/gmp/tests/004.phpt @@ -0,0 +1,45 @@ +--TEST-- +gmp_intval() tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_intval(1,1)); +var_dump(gmp_intval("")); +var_dump(gmp_intval(1.0001)); +var_dump(gmp_intval("1.0001")); +var_dump(gmp_intval("-1")); +var_dump(gmp_intval(-1)); +var_dump(gmp_intval(-2349828)); +var_dump(gmp_intval(2342344)); +var_dump(gmp_intval(new stdclass)); +var_dump(gmp_intval(array())); + +$fp = fopen(__FILE__, 'r'); +var_dump(gmp_intval($fp)); + +$g = gmp_init("12345678"); +var_dump(gmp_intval($g)); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_intval() expects exactly 1 parameter, 2 given in %s on line %d +NULL +int(0) +int(1) +int(1) +int(-1) +int(-1) +int(-2349828) +int(2342344) + +Notice: Object of class stdClass could not be converted to int in %s on line %d +int(1) +int(0) + +Warning: gmp_intval(): supplied resource is not a valid GMP integer resource in %s on line %d +bool(false) +int(12345678) +Done diff --git a/ext/gmp/tests/005.phpt b/ext/gmp/tests/005.phpt new file mode 100644 index 0000000..7907ffb --- /dev/null +++ b/ext/gmp/tests/005.phpt @@ -0,0 +1,80 @@ +--TEST-- +gmp_strval() tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval()); +var_dump(gmp_strval("")); +var_dump(gmp_strval("", "")); +var_dump(gmp_strval("", -1)); +var_dump(gmp_strval(-1, "")); + +$fp = fopen(__FILE__, "r"); +var_dump(gmp_strval($fp)); + +$g = gmp_init("9765456"); +var_dump(gmp_strval($g)); +var_dump(gmp_strval($g, -1)); +var_dump(gmp_strval($g, 100000)); +var_dump(gmp_strval($g, 10)); + +$g = gmp_init("-3373333"); +var_dump(gmp_strval($g)); +var_dump(gmp_strval($g, -1)); +var_dump(gmp_strval($g, 100000)); +var_dump(gmp_strval($g, 10)); + +var_dump(gmp_strval(array(1,2), array(1,2))); +var_dump(gmp_strval(new stdclass, new stdclass)); +var_dump(gmp_strval(array(1,2))); +var_dump(gmp_strval(new stdclass)); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_strval() expects at least 1 parameter, 0 given in %s on line %d +NULL +bool(false) + +Warning: gmp_strval() expects parameter 2 to be long, string given in %s on line %d +NULL + +Warning: gmp_strval(): Bad base for conversion: -1 (should be between 2 and %d or -2 and -%d) in %s on line %d +bool(false) + +Warning: gmp_strval() expects parameter 2 to be long, string given in %s on line %d +NULL + +Warning: gmp_strval(): supplied resource is not a valid GMP integer resource in %s on line %d +bool(false) +string(7) "9765456" + +Warning: gmp_strval(): Bad base for conversion: -1 (should be between 2 and %d or -2 and -%d) in %s on line %d +bool(false) + +Warning: gmp_strval(): Bad base for conversion: 100000 (should be between 2 and %d or -2 and -%d) in %s on line %d +bool(false) +string(7) "9765456" +string(8) "-3373333" + +Warning: gmp_strval(): Bad base for conversion: -1 (should be between 2 and %d or -2 and -%d) in %s on line %d +bool(false) + +Warning: gmp_strval(): Bad base for conversion: 100000 (should be between 2 and %d or -2 and -%d) in %s on line %d +bool(false) +string(8) "-3373333" + +Warning: gmp_strval() expects parameter 2 to be long, array given in %s on line %d +NULL + +Warning: gmp_strval() expects parameter 2 to be long, object given in %s on line %d +NULL + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/006.phpt b/ext/gmp/tests/006.phpt new file mode 100644 index 0000000..dedbcd0 --- /dev/null +++ b/ext/gmp/tests/006.phpt @@ -0,0 +1,50 @@ +--TEST-- +gmp_sub() tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_sub()); +var_dump(gmp_sub("")); +var_dump(gmp_sub("", "")); +var_dump(gmp_sub("", "", "")); +var_dump(gmp_sub(array(), array())); + +var_dump($g = gmp_sub(10000, 10001)); +var_dump(gmp_strval($g)); +var_dump($g = gmp_sub(10000, -1)); +var_dump(gmp_strval($g)); +var_dump($g = gmp_sub(10000, new stdclass)); +var_dump(gmp_strval($g)); +var_dump($g = gmp_sub(new stdclass, 100)); +var_dump(gmp_strval($g)); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_sub() expects exactly 2 parameters, 0 given in %s on line %d +NULL + +Warning: gmp_sub() expects exactly 2 parameters, 1 given in %s on line %d +NULL +bool(false) + +Warning: gmp_sub() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_sub(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +resource(%d) of type (GMP integer) +string(2) "-1" +resource(%d) of type (GMP integer) +string(5) "10001" + +Warning: gmp_sub(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +string(1) "0" + +Warning: gmp_sub(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +string(1) "0" +Done diff --git a/ext/gmp/tests/007.phpt b/ext/gmp/tests/007.phpt new file mode 100644 index 0000000..4d4a993 --- /dev/null +++ b/ext/gmp/tests/007.phpt @@ -0,0 +1,133 @@ +--TEST-- +gmp_div_qr() tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_div_qr()); +var_dump(gmp_div_qr("")); + +var_dump($r = gmp_div_qr(0,1)); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); +var_dump($r = gmp_div_qr(1,0)); +var_dump($r = gmp_div_qr(12653,23482734)); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); +var_dump($r = gmp_div_qr(12653,23482734, 10)); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); +var_dump($r = gmp_div_qr(1123123,123)); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); +var_dump($r = gmp_div_qr(1123123,123, 1)); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); +var_dump($r = gmp_div_qr(1123123,123, 2)); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); +var_dump($r = gmp_div_qr(1123123,123, GMP_ROUND_ZERO)); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); +var_dump($r = gmp_div_qr(1123123,123, GMP_ROUND_PLUSINF)); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); +var_dump($r = gmp_div_qr(1123123,123, GMP_ROUND_MINUSINF)); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$fp = fopen(__FILE__, 'r'); + +var_dump(gmp_div_qr($fp, $fp)); +var_dump(gmp_div_qr(array(), array())); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_div_qr() expects at least 2 parameters, 0 given in %s on line %d +NULL + +Warning: gmp_div_qr() expects at least 2 parameters, 1 given in %s on line %d +NULL +array(2) { + [0]=> + resource(%d) of type (GMP integer) + [1]=> + resource(%d) of type (GMP integer) +} +string(1) "0" +string(1) "0" + +Warning: gmp_div_qr(): Zero operand not allowed in %s on line %d +bool(false) +array(2) { + [0]=> + resource(%d) of type (GMP integer) + [1]=> + resource(%d) of type (GMP integer) +} +string(1) "0" +string(5) "12653" +NULL + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +array(2) { + [0]=> + resource(%d) of type (GMP integer) + [1]=> + resource(%d) of type (GMP integer) +} +string(4) "9131" +string(2) "10" +array(2) { + [0]=> + resource(%d) of type (GMP integer) + [1]=> + resource(%d) of type (GMP integer) +} +string(4) "9132" +string(4) "-113" +array(2) { + [0]=> + resource(%d) of type (GMP integer) + [1]=> + resource(%d) of type (GMP integer) +} +string(4) "9131" +string(2) "10" +array(2) { + [0]=> + resource(%d) of type (GMP integer) + [1]=> + resource(%d) of type (GMP integer) +} +string(4) "9131" +string(2) "10" +array(2) { + [0]=> + resource(%d) of type (GMP integer) + [1]=> + resource(%d) of type (GMP integer) +} +string(4) "9132" +string(4) "-113" +array(2) { + [0]=> + resource(%d) of type (GMP integer) + [1]=> + resource(%d) of type (GMP integer) +} +string(4) "9131" +string(2) "10" + +Warning: gmp_div_qr(): supplied resource is not a valid GMP integer resource in %s on line %d +bool(false) + +Warning: gmp_div_qr(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/008.phpt b/ext/gmp/tests/008.phpt new file mode 100644 index 0000000..4e44ec1 --- /dev/null +++ b/ext/gmp/tests/008.phpt @@ -0,0 +1,73 @@ +--TEST-- +gmp_div_r() tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_div_r()); +var_dump(gmp_div_r("")); + +var_dump($r = gmp_div_r(0,1)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_r(1,0)); +var_dump($r = gmp_div_r(12653,23482734)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_r(12653,23482734, 10)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_r(1123123,123)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_r(1123123,123, 1)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_r(1123123,123, 2)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_r(1123123,123, GMP_ROUND_ZERO)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_r(1123123,123, GMP_ROUND_PLUSINF)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_r(1123123,123, GMP_ROUND_MINUSINF)); +var_dump(gmp_strval($r)); + +$fp = fopen(__FILE__, 'r'); + +var_dump(gmp_div_r($fp, $fp)); +var_dump(gmp_div_r(array(), array())); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_div_r() expects at least 2 parameters, 0 given in %s on line %d +NULL + +Warning: gmp_div_r() expects at least 2 parameters, 1 given in %s on line %d +NULL +int(0) +string(1) "0" + +Warning: gmp_div_r(): Zero operand not allowed in %s on line %d +bool(false) +int(12653) +string(5) "12653" +NULL + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +int(10) +string(2) "10" +int(113) +string(3) "113" +int(10) +string(2) "10" +int(10) +string(2) "10" +int(113) +string(3) "113" +int(10) +string(2) "10" + +Warning: gmp_div_r(): supplied resource is not a valid GMP integer resource in %s on line %d +bool(false) + +Warning: gmp_div_r(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/009.phpt b/ext/gmp/tests/009.phpt new file mode 100644 index 0000000..745a4ef --- /dev/null +++ b/ext/gmp/tests/009.phpt @@ -0,0 +1,73 @@ +--TEST-- +gmp_div_q() tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_div_q()); +var_dump(gmp_div_q("")); + +var_dump($r = gmp_div_q(0,1)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_q(1,0)); +var_dump($r = gmp_div_q(12653,23482734)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_q(12653,23482734, 10)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_q(1123123,123)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_q(1123123,123, 1)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_q(1123123,123, 2)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_q(1123123,123, GMP_ROUND_ZERO)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_q(1123123,123, GMP_ROUND_PLUSINF)); +var_dump(gmp_strval($r)); +var_dump($r = gmp_div_q(1123123,123, GMP_ROUND_MINUSINF)); +var_dump(gmp_strval($r)); + +$fp = fopen(__FILE__, 'r'); + +var_dump(gmp_div_q($fp, $fp)); +var_dump(gmp_div_q(array(), array())); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_div_q() expects at least 2 parameters, 0 given in %s on line %d +NULL + +Warning: gmp_div_q() expects at least 2 parameters, 1 given in %s on line %d +NULL +resource(%d) of type (GMP integer) +string(1) "0" + +Warning: gmp_div_q(): Zero operand not allowed in %s on line %d +bool(false) +resource(%d) of type (GMP integer) +string(1) "0" +NULL + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +resource(%d) of type (GMP integer) +string(4) "9131" +resource(%d) of type (GMP integer) +string(4) "9132" +resource(%d) of type (GMP integer) +string(4) "9131" +resource(%d) of type (GMP integer) +string(4) "9131" +resource(%d) of type (GMP integer) +string(4) "9132" +resource(%d) of type (GMP integer) +string(4) "9131" + +Warning: gmp_div_q(): supplied resource is not a valid GMP integer resource in %s on line %d +bool(false) + +Warning: gmp_div_q(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/010.phpt b/ext/gmp/tests/010.phpt new file mode 100644 index 0000000..293a2a0 --- /dev/null +++ b/ext/gmp/tests/010.phpt @@ -0,0 +1,40 @@ +--TEST-- +gmp_mod tests() +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_mod()); +var_dump(gmp_mod("")); +var_dump(gmp_mod("","")); +var_dump(gmp_mod(0,1)); +var_dump(gmp_mod(0,-1)); +var_dump(gmp_mod(-1,0)); + +var_dump(gmp_mod(array(), array())); + +$a = gmp_init("-100000000"); +$b = gmp_init("353467"); + +var_dump(gmp_mod($a, $b)); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_mod() expects exactly 2 parameters, 0 given in %s on line %d +NULL + +Warning: gmp_mod() expects exactly 2 parameters, 1 given in %s on line %d +NULL +bool(false) +int(0) +resource(%d) of type (GMP integer) + +Warning: gmp_mod(): Zero operand not allowed in %s on line %d +bool(false) + +Warning: gmp_mod(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +resource(%d) of type (GMP integer) +Done diff --git a/ext/gmp/tests/011.phpt b/ext/gmp/tests/011.phpt new file mode 100644 index 0000000..a42c1b6 --- /dev/null +++ b/ext/gmp/tests/011.phpt @@ -0,0 +1,56 @@ +--TEST-- +gmp_divexact() tests +--SKIPIF-- +<?php +if (!extension_loaded("gmp")) die ("skip"); +if (!defined('GMP_VERSION') || version_compare("4.2.1", GMP_VERSION, ">=")) { + die("skip your GMP is too old and will crash"); +} +?> +--FILE-- +<?php + +var_dump(gmp_divexact(1, 1, 1)); +var_dump(gmp_divexact()); + +$r = gmp_divexact("233", "23345555555555555555555555"); +var_dump(gmp_strval($r)); + +$r = gmp_divexact("233", "0"); +var_dump(gmp_strval($r)); + +$r = gmp_divexact("100", "10"); +var_dump(gmp_strval($r)); + +$r = gmp_divexact("1024", "2"); +var_dump(gmp_strval($r)); + +$n = gmp_init("10000000000000000000"); +$r = gmp_divexact($n, "2"); +var_dump(gmp_strval($r)); + +$r = gmp_divexact($n, "50"); +var_dump(gmp_strval($r)); + +$n1 = gmp_init("-100000000000000000000000000"); +$r = gmp_divexact($n1, $n); +var_dump(gmp_strval($r)); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_divexact() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_divexact() expects exactly 2 parameters, 0 given in %s on line %d +NULL +string(1) "0" + +Warning: gmp_divexact(): Zero operand not allowed in %s on line %d +string(1) "0" +string(2) "10" +string(3) "512" +string(19) "5000000000000000000" +string(18) "200000000000000000" +string(9) "-10000000" +Done diff --git a/ext/gmp/tests/012.phpt b/ext/gmp/tests/012.phpt new file mode 100644 index 0000000..8582ba1 --- /dev/null +++ b/ext/gmp/tests/012.phpt @@ -0,0 +1,44 @@ +--TEST-- +gmp_neg() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_intval(gmp_neg(0))); +var_dump(gmp_intval(gmp_neg(1))); +var_dump(gmp_intval(gmp_neg(-1))); +var_dump(gmp_intval(gmp_neg("-1"))); +var_dump(gmp_intval(gmp_neg(""))); +var_dump(gmp_intval(gmp_neg(0))); + +$n = gmp_init("0"); +var_dump(gmp_intval(gmp_neg($n))); +$n = gmp_init("12345678901234567890"); +var_dump(gmp_strval(gmp_neg($n))); + +var_dump(gmp_neg(1,1)); +var_dump(gmp_neg()); +var_dump(gmp_neg(array())); + +echo "Done\n"; +?> +--EXPECTF-- +int(0) +int(-1) +int(1) +int(1) +int(0) +int(0) +int(0) +string(21) "-12345678901234567890" + +Warning: gmp_neg() expects exactly 1 parameter, 2 given in %s on line %d +NULL + +Warning: gmp_neg() expects exactly 1 parameter, 0 given in %s on line %d +NULL + +Warning: gmp_neg(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/013.phpt b/ext/gmp/tests/013.phpt new file mode 100644 index 0000000..06c2d81 --- /dev/null +++ b/ext/gmp/tests/013.phpt @@ -0,0 +1,45 @@ +--TEST-- +gmp_abs() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_abs(""))); +var_dump(gmp_strval(gmp_abs("0"))); +var_dump(gmp_strval(gmp_abs(0))); +var_dump(gmp_strval(gmp_abs(-111111111111111111111))); +var_dump(gmp_strval(gmp_abs("111111111111111111111"))); +var_dump(gmp_strval(gmp_abs("-111111111111111111111"))); +var_dump(gmp_strval(gmp_abs("0000"))); +var_dump(gmp_strval(gmp_abs("09876543"))); +var_dump(gmp_strval(gmp_abs("-099987654"))); + +var_dump(gmp_abs()); +var_dump(gmp_abs(1,2)); +var_dump(gmp_abs(array())); + +echo "Done\n"; +?> +--EXPECTF-- +string(1) "0" +string(1) "0" +string(1) "0" + +Warning: gmp_abs(): Unable to convert variable to GMP - wrong type in %s on line %d +string(1) "0" +string(21) "111111111111111111111" +string(21) "111111111111111111111" +string(1) "0" +string(1) "0" +string(1) "0" + +Warning: gmp_abs() expects exactly 1 parameter, 0 given in %s on line %d +NULL + +Warning: gmp_abs() expects exactly 1 parameter, 2 given in %s on line %d +NULL + +Warning: gmp_abs(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/014.phpt b/ext/gmp/tests/014.phpt new file mode 100644 index 0000000..40e10c6 --- /dev/null +++ b/ext/gmp/tests/014.phpt @@ -0,0 +1,58 @@ +--TEST-- +gmp_fact() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_fact(0))); +var_dump(gmp_strval(gmp_fact(""))); +var_dump(gmp_strval(gmp_fact("0"))); +var_dump(gmp_strval(gmp_fact("-1"))); +var_dump(gmp_strval(gmp_fact(-1))); +var_dump(gmp_strval(gmp_fact(1.1))); +var_dump(gmp_strval(gmp_fact(20))); +var_dump(gmp_strval(gmp_fact("50"))); +var_dump(gmp_strval(gmp_fact("10"))); +var_dump(gmp_strval(gmp_fact("0000"))); + +$n = gmp_init(12); +var_dump(gmp_strval(gmp_fact($n))); +$n = gmp_init(-10); +var_dump(gmp_strval(gmp_fact($n))); + +var_dump(gmp_fact()); +var_dump(gmp_fact(1,1)); +var_dump(gmp_fact(array())); +var_dump(gmp_strval(gmp_fact(array()))); + +echo "Done\n"; +?> +--EXPECTF-- +string(1) "1" +string(1) "1" +string(1) "1" + +Warning: gmp_fact(): Number has to be greater than or equal to 0 in %s on line %d +string(1) "0" + +Warning: gmp_fact(): Number has to be greater than or equal to 0 in %s on line %d +string(1) "0" +string(1) "1" +string(19) "2432902008176640000" +string(65) "30414093201713378043612608166064768844377641568960512000000000000" +string(7) "3628800" +string(1) "1" +string(11) "87178291200" + +Warning: gmp_fact(): Number has to be greater than or equal to 0 in %s on line %d +string(1) "0" + +Warning: gmp_fact() expects exactly 1 parameter, 0 given in %s on line %d +NULL + +Warning: gmp_fact() expects exactly 1 parameter, 2 given in %s on line %d +NULL +resource(%d) of type (GMP integer) +string(1) "1" +Done diff --git a/ext/gmp/tests/015.phpt b/ext/gmp/tests/015.phpt new file mode 100644 index 0000000..e17ecc7 --- /dev/null +++ b/ext/gmp/tests/015.phpt @@ -0,0 +1,68 @@ +--TEST-- +gmp_pow() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_pow(2,10))); +var_dump(gmp_strval(gmp_pow(-2,10))); +var_dump(gmp_strval(gmp_pow(-2,11))); +var_dump(gmp_strval(gmp_pow("2",10))); +var_dump(gmp_strval(gmp_pow("2",0))); +var_dump(gmp_strval(gmp_pow("2",-1))); +var_dump(gmp_strval(gmp_pow("-2",10))); +var_dump(gmp_strval(gmp_pow(20,10))); +var_dump(gmp_strval(gmp_pow(50,10))); +var_dump(gmp_strval(gmp_pow(50,-5))); + +$n = gmp_init("20"); +var_dump(gmp_strval(gmp_pow($n,10))); +$n = gmp_init("-20"); +var_dump(gmp_strval(gmp_pow($n,10))); + +var_dump(gmp_pow(2,10,1)); +var_dump(gmp_pow(2)); +var_dump(gmp_pow()); +var_dump(gmp_pow(array(), array())); +var_dump(gmp_pow(2,array())); +var_dump(gmp_pow(array(),10)); + +echo "Done\n"; +?> +--EXPECTF-- +string(4) "1024" +string(4) "1024" +string(5) "-2048" +string(4) "1024" +string(1) "1" + +Warning: gmp_pow(): Negative exponent not supported in %s on line %d +string(1) "0" +string(4) "1024" +string(14) "10240000000000" +string(17) "97656250000000000" + +Warning: gmp_pow(): Negative exponent not supported in %s on line %d +string(1) "0" +string(14) "10240000000000" +string(14) "10240000000000" + +Warning: gmp_pow() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_pow() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_pow() expects exactly 2 parameters, 0 given in %s on line %d +NULL + +Warning: gmp_pow() expects parameter 2 to be long, array given in %s on line %d +NULL + +Warning: gmp_pow() expects parameter 2 to be long, array given in %s on line %d +NULL + +Warning: gmp_pow(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/016.phpt b/ext/gmp/tests/016.phpt new file mode 100644 index 0000000..4436086 --- /dev/null +++ b/ext/gmp/tests/016.phpt @@ -0,0 +1,73 @@ +--TEST-- +gmp_powm() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_powm(0,1,10))); +var_dump(gmp_strval(gmp_powm(5,1,10))); +var_dump(gmp_strval(gmp_powm(-5,1,-10))); +var_dump(gmp_strval(gmp_powm(-5,1,10))); +var_dump(gmp_strval(gmp_powm(-5,11,10))); +var_dump(gmp_strval(gmp_powm("77",3,1000))); + +$n = gmp_init(11); +var_dump(gmp_strval(gmp_powm($n,3,1000))); +$e = gmp_init(7); +var_dump(gmp_strval(gmp_powm($n,$e,1000))); +$m = gmp_init(900); +var_dump(gmp_strval(gmp_powm($n,$e,$m))); + +var_dump(gmp_powm(array(),$e,$m)); +var_dump(gmp_powm($n,array(),$m)); +var_dump(gmp_powm($n,$e,array())); +var_dump(gmp_powm(array(),array(),array())); +var_dump(gmp_powm(array(),array())); +var_dump(gmp_powm(array())); +var_dump(gmp_powm()); + +$n = gmp_init("-5"); +var_dump(gmp_powm(10, $n, 10)); + +$n = gmp_init("0"); +var_dump(gmp_powm(10, $n, 10)); + +echo "Done\n"; +?> +--EXPECTF-- +string(1) "0" +string(1) "5" +string(1) "5" +string(1) "5" +string(1) "5" +string(3) "533" +string(3) "331" +string(3) "171" +string(3) "371" + +Warning: gmp_powm(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_powm(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_powm(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_powm(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_powm() expects exactly 3 parameters, 2 given in %s on line %d +NULL + +Warning: gmp_powm() expects exactly 3 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_powm() expects exactly 3 parameters, 0 given in %s on line %d +NULL + +Warning: gmp_powm(): Second parameter cannot be less than 0 in %s on line %d +bool(false) +resource(%d) of type (GMP integer) +Done diff --git a/ext/gmp/tests/017.phpt b/ext/gmp/tests/017.phpt new file mode 100644 index 0000000..d90f538 --- /dev/null +++ b/ext/gmp/tests/017.phpt @@ -0,0 +1,50 @@ +--TEST-- +gmp_sqrt() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_sqrt(-2))); +var_dump(gmp_strval(gmp_sqrt("-2"))); +var_dump(gmp_strval(gmp_sqrt("0"))); +var_dump(gmp_strval(gmp_sqrt("2"))); +var_dump(gmp_strval(gmp_sqrt("144"))); + +$n = gmp_init(0); +var_dump(gmp_strval(gmp_sqrt($n))); +$n = gmp_init(-144); +var_dump(gmp_strval(gmp_sqrt($n))); +$n = gmp_init(777); +var_dump(gmp_strval(gmp_sqrt($n))); + +var_dump(gmp_sqrt($n, 1)); +var_dump(gmp_sqrt()); +var_dump(gmp_sqrt(array())); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_sqrt(): Number has to be greater than or equal to 0 in %s on line %d +string(1) "0" + +Warning: gmp_sqrt(): Number has to be greater than or equal to 0 in %s on line %d +string(1) "0" +string(1) "0" +string(1) "1" +string(2) "12" +string(1) "0" + +Warning: gmp_sqrt(): Number has to be greater than or equal to 0 in %s on line %d +string(1) "0" +string(2) "27" + +Warning: gmp_sqrt() expects exactly 1 parameter, 2 given in %s on line %d +NULL + +Warning: gmp_sqrt() expects exactly 1 parameter, 0 given in %s on line %d +NULL + +Warning: gmp_sqrt(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/018.phpt b/ext/gmp/tests/018.phpt new file mode 100644 index 0000000..2fca463 --- /dev/null +++ b/ext/gmp/tests/018.phpt @@ -0,0 +1,100 @@ +--TEST-- +gmp_sqrtrem() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +$r = gmp_sqrtrem(-1); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$r = gmp_sqrtrem("0"); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$r = gmp_sqrtrem(2); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$r = gmp_sqrtrem(10); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$r = gmp_sqrtrem(7); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$r = gmp_sqrtrem(3); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$r = gmp_sqrtrem(100000); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$r = gmp_sqrtrem("1000000"); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$r = gmp_sqrtrem("1000001"); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + + +$n = gmp_init(-1); +$r = gmp_sqrtrem($n); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +$n = gmp_init(1000001); +$r = gmp_sqrtrem($n); +var_dump(gmp_strval($r[0])); +var_dump(gmp_strval($r[1])); + +var_dump(gmp_sqrtrem(array())); +var_dump(gmp_sqrtrem()); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_sqrtrem(): Number has to be greater than or equal to 0 in %s on line %d + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +string(1) "0" +string(1) "0" +string(1) "1" +string(1) "1" +string(1) "3" +string(1) "1" +string(1) "2" +string(1) "3" +string(1) "1" +string(1) "2" +string(3) "316" +string(3) "144" +string(4) "1000" +string(1) "0" +string(4) "1000" +string(1) "1" + +Warning: gmp_sqrtrem(): Number has to be greater than or equal to 0 in %s on line %d + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +string(4) "1000" +string(1) "1" + +Warning: gmp_sqrtrem(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_sqrtrem() expects exactly 1 parameter, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/019.phpt b/ext/gmp/tests/019.phpt new file mode 100644 index 0000000..aa596ba --- /dev/null +++ b/ext/gmp/tests/019.phpt @@ -0,0 +1,47 @@ +--TEST-- +gmp_perfect_square() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_perfect_square(0)); +var_dump(gmp_perfect_square("0")); +var_dump(gmp_perfect_square(-1)); +var_dump(gmp_perfect_square(1)); +var_dump(gmp_perfect_square(16)); +var_dump(gmp_perfect_square(17)); +var_dump(gmp_perfect_square("1000000")); +var_dump(gmp_perfect_square("1000001")); + +$n = gmp_init(100101); +var_dump(gmp_perfect_square($n)); +$n = gmp_init(64); +var_dump(gmp_perfect_square($n)); +$n = gmp_init(-5); +var_dump(gmp_perfect_square($n)); + +var_dump(gmp_perfect_square()); +var_dump(gmp_perfect_square(array())); + +echo "Done\n"; +?> +--EXPECTF-- +bool(true) +bool(true) +bool(false) +bool(true) +bool(true) +bool(false) +bool(true) +bool(false) +bool(false) +bool(true) +bool(false) + +Warning: gmp_perfect_square() expects exactly 1 parameter, 0 given in %s on line %d +NULL + +Warning: gmp_perfect_square(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/020.phpt b/ext/gmp/tests/020.phpt new file mode 100644 index 0000000..f8f3e69 --- /dev/null +++ b/ext/gmp/tests/020.phpt @@ -0,0 +1,81 @@ +--TEST-- +gmp_prob_prime() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_prob_prime(10)); +var_dump(gmp_prob_prime("7")); +var_dump(gmp_prob_prime(17)); +var_dump(gmp_prob_prime(-31)); +var_dump(gmp_prob_prime("172368715471481723")); + +var_dump(gmp_prob_prime(10)); +var_dump(gmp_prob_prime("7")); +var_dump(gmp_prob_prime(17)); +var_dump(gmp_prob_prime(-31)); +var_dump(gmp_prob_prime("172368715471481723")); + +for ($i = -1; $i < 12; $i++) { + var_dump(gmp_prob_prime((773*$i)-($i*7)-1, $i)); + $n = gmp_init("23476812735411"); + var_dump(gmp_prob_prime(gmp_add($n, $i-1), $i)); +} + +$n = gmp_init("19481923"); +var_dump(gmp_prob_prime($n)); +$n = gmp_init(0); +var_dump(gmp_prob_prime($n)); + +var_dump(gmp_prob_prime()); +var_dump(gmp_prob_prime(array())); + +echo "Done\n"; +?> +--EXPECTF-- +int(0) +int(2) +int(2) +int(2) +int(0) +int(0) +int(2) +int(2) +int(2) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(2) +int(0) +int(2) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) + +Warning: gmp_prob_prime() expects at least 1 parameter, 0 given in %s on line %d +NULL + +Warning: gmp_prob_prime(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/021.phpt b/ext/gmp/tests/021.phpt new file mode 100644 index 0000000..275f0bc --- /dev/null +++ b/ext/gmp/tests/021.phpt @@ -0,0 +1,51 @@ +--TEST-- +gmp_gcd() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_gcd(234,12387))); +var_dump(gmp_strval(gmp_gcd(0,12387))); +var_dump(gmp_strval(gmp_gcd(224,0))); +var_dump(gmp_strval(gmp_gcd(-1,0))); +var_dump(gmp_strval(gmp_gcd(-1,0))); +var_dump(gmp_strval(gmp_gcd("12371238123","32618723123"))); +var_dump(gmp_strval(gmp_gcd("7623456735","12372341234"))); + +$n = gmp_init("8127346234"); +var_dump(gmp_strval(gmp_gcd($n,"12372341234"))); +$n = gmp_init("8127346234"); +var_dump(gmp_strval(gmp_gcd("7623456735",$n))); +$n = gmp_init("8127346234"); +var_dump(gmp_strval(gmp_gcd($n,$n))); +$n = gmp_init("8127346234"); +var_dump(gmp_strval(gmp_gcd($n,0))); +var_dump(gmp_gcd($n,$n,1)); +var_dump(gmp_gcd($n,array(),1)); +var_dump(gmp_gcd(array(),$n,1)); + +echo "Done\n"; +?> +--EXPECTF-- +string(1) "3" +string(5) "12387" +string(3) "224" +string(1) "1" +string(1) "1" +string(1) "1" +string(1) "1" +string(1) "2" +string(1) "1" +string(10) "8127346234" +string(10) "8127346234" + +Warning: gmp_gcd() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_gcd() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_gcd() expects exactly 2 parameters, 3 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/022.phpt b/ext/gmp/tests/022.phpt new file mode 100644 index 0000000..469aa30 --- /dev/null +++ b/ext/gmp/tests/022.phpt @@ -0,0 +1,86 @@ +--TEST-- +gmp_gcdext() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; +?> +--FILE-- +<?php + +$n = gmp_init("34293864345"); +$n1 = gmp_init("23434293864345"); + +$a = array( + array(123,45), + array(4341,9734), + array(23487,333), + array(-234234,-123123), + array(-100,-2234), + array(345,"34587345"), + array(345,"0"), + array("345556456",345873), + array("34545345556456","323432445873"), + array($n, $n1), + ); + +foreach ($a as $val) { + $r = gmp_gcdext($val[0],$val[1]); + var_dump(gmp_strval($r['g'])); + var_dump(gmp_strval($r['s'])); + var_dump(gmp_strval($r['t'])); +} + +var_dump(gmp_gcdext($val[0],array())); +var_dump(gmp_gcdext(array(),array())); +var_dump(gmp_gcdext(array(),array(),1)); +var_dump(gmp_gcdext(array())); +var_dump(gmp_gcdext()); + +echo "Done\n"; +?> +--EXPECTF-- +string(1) "3" +string(2) "-4" +string(2) "11" +string(1) "1" +string(4) "-805" +string(3) "359" +string(1) "3" +string(2) "32" +string(5) "-2257" +string(4) "3003" +string(3) "-10" +string(2) "19" +string(1) "2" +string(2) "67" +string(2) "-3" +string(2) "15" +string(7) "-601519" +string(1) "6" +string(3) "345" +string(1) "1" +string(1) "0" +string(1) "1" +string(5) "84319" +string(9) "-84241831" +string(1) "1" +string(13) "-156252240050" +string(14) "16689072773537" +string(3) "195" +string(11) "46994884483" +string(9) "-68772552" + +Warning: gmp_gcdext(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_gcdext(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_gcdext() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_gcdext() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_gcdext() expects exactly 2 parameters, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/023.phpt b/ext/gmp/tests/023.phpt new file mode 100644 index 0000000..81a90fe --- /dev/null +++ b/ext/gmp/tests/023.phpt @@ -0,0 +1,55 @@ +--TEST-- +gmp_invert() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_invert(123123,5467624))); +var_dump(gmp_strval(gmp_invert(123123,"3333334345467624"))); +var_dump(gmp_strval(gmp_invert("12312323213123123",7624))); +var_dump(gmp_strval(gmp_invert(444,0))); +var_dump(gmp_strval(gmp_invert(0,28347))); +var_dump(gmp_strval(gmp_invert(-12,456456))); +var_dump(gmp_strval(gmp_invert(234234,-435345))); + +$n = gmp_init("349827349623423452345"); +$n1 = gmp_init("3498273496234234523451"); + +var_dump(gmp_strval(gmp_invert($n, $n1))); +var_dump(gmp_strval(gmp_invert($n1, $n))); + +var_dump(gmp_invert($n1, $n, 10)); +var_dump(gmp_invert($n1)); +var_dump(gmp_invert(array(), 1)); +var_dump(gmp_invert(1, array())); +var_dump(gmp_invert(array(), array())); + +echo "Done\n"; +?> +--EXPECTF-- +string(7) "2293131" +string(1) "0" +string(4) "5827" +string(1) "0" +string(1) "0" +string(1) "0" +string(1) "0" +string(22) "3498273496234234523441" +string(1) "1" + +Warning: gmp_invert() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_invert() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_invert(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_invert(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_invert(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/024.phpt b/ext/gmp/tests/024.phpt new file mode 100644 index 0000000..04ddba4 --- /dev/null +++ b/ext/gmp/tests/024.phpt @@ -0,0 +1,69 @@ +--TEST-- +gmp_jacobi() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +for ($i = -1; $i < 10; $i++) { + var_dump(gmp_strval(gmp_jacobi(($i*$i)-1, 3))); +} + +var_dump(gmp_strval(gmp_jacobi(7, 23))); +var_dump(gmp_strval(gmp_jacobi("733535124", "1234123423434535623"))); +var_dump(gmp_strval(gmp_jacobi(3, "1234123423434535623"))); + +$n = "123123"; +$n1 = "1231231"; + +var_dump(gmp_strval(gmp_jacobi($n, $n1))); +var_dump(gmp_strval(gmp_jacobi($n, 3))); +var_dump(gmp_strval(gmp_jacobi(3, $n1))); + +var_dump(gmp_jacobi(3, array())); +var_dump(gmp_jacobi(array(), 3)); +var_dump(gmp_jacobi(array(), array())); + +var_dump(gmp_jacobi(array(), array(), 1)); +var_dump(gmp_jacobi(array())); +var_dump(gmp_jacobi()); + +echo "Done\n"; +?> +--EXPECTF-- +string(1) "0" +string(2) "-1" +string(1) "0" +string(1) "0" +string(2) "-1" +string(1) "0" +string(1) "0" +string(2) "-1" +string(1) "0" +string(1) "0" +string(2) "-1" +string(2) "-1" +string(1) "0" +string(1) "0" +string(2) "-1" +string(1) "0" +string(2) "-1" + +Warning: gmp_jacobi(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_jacobi(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_jacobi(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_jacobi() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_jacobi() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_jacobi() expects exactly 2 parameters, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/025.phpt b/ext/gmp/tests/025.phpt new file mode 100644 index 0000000..6dde34e --- /dev/null +++ b/ext/gmp/tests/025.phpt @@ -0,0 +1,69 @@ +--TEST-- +gmp_legendre() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +for ($i = -1; $i < 10; $i++) { + var_dump(gmp_strval(gmp_legendre(($i*$i)-1, 3))); +} + +var_dump(gmp_strval(gmp_legendre(7, 23))); +var_dump(gmp_strval(gmp_legendre("733535124", "1234123423434535623"))); +var_dump(gmp_strval(gmp_legendre(3, "1234123423434535623"))); + +$n = "123123"; +$n1 = "1231231"; + +var_dump(gmp_strval(gmp_legendre($n, $n1))); +var_dump(gmp_strval(gmp_legendre($n, 3))); +var_dump(gmp_strval(gmp_legendre(3, $n1))); + +var_dump(gmp_legendre(3, array())); +var_dump(gmp_legendre(array(), 3)); +var_dump(gmp_legendre(array(), array())); + +var_dump(gmp_legendre(array(), array(), 1)); +var_dump(gmp_legendre(array())); +var_dump(gmp_legendre()); + +echo "Done\n"; +?> +--EXPECTF-- +string(1) "0" +string(2) "-1" +string(1) "0" +string(1) "0" +string(2) "-1" +string(1) "0" +string(1) "0" +string(2) "-1" +string(1) "0" +string(1) "0" +string(2) "-1" +string(2) "-1" +string(1) "0" +string(1) "0" +string(2) "-1" +string(1) "0" +string(2) "-1" + +Warning: gmp_legendre(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_legendre(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_legendre(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_legendre() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_legendre() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_legendre() expects exactly 2 parameters, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/026.phpt b/ext/gmp/tests/026.phpt new file mode 100644 index 0000000..83e7910 --- /dev/null +++ b/ext/gmp/tests/026.phpt @@ -0,0 +1,48 @@ +--TEST-- +gmp_cmp() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_cmp(123123,-123123)); +var_dump(gmp_cmp("12345678900987654321","12345678900987654321")); +var_dump(gmp_cmp("12345678900987654321","123456789009876543211")); +var_dump(gmp_cmp(0,0)); +var_dump(gmp_cmp(1231222,0)); +var_dump(gmp_cmp(0,345355)); + +$n = gmp_init("827278512385463739"); +var_dump(gmp_cmp(0,$n) < 0); +$n1 = gmp_init("827278512385463739"); +var_dump(gmp_cmp($n1,$n)); + +var_dump(gmp_cmp($n1,$n,1)); +var_dump(gmp_cmp(array(),array())); +var_dump(gmp_cmp(array())); +var_dump(gmp_cmp()); + +echo "Done\n"; +?> +--EXPECTF-- +int(2) +int(0) +int(-1) +int(0) +int(1) +int(-1) +bool(true) +int(0) + +Warning: gmp_cmp() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_cmp(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_cmp() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_cmp() expects exactly 2 parameters, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/027.phpt b/ext/gmp/tests/027.phpt new file mode 100644 index 0000000..71204db --- /dev/null +++ b/ext/gmp/tests/027.phpt @@ -0,0 +1,39 @@ +--TEST-- +gmp_sign() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_sign(-1)); +var_dump(gmp_sign(1)); +var_dump(gmp_sign(0)); +var_dump(gmp_sign("123718235123123")); +var_dump(gmp_sign("-34535345345")); +var_dump(gmp_sign("+34534573457345")); +$n = gmp_init("098909878976786545"); +var_dump(gmp_sign($n)); +var_dump(gmp_sign($n, $n)); +var_dump(gmp_sign(array())); +var_dump(gmp_sign()); + +echo "Done\n"; +?> +--EXPECTF-- +int(-1) +int(1) +int(0) +int(1) +int(-1) +bool(false) +int(0) + +Warning: gmp_sign() expects exactly 1 parameter, 2 given in %s on line %d +NULL + +Warning: gmp_sign(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_sign() expects exactly 1 parameter, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/028.phpt b/ext/gmp/tests/028.phpt new file mode 100644 index 0000000..3a876aa --- /dev/null +++ b/ext/gmp/tests/028.phpt @@ -0,0 +1,41 @@ +--TEST-- +gmp_random() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_random())); +var_dump(gmp_strval(gmp_random(-1))); +var_dump(gmp_strval(gmp_random(0))); +var_dump(gmp_strval(gmp_random(10))); +var_dump(gmp_strval(gmp_random("-10"))); +var_dump(gmp_strval(gmp_random(-10))); + +var_dump(gmp_random(array())); +var_dump(gmp_random(array(),1)); +var_dump(gmp_random("")); +var_dump(gmp_random("test")); + +echo "Done\n"; +?> +--EXPECTF-- +string(%d) "%d" +string(%d) "%d" +string(1) "%d" +string(%d) "%d" +string(%d) "%d" +string(%d) "%d" + +Warning: gmp_random() expects parameter 1 to be long, array given in %s on line %d +NULL + +Warning: gmp_random() expects at most 1 parameter, 2 given in %s on line %d +NULL + +Warning: gmp_random() expects parameter 1 to be long, string given in %s on line %d +NULL + +Warning: gmp_random() expects parameter 1 to be long, string given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/029.phpt b/ext/gmp/tests/029.phpt new file mode 100644 index 0000000..1b86e47 --- /dev/null +++ b/ext/gmp/tests/029.phpt @@ -0,0 +1,52 @@ +--TEST-- +gmp_and() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_and("111111", "2222222"))); +var_dump(gmp_strval(gmp_and(123123, 435234))); +var_dump(gmp_strval(gmp_and(555, "2342341123"))); +var_dump(gmp_strval(gmp_and(-1, 3333))); +var_dump(gmp_strval(gmp_and(4545, -20))); +var_dump(gmp_strval(gmp_and("test", "no test"))); + +$n = gmp_init("987657876543456"); +var_dump(gmp_strval(gmp_and($n, "34332"))); +$n1 = gmp_init("987657878765436543456"); +var_dump(gmp_strval(gmp_and($n, $n1))); + +var_dump(gmp_and($n, $n1, 1)); +var_dump(gmp_and(1)); +var_dump(gmp_and(array(), 1)); +var_dump(gmp_and(1, array())); +var_dump(gmp_and(array(), array())); + +echo "Done\n"; +?> +--EXPECTF-- +string(6) "106502" +string(5) "40994" +string(3) "515" +string(4) "3333" +string(4) "4544" +string(1) "0" +string(4) "1536" +string(15) "424703623692768" + +Warning: gmp_and() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_and() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_and(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_and(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_and(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/030.phpt b/ext/gmp/tests/030.phpt new file mode 100644 index 0000000..633af41 --- /dev/null +++ b/ext/gmp/tests/030.phpt @@ -0,0 +1,52 @@ +--TEST-- +gmp_or() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_or("111111", "2222222"))); +var_dump(gmp_strval(gmp_or(123123, 435234))); +var_dump(gmp_strval(gmp_or(555, "2342341123"))); +var_dump(gmp_strval(gmp_or(-1, 3333))); +var_dump(gmp_strval(gmp_or(4545, -20))); +var_dump(gmp_strval(gmp_or("test", "no test"))); + +$n = gmp_init("987657876543456"); +var_dump(gmp_strval(gmp_or($n, "34332"))); +$n1 = gmp_init("987657878765436543456"); +var_dump(gmp_strval(gmp_or($n, $n1))); + +var_dump(gmp_or($n, $n1, 1)); +var_dump(gmp_or(1)); +var_dump(gmp_or(array(), 1)); +var_dump(gmp_or(1, array())); +var_dump(gmp_or(array(), array())); + +echo "Done\n"; +?> +--EXPECTF-- +string(7) "2226831" +string(6) "517363" +string(10) "2342341163" +string(2) "-1" +string(3) "-19" +string(1) "0" +string(15) "987657876576252" +string(21) "987658441719689394144" + +Warning: gmp_or() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_or() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_or(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_or(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_or(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/031.phpt b/ext/gmp/tests/031.phpt new file mode 100644 index 0000000..90ce175 --- /dev/null +++ b/ext/gmp/tests/031.phpt @@ -0,0 +1,44 @@ +--TEST-- +gmp_com() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_com(0))); +var_dump(gmp_strval(gmp_com("0"))); +var_dump(gmp_strval(gmp_com("test"))); +var_dump(gmp_strval(gmp_com("2394876545678"))); +var_dump(gmp_strval(gmp_com("-111"))); +var_dump(gmp_strval(gmp_com(874653))); +var_dump(gmp_strval(gmp_com(-9876))); + +$n = gmp_init("98765467"); +var_dump(gmp_strval(gmp_com($n))); +$n = gmp_init("98765463337"); +var_dump(gmp_strval(gmp_com($n))); + +var_dump(gmp_strval(gmp_com(array()))); +var_dump(gmp_strval(gmp_com())); + +echo "Done\n"; +?> +--EXPECTF-- +string(2) "-1" +string(2) "-1" +string(1) "0" +string(14) "-2394876545679" +string(3) "110" +string(7) "-874654" +string(4) "9875" +string(9) "-98765468" +string(12) "-98765463338" + +Warning: gmp_com(): Unable to convert variable to GMP - wrong type in %s on line %d +string(1) "0" + +Warning: gmp_com() expects exactly 1 parameter, 0 given in %s on line %d + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/032.phpt b/ext/gmp/tests/032.phpt new file mode 100644 index 0000000..327c979 --- /dev/null +++ b/ext/gmp/tests/032.phpt @@ -0,0 +1,52 @@ +--TEST-- +gmp_xor() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_strval(gmp_xor("111111", "2222222"))); +var_dump(gmp_strval(gmp_xor(123123, 435234))); +var_dump(gmp_strval(gmp_xor(555, "2342341123"))); +var_dump(gmp_strval(gmp_xor(-1, 3333))); +var_dump(gmp_strval(gmp_xor(4545, -20))); +var_dump(gmp_strval(gmp_xor("test", "no test"))); + +$n = gmp_init("987657876543456"); +var_dump(gmp_strval(gmp_xor($n, "34332"))); +$n1 = gmp_init("987657878765436543456"); +var_dump(gmp_strval(gmp_xor($n, $n1))); + +var_dump(gmp_xor($n, $n1, 1)); +var_dump(gmp_xor(1)); +var_dump(gmp_xor(array(), 1)); +var_dump(gmp_xor(1, array())); +var_dump(gmp_xor(array(), array())); + +echo "Done\n"; +?> +--EXPECTF-- +string(7) "2120329" +string(6) "476369" +string(10) "2342340648" +string(5) "-3334" +string(5) "-4563" +string(1) "0" +string(15) "987657876574716" +string(21) "987658017016065701376" + +Warning: gmp_xor() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_xor() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_xor(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_xor(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_xor(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) +Done diff --git a/ext/gmp/tests/033.phpt b/ext/gmp/tests/033.phpt new file mode 100644 index 0000000..38ff5be --- /dev/null +++ b/ext/gmp/tests/033.phpt @@ -0,0 +1,64 @@ +--TEST-- +gmp_setbit() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +$n = gmp_init(-1); +gmp_setbit($n, 10, -1); +var_dump(gmp_strval($n)); + +$n = gmp_init(5); +gmp_setbit($n, -20, 0); +var_dump(gmp_strval($n)); + +$n = gmp_init(5); +gmp_setbit($n, 2, 0); +var_dump(gmp_strval($n)); + +$n = gmp_init(5); +gmp_setbit($n, 1, 1); +var_dump(gmp_strval($n)); + +$n = gmp_init("100000000000"); +gmp_setbit($n, 23, 1); +var_dump(gmp_strval($n)); + +gmp_setbit($n, 23, 0); +var_dump(gmp_strval($n)); + +gmp_setbit($n, 3); +var_dump(gmp_strval($n)); + +$b = ""; +gmp_setbit($b, 23); +gmp_setbit($b); +gmp_setbit($b, 23,1,1); +gmp_setbit($b,array()); +$a = array(); +gmp_setbit($a,array()); + +echo "Done\n"; +?> +--EXPECTF-- +string(2) "-1" + +Warning: gmp_setbit(): Index must be greater than or equal to zero in %s on line %d +string(1) "5" +string(1) "1" +string(1) "7" +string(12) "100008388608" +string(12) "100000000000" +string(12) "100000000008" + +Warning: gmp_setbit(): supplied argument is not a valid GMP integer resource in %s on line %d + +Warning: gmp_setbit() expects at least 2 parameters, 1 given in %s on line %d + +Warning: gmp_setbit() expects at most 3 parameters, 4 given in %s on line %d + +Warning: gmp_setbit() expects parameter 2 to be long, array given in %s on line %d + +Warning: gmp_setbit() expects parameter 2 to be long, array given in %s on line %d +Done diff --git a/ext/gmp/tests/034.phpt b/ext/gmp/tests/034.phpt new file mode 100644 index 0000000..6011029 --- /dev/null +++ b/ext/gmp/tests/034.phpt @@ -0,0 +1,56 @@ +--TEST-- +gmp_clrbit() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +$n = gmp_init(0); +gmp_clrbit($n, 0); +var_dump(gmp_strval($n)); + +$n = gmp_init(-1); +gmp_clrbit($n, -1); +var_dump(gmp_strval($n)); + +$n = gmp_init("1000000"); +gmp_clrbit($n, -1); +var_dump(gmp_strval($n)); + +$n = gmp_init("1000000"); +gmp_clrbit($n, 3); +var_dump(gmp_strval($n)); + +$n = gmp_init("238462734628347239571823641234"); +gmp_clrbit($n, 3); +gmp_clrbit($n, 5); +gmp_clrbit($n, 20); +var_dump(gmp_strval($n)); + +$n = array(); +gmp_clrbit($n, 3); +gmp_clrbit($n, 3, 1); +gmp_clrbit($n); +gmp_clrbit(); + +echo "Done\n"; +?> +--EXPECTF-- +string(1) "0" + +Warning: gmp_clrbit(): Index must be greater than or equal to zero in %s on line %d +string(2) "-1" + +Warning: gmp_clrbit(): Index must be greater than or equal to zero in %s on line %d +string(7) "1000000" +string(7) "1000000" +string(30) "238462734628347239571822592658" + +Warning: gmp_clrbit(): supplied argument is not a valid GMP integer resource in %s on line %d + +Warning: gmp_clrbit() expects exactly 2 parameters, 3 given in %s on line %d + +Warning: gmp_clrbit() expects exactly 2 parameters, 1 given in %s on line %d + +Warning: gmp_clrbit() expects exactly 2 parameters, 0 given in %s on line %d +Done diff --git a/ext/gmp/tests/035.phpt b/ext/gmp/tests/035.phpt new file mode 100644 index 0000000..4b45a04 --- /dev/null +++ b/ext/gmp/tests/035.phpt @@ -0,0 +1,33 @@ +--TEST-- +gmp_popcount() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_popcount(-1)); +var_dump(gmp_popcount(0)); +var_dump(gmp_popcount(12123)); +var_dump(gmp_popcount("52638927634234")); +var_dump(gmp_popcount("-23476123423433")); +$n = gmp_init("9876546789222"); +var_dump(gmp_popcount($n)); +var_dump(gmp_popcount(array())); +var_dump(gmp_popcount()); + +echo "Done\n"; +?> +--EXPECTF-- +int(-1) +int(0) +int(10) +int(31) +int(-1) +int(20) + +Warning: gmp_popcount(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_popcount() expects exactly 1 parameter, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/036.phpt b/ext/gmp/tests/036.phpt new file mode 100644 index 0000000..c21e03c --- /dev/null +++ b/ext/gmp/tests/036.phpt @@ -0,0 +1,50 @@ +--TEST-- +gmp_hamdist() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_hamdist(1231231, 0)); +var_dump(gmp_hamdist(1231231, -1)); +var_dump(gmp_hamdist(1231231, "8765434567897654333334567")); +var_dump(gmp_hamdist(-364264234, "8333765434567897654333334567")); + +$n = gmp_init("8765434567"); +$n1 = gmp_init("987654445678"); +var_dump(gmp_hamdist($n, "8333765434567897654333334567")); +var_dump(gmp_hamdist($n, $n)); +var_dump(gmp_hamdist($n, $n1)); + +var_dump(gmp_hamdist($n, $n1, 1)); +var_dump(gmp_hamdist($n, array())); +var_dump(gmp_hamdist(array(), $n)); +var_dump(gmp_hamdist(array(), array())); +var_dump(gmp_hamdist()); + +echo "Done\n"; +?> +--EXPECTF-- +int(13) +int(-1) +int(36) +int(-1) +int(43) +int(0) +int(26) + +Warning: gmp_hamdist() expects exactly 2 parameters, 3 given in %s on line %d +NULL + +Warning: gmp_hamdist(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_hamdist(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_hamdist(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_hamdist() expects exactly 2 parameters, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/037.phpt b/ext/gmp/tests/037.phpt new file mode 100644 index 0000000..2a87a96 --- /dev/null +++ b/ext/gmp/tests/037.phpt @@ -0,0 +1,40 @@ +--TEST-- +gmp_scan0() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_scan0("434234", -10)); +var_dump(gmp_scan0("434234", 1)); +var_dump(gmp_scan0(4096, 0)); +var_dump(gmp_scan0("1000000000", 5)); +var_dump(gmp_scan0("1000000000", 200)); + +$n = gmp_init("24234527465274"); +var_dump(gmp_scan0($n, 10)); + +var_dump(gmp_scan0(array(), 200)); +var_dump(gmp_scan0(array())); +var_dump(gmp_scan0()); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_scan0(): Starting index must be greater than or equal to zero in %s on line %d +bool(false) +int(2) +int(0) +int(5) +int(200) +int(13) + +Warning: gmp_scan0(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_scan0() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_scan0() expects exactly 2 parameters, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/038.phpt b/ext/gmp/tests/038.phpt new file mode 100644 index 0000000..7ebce9b --- /dev/null +++ b/ext/gmp/tests/038.phpt @@ -0,0 +1,40 @@ +--TEST-- +gmp_scan1() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_scan1("434234", -10)); +var_dump(gmp_scan1("434234", 1)); +var_dump(gmp_scan1(4096, 0)); +var_dump(gmp_scan1("1000000000", 5)); +var_dump(gmp_scan1("1000000000", 200)); + +$n = gmp_init("24234527465274"); +var_dump(gmp_scan1($n, 10)); + +var_dump(gmp_scan1(array(), 200)); +var_dump(gmp_scan1(array())); +var_dump(gmp_scan1()); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_scan1(): Starting index must be greater than or equal to zero in %s on line %d +bool(false) +int(1) +int(12) +int(9) +int(-1) +int(10) + +Warning: gmp_scan1(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_scan1() expects exactly 2 parameters, 1 given in %s on line %d +NULL + +Warning: gmp_scan1() expects exactly 2 parameters, 0 given in %s on line %d +NULL +Done diff --git a/ext/gmp/tests/039.phpt b/ext/gmp/tests/039.phpt new file mode 100644 index 0000000..399c511 --- /dev/null +++ b/ext/gmp/tests/039.phpt @@ -0,0 +1,60 @@ +--TEST-- +gmp_testbit() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +$n = gmp_init(0); +var_dump(gmp_testbit($n, -10)); +var_dump(gmp_testbit($n, 0)); +var_dump(gmp_testbit($n, 1)); +var_dump(gmp_testbit($n, 100)); + +$n = gmp_init(-1); +var_dump(gmp_testbit($n, 1)); +var_dump(gmp_testbit($n, -1)); + +$n = gmp_init("1000000"); +var_dump(gmp_testbit($n, 1)); +gmp_setbit($n, 1); +var_dump(gmp_testbit($n, 1)); +var_dump(gmp_strval($n)); + +gmp_setbit($n, 5); +var_dump(gmp_testbit($n, 5)); +var_dump(gmp_strval($n)); + +$n = gmp_init("238462734628347239571823641234"); +var_dump(gmp_testbit($n, 5)); +gmp_setbit($n, 5); +var_dump(gmp_testbit($n, 5)); +var_dump(gmp_strval($n)); + +gmp_clrbit($n, 5); +var_dump(gmp_testbit($n, 5)); +var_dump(gmp_strval($n)); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: gmp_testbit(): Index must be greater than or equal to zero in %s on line %d +bool(false) +bool(false) +bool(false) +bool(false) +bool(true) + +Warning: gmp_testbit(): Index must be greater than or equal to zero in %s on line %d +bool(false) +bool(false) +bool(true) +string(7) "1000002" +bool(true) +string(7) "1000034" +bool(false) +bool(true) +string(30) "238462734628347239571823641266" +bool(false) +string(30) "238462734628347239571823641234" +Done diff --git a/ext/gmp/tests/040.phpt b/ext/gmp/tests/040.phpt new file mode 100644 index 0000000..3af18cc --- /dev/null +++ b/ext/gmp/tests/040.phpt @@ -0,0 +1,40 @@ +--TEST-- +gmp_init() basic tests +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +var_dump(gmp_init("98765678")); +var_dump(gmp_strval(gmp_init("98765678"))); +var_dump(gmp_strval(gmp_init())); +var_dump(gmp_init()); +var_dump(gmp_init(1,2,3,4)); +var_dump(gmp_init(1,-1)); +var_dump(gmp_init("",36)); +var_dump(gmp_init("foo",3)); +var_dump(gmp_strval(gmp_init("993247326237679187178",3))); + +echo "Done\n"; +?> +--EXPECTF-- +resource(%d) of type (GMP integer) +string(8) "98765678" + +Warning: gmp_init() expects at least 1 parameter, 0 given in %s on line %d + +Warning: gmp_strval(): Unable to convert variable to GMP - wrong type in %s on line %d +bool(false) + +Warning: gmp_init() expects at least 1 parameter, 0 given in %s on line %d +NULL + +Warning: gmp_init() expects at most 2 parameters, 4 given in %s on line %d +NULL + +Warning: gmp_init(): Bad base for conversion: -1 (should be between 2 and %d) in %s on line %d +bool(false) +bool(false) +bool(false) +string(1) "0" +Done diff --git a/ext/gmp/tests/bug32773.phpt b/ext/gmp/tests/bug32773.phpt new file mode 100644 index 0000000..6823fa1 --- /dev/null +++ b/ext/gmp/tests/bug32773.phpt @@ -0,0 +1,22 @@ +--TEST-- +Bug #32773 (binary GMP functions returns unexpected value, when second parameter is int(0)) +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php +echo '10 + 0 = ', gmp_strval(gmp_add(10, 0)), "\n"; +echo '10 + "0" = ', gmp_strval(gmp_add(10, '0')), "\n"; + +echo gmp_strval(gmp_div(10, 0))."\n"; +echo gmp_strval(gmp_div_qr(10, 0))."\n"; + +?> +--EXPECTF-- +10 + 0 = 10 +10 + "0" = 10 + +Warning: gmp_div(): Zero operand not allowed in %s on line %d +0 + +Warning: gmp_div_qr(): Zero operand not allowed in %s on line %d +0 diff --git a/ext/gmp/tests/bug50283.phpt b/ext/gmp/tests/bug50283.phpt new file mode 100644 index 0000000..13eef54 --- /dev/null +++ b/ext/gmp/tests/bug50283.phpt @@ -0,0 +1,37 @@ +--TEST-- +Feature Request #50283 (allow base in gmp_strval to use full range: 2 to 62, and -2 to -36) +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +<?php if (version_compare(GMP_VERSION, "4.2.0", "<")) print "skip"; ?> +--FILE-- +<?php +$a = gmp_init("0x41682179fbf5"); +printf("Decimal: %s, -36-based: %s\n", gmp_strval($a), gmp_strval($a,-36)); +printf("Decimal: %s, 36-based: %s\n", gmp_strval($a), gmp_strval($a,36)); +printf("Decimal: %s, -1-based: %s\n", gmp_strval($a), gmp_strval($a,-1)); +printf("Decimal: %s, 1-based: %s\n", gmp_strval($a), gmp_strval($a,1)); +printf("Decimal: %s, -37-based: %s\n", gmp_strval($a), gmp_strval($a,-37)); +printf("Decimal: %s, 37-based: %s\n", gmp_strval($a), gmp_strval($a,37)); +printf("Decimal: %s, 62-based: %s\n", gmp_strval($a), gmp_strval($a,62)); +printf("Decimal: %s, 63-based: %s\n\n", gmp_strval($a), gmp_strval($a,63)); +printf("Base 32 and 62-based: %s\n", gmp_strval(gmp_init("gh82179fbf5", 32), 62)); +?> +--EXPECTF-- +Decimal: 71915494046709, -36-based: PHPISCOOL +Decimal: 71915494046709, 36-based: phpiscool + +Warning: gmp_strval(): Bad base for conversion: -1 (should be between 2 and %d or -2 and -%d) in %s on line 5 +Decimal: 71915494046709, -1-based: + +Warning: gmp_strval(): Bad base for conversion: 1 (should be between 2 and %d or -2 and -%d) in %s on line 6 +Decimal: 71915494046709, 1-based: + +Warning: gmp_strval(): Bad base for conversion: -37 (should be between 2 and %d or -2 and -%d) in %s on line 7 +Decimal: 71915494046709, -37-based: +Decimal: 71915494046709, 37-based: KHKATELJF +Decimal: 71915494046709, 62-based: KQ6yq741 + +Warning: gmp_strval(): Bad base for conversion: 63 (should be between 2 and %d or -2 and -%d) in %s on line 10 +Decimal: 71915494046709, 63-based: + +Base 32 and 62-based: 1NHkAcdIiD diff --git a/ext/gmp/tests/bug52906.phpt b/ext/gmp/tests/bug52906.phpt new file mode 100644 index 0000000..60fc741 --- /dev/null +++ b/ext/gmp/tests/bug52906.phpt @@ -0,0 +1,46 @@ +--TEST-- +Bug #52906 gmp_mod returns negative result when non-negative is expected +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; ?> +--FILE-- +<?php + +$vals = array( + array(7, 3), + array(2, 7), + array(12, 7), + array(-2, 7), + array(-12, 7), + array(2, -7), + array(12, -7), + array(-2, -7), + array(-12, -7), +); +foreach($vals as $data) { + echo "{$data[0]}%{$data[1]}=".gmp_strval(gmp_mod($data[0], $data[1])); + echo "\n"; + echo "{$data[0]}%{$data[1]}=".gmp_strval(gmp_mod(gmp_init($data[0]), gmp_init($data[1]))); + echo "\n"; +} +echo "Done\n"; +?> +--EXPECTF-- +7%3=1 +7%3=1 +2%7=2 +2%7=2 +12%7=5 +12%7=5 +-2%7=5 +-2%7=5 +-12%7=2 +-12%7=2 +2%-7=2 +2%-7=2 +12%-7=5 +12%-7=5 +-2%-7=5 +-2%-7=5 +-12%-7=2 +-12%-7=2 +Done diff --git a/ext/gmp/tests/gmp_nextprime.phpt b/ext/gmp/tests/gmp_nextprime.phpt new file mode 100644 index 0000000..5683c8c --- /dev/null +++ b/ext/gmp/tests/gmp_nextprime.phpt @@ -0,0 +1,41 @@ +--TEST-- +gmp_nextprime() +--SKIPIF-- +<?php if (!extension_loaded("gmp")) print "skip"; +?> +--FILE-- +<?php + +$n = gmp_nextprime(-1); +var_dump(gmp_strval($n)); +$n = gmp_nextprime(0); +var_dump(gmp_strval($n)); +$n = gmp_nextprime(-1000); +var_dump(gmp_strval($n)); +$n = gmp_nextprime(1000); +var_dump(gmp_strval($n)); +$n = gmp_nextprime(100000); +var_dump(gmp_strval($n)); +$n = gmp_nextprime(array()); +var_dump(gmp_strval($n)); +$n = gmp_nextprime(""); +var_dump(gmp_strval($n)); +$n = gmp_nextprime(new stdclass()); +var_dump(gmp_strval($n)); + +echo "Done\n"; +?> +--EXPECTF-- +string(1) "2" +string(1) "2" +string(1) "2" +string(4) "1009" +string(6) "100003" + +Warning: gmp_nextprime(): Unable to convert variable to GMP - wrong type in %s on line %d +string(1) "0" +string(1) "0" + +Warning: gmp_nextprime(): Unable to convert variable to GMP - wrong type in %s on line %d +string(1) "0" +Done |