From 348ac51ccf29cebabbc431c8e0e45ad2ffffda96 Mon Sep 17 00:00:00 2001 From: Andrew DalPino Date: Fri, 28 Feb 2020 21:33:56 -0600 Subject: [PATCH] Version bump --- CHANGELOG.md | 2 +- LICENSE.md | 3 +- config.json | 2 +- ext/php_tensor.h | 2 +- ext/tensor/matrix.zep.c | 1377 +++++++++++++++++++-------------------- 5 files changed, 684 insertions(+), 702 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9a7629d..cdef91f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,4 @@ -- Unreleased +- 2.0.4 - Individual Arithmetic and Comparison methods now public - Matrix reductions have their own namespace - Optimized Matrix structural operations diff --git a/LICENSE.md b/LICENSE.md index b69d79c..b3d6aaa 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -1,7 +1,6 @@ MIT License -Copyright (c) 2019 Rubix ML Community -Copyright (c) 2019 Andrew DalPino +Copyright (c) 2020 Andrew DalPino Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/config.json b/config.json index 5c2da83..ae1ab1f 100644 --- a/config.json +++ b/config.json @@ -4,7 +4,7 @@ "extension-name": "tensor", "description": "Tensor is a library and extension that provides objects for scientific computing in PHP.", "author": "Andrew DalPino", - "version": "2.0.3-alpha", + "version": "2.0.4-alpha", "verbose": true, "requires": { "extensions": [] diff --git a/ext/php_tensor.h b/ext/php_tensor.h index 3535166..197c508 100644 --- a/ext/php_tensor.h +++ b/ext/php_tensor.h @@ -11,7 +11,7 @@ #include "kernel/globals.h" #define PHP_TENSOR_NAME "tensor" -#define PHP_TENSOR_VERSION "2.0.3-alpha" +#define PHP_TENSOR_VERSION "2.0.4-alpha" #define PHP_TENSOR_EXTNAME "tensor" #define PHP_TENSOR_AUTHOR "Andrew DalPino" #define PHP_TENSOR_ZEPVERSION "0.12.17-$Id$" diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c index 6c922d2..b8394ed 100644 --- a/ext/tensor/matrix.zep.c +++ b/ext/tensor/matrix.zep.c @@ -7059,13 +7059,13 @@ PHP_METHOD(Tensor_Matrix, negate) { */ PHP_METHOD(Tensor_Matrix, insert) { - zend_string *_19, *_25$$5, *_31$$8; - zend_ulong _18, _24$$5, _30$$8; - zval c, rowC, _14, _21$$5, _27$$8; + zend_string *_19, *_23$$5, *_27$$8; + zend_ulong _18, _22$$5, _26$$8; + zval c, _14; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zephir_fcall_cache_entry *_5 = NULL; zend_long rowOffset, columnOffset, ZEPHIR_LAST_CALL_STATUS, ii = 0, jj = 0; - zval *b, b_sub, *rowOffset_param = NULL, *columnOffset_param = NULL, _0, _1, _7, _8, i, j, rowB, valueB, _13, _15, *_16, _17, _2$$3, _3$$3, _4$$3, _6$$3, _9$$4, _10$$4, _11$$4, _12$$4, _20$$5, *_22$$5, _23$$5, _26$$8, *_28$$8, _29$$8; + zval *b, b_sub, *rowOffset_param = NULL, *columnOffset_param = NULL, _0, _1, _7, _8, i, j, rowB, valueB, _13, _15, *_16, _17, _2$$3, _3$$3, _4$$3, _6$$3, _9$$4, _10$$4, _11$$4, _12$$4, *_20$$5, _21$$5, *_24$$8, _25$$8; zval *this_ptr = getThis(); ZVAL_UNDEF(&b_sub); @@ -7088,15 +7088,10 @@ PHP_METHOD(Tensor_Matrix, insert) { ZVAL_UNDEF(&_10$$4); ZVAL_UNDEF(&_11$$4); ZVAL_UNDEF(&_12$$4); - ZVAL_UNDEF(&_20$$5); - ZVAL_UNDEF(&_23$$5); - ZVAL_UNDEF(&_26$$8); - ZVAL_UNDEF(&_29$$8); + ZVAL_UNDEF(&_21$$5); + ZVAL_UNDEF(&_25$$8); ZVAL_UNDEF(&c); - ZVAL_UNDEF(&rowC); ZVAL_UNDEF(&_14); - ZVAL_UNDEF(&_21$$5); - ZVAL_UNDEF(&_27$$8); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 0, &b, &rowOffset_param, &columnOffset_param); @@ -7141,15 +7136,13 @@ PHP_METHOD(Tensor_Matrix, insert) { } ZEPHIR_INIT_VAR(&c); array_init(&c); - ZEPHIR_INIT_VAR(&rowC); - array_init(&rowC); ZEPHIR_OBS_VAR(&_13); zephir_read_property(&_13, this_ptr, SL("a"), PH_NOISY_CC); zephir_get_arrval(&_14, &_13); ZEPHIR_CPY_WRT(&c, &_14); ZEPHIR_CALL_METHOD(&_15, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_15, 0, "tensor/matrix.zep", 2203); + zephir_is_iterable(&_15, 0, "tensor/matrix.zep", 2198); if (Z_TYPE_P(&_15) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_15), _18, _19, _16) { @@ -7161,48 +7154,43 @@ PHP_METHOD(Tensor_Matrix, insert) { } ZEPHIR_INIT_NVAR(&rowB); ZVAL_COPY(&rowB, _16); - ii = (rowOffset + zephir_get_intval(&i)); - ZEPHIR_OBS_NVAR(&_20$$5); - zephir_array_fetch_long(&_20$$5, &c, ii, PH_NOISY, "tensor/matrix.zep", 2192); - zephir_get_arrval(&_21$$5, &_20$$5); - ZEPHIR_CPY_WRT(&rowC, &_21$$5); - zephir_is_iterable(&rowB, 0, "tensor/matrix.zep", 2200); + ii = (rowOffset + zephir_get_numberval(&i)); + zephir_is_iterable(&rowB, 0, "tensor/matrix.zep", 2196); if (Z_TYPE_P(&rowB) == IS_ARRAY) { - ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowB), _24$$5, _25$$5, _22$$5) + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowB), _22$$5, _23$$5, _20$$5) { ZEPHIR_INIT_NVAR(&j); - if (_25$$5 != NULL) { - ZVAL_STR_COPY(&j, _25$$5); + if (_23$$5 != NULL) { + ZVAL_STR_COPY(&j, _23$$5); } else { - ZVAL_LONG(&j, _24$$5); + ZVAL_LONG(&j, _22$$5); } ZEPHIR_INIT_NVAR(&valueB); - ZVAL_COPY(&valueB, _22$$5); - jj = (columnOffset + zephir_get_intval(&j)); - zephir_array_update_long(&rowC, jj, &valueB, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); + ZVAL_COPY(&valueB, _20$$5); + jj = (columnOffset + zephir_get_numberval(&j)); + zephir_array_update_multi(&c, &valueB, SL("ll"), 2, ii, jj); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0); zephir_check_call_status(); while (1) { - ZEPHIR_CALL_METHOD(&_23$$5, &rowB, "valid", NULL, 0); + ZEPHIR_CALL_METHOD(&_21$$5, &rowB, "valid", NULL, 0); zephir_check_call_status(); - if (!zend_is_true(&_23$$5)) { + if (!zend_is_true(&_21$$5)) { break; } ZEPHIR_CALL_METHOD(&j, &rowB, "key", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0); zephir_check_call_status(); - jj = (columnOffset + zephir_get_intval(&j)); - zephir_array_update_long(&rowC, jj, &valueB, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); + jj = (columnOffset + zephir_get_numberval(&j)); + zephir_array_update_multi(&c, &valueB, SL("ll"), 2, ii, jj); ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_update_long(&c, ii, &rowC, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_15, "rewind", NULL, 0); @@ -7217,48 +7205,43 @@ PHP_METHOD(Tensor_Matrix, insert) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&rowB, &_15, "current", NULL, 0); zephir_check_call_status(); - ii = (rowOffset + zephir_get_intval(&i)); - ZEPHIR_OBS_NVAR(&_26$$8); - zephir_array_fetch_long(&_26$$8, &c, ii, PH_NOISY, "tensor/matrix.zep", 2192); - zephir_get_arrval(&_27$$8, &_26$$8); - ZEPHIR_CPY_WRT(&rowC, &_27$$8); - zephir_is_iterable(&rowB, 0, "tensor/matrix.zep", 2200); + ii = (rowOffset + zephir_get_numberval(&i)); + zephir_is_iterable(&rowB, 0, "tensor/matrix.zep", 2196); if (Z_TYPE_P(&rowB) == IS_ARRAY) { - ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowB), _30$$8, _31$$8, _28$$8) + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowB), _26$$8, _27$$8, _24$$8) { ZEPHIR_INIT_NVAR(&j); - if (_31$$8 != NULL) { - ZVAL_STR_COPY(&j, _31$$8); + if (_27$$8 != NULL) { + ZVAL_STR_COPY(&j, _27$$8); } else { - ZVAL_LONG(&j, _30$$8); + ZVAL_LONG(&j, _26$$8); } ZEPHIR_INIT_NVAR(&valueB); - ZVAL_COPY(&valueB, _28$$8); - jj = (columnOffset + zephir_get_intval(&j)); - zephir_array_update_long(&rowC, jj, &valueB, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); + ZVAL_COPY(&valueB, _24$$8); + jj = (columnOffset + zephir_get_numberval(&j)); + zephir_array_update_multi(&c, &valueB, SL("ll"), 2, ii, jj); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0); zephir_check_call_status(); while (1) { - ZEPHIR_CALL_METHOD(&_29$$8, &rowB, "valid", NULL, 0); + ZEPHIR_CALL_METHOD(&_25$$8, &rowB, "valid", NULL, 0); zephir_check_call_status(); - if (!zend_is_true(&_29$$8)) { + if (!zend_is_true(&_25$$8)) { break; } ZEPHIR_CALL_METHOD(&j, &rowB, "key", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0); zephir_check_call_status(); - jj = (columnOffset + zephir_get_intval(&j)); - zephir_array_update_long(&rowC, jj, &valueB, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); + jj = (columnOffset + zephir_get_numberval(&j)); + zephir_array_update_multi(&c, &valueB, SL("ll"), 2, ii, jj); ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_update_long(&c, ii, &rowC, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); ZEPHIR_CALL_METHOD(NULL, &_15, "next", NULL, 0); zephir_check_call_status(); } @@ -7335,7 +7318,7 @@ PHP_METHOD(Tensor_Matrix, subMatrix) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Start row must be", " greater than 0, ", &_2$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 2224); + zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 2219); ZEPHIR_MM_RESTORE(); return; } @@ -7349,7 +7332,7 @@ PHP_METHOD(Tensor_Matrix, subMatrix) { ZEPHIR_CONCAT_SSVS(&_8$$4, "Start column must be", " greater than 0, ", &_7$$4, " given."); ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_8$$4); zephir_check_call_status(); - zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 2229); + zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 2224); ZEPHIR_MM_RESTORE(); return; } @@ -7360,7 +7343,7 @@ PHP_METHOD(Tensor_Matrix, subMatrix) { ZEPHIR_CONCAT_SS(&_10$$5, "End row must be", " greater than start row."); ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 3, &_10$$5); zephir_check_call_status(); - zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 2234); + zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 2229); ZEPHIR_MM_RESTORE(); return; } @@ -7371,7 +7354,7 @@ PHP_METHOD(Tensor_Matrix, subMatrix) { ZEPHIR_CONCAT_SS(&_12$$6, "End column must be", " greater than start column."); ZEPHIR_CALL_METHOD(NULL, &_11$$6, "__construct", NULL, 3, &_12$$6); zephir_check_call_status(); - zephir_throw_exception_debug(&_11$$6, "tensor/matrix.zep", 2239); + zephir_throw_exception_debug(&_11$$6, "tensor/matrix.zep", 2234); ZEPHIR_MM_RESTORE(); return; } @@ -7383,7 +7366,7 @@ PHP_METHOD(Tensor_Matrix, subMatrix) { ZEPHIR_CONCAT_SS(&_15$$7, "End row is out", " of bounds of matrix."); ZEPHIR_CALL_METHOD(NULL, &_14$$7, "__construct", NULL, 3, &_15$$7); zephir_check_call_status(); - zephir_throw_exception_debug(&_14$$7, "tensor/matrix.zep", 2244); + zephir_throw_exception_debug(&_14$$7, "tensor/matrix.zep", 2239); ZEPHIR_MM_RESTORE(); return; } @@ -7395,7 +7378,7 @@ PHP_METHOD(Tensor_Matrix, subMatrix) { ZEPHIR_CONCAT_SS(&_18$$8, "End column is out", " of bounds of matrix."); ZEPHIR_CALL_METHOD(NULL, &_17$$8, "__construct", NULL, 3, &_18$$8); zephir_check_call_status(); - zephir_throw_exception_debug(&_17$$8, "tensor/matrix.zep", 2249); + zephir_throw_exception_debug(&_17$$8, "tensor/matrix.zep", 2244); ZEPHIR_MM_RESTORE(); return; } @@ -7421,7 +7404,7 @@ PHP_METHOD(Tensor_Matrix, subMatrix) { i = _20; zephir_read_property(&_22$$9, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch_long(&rowA, &_22$$9, i, PH_NOISY, "tensor/matrix.zep", 2261); + zephir_array_fetch_long(&rowA, &_22$$9, i, PH_NOISY, "tensor/matrix.zep", 2256); ZEPHIR_INIT_NVAR(&rowB); array_init(&rowB); _25$$9 = l; @@ -7438,11 +7421,11 @@ PHP_METHOD(Tensor_Matrix, subMatrix) { _23$$9 = 1; } j = _24$$9; - zephir_array_fetch_long(&_26$$10, &rowA, j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2266); - zephir_array_append(&rowB, &_26$$10, PH_SEPARATE, "tensor/matrix.zep", 2266); + zephir_array_fetch_long(&_26$$10, &rowA, j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2261); + zephir_array_append(&rowB, &_26$$10, PH_SEPARATE, "tensor/matrix.zep", 2261); } } - zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2269); + zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2264); } } ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b); @@ -7507,7 +7490,7 @@ PHP_METHOD(Tensor_Matrix, augmentAbove) { ZEPHIR_CONCAT_SVSVS(&_9$$3, "Matrix A requires", &_6$$3, " columns but Matrix B has ", &_8$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 3, &_9$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2287); + zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2282); ZEPHIR_MM_RESTORE(); return; } @@ -7578,7 +7561,7 @@ PHP_METHOD(Tensor_Matrix, augmentBelow) { ZEPHIR_CONCAT_SVSVS(&_9$$3, "Matrix A requires", &_6$$3, " columns but Matrix B has ", &_8$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 3, &_9$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2305); + zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2300); ZEPHIR_MM_RESTORE(); return; } @@ -7650,7 +7633,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft) { ZEPHIR_CONCAT_SVSVS(&_9$$3, "Matrix A requires", &_6$$3, " rows but Matrix B has ", &_8$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 3, &_9$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2323); + zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2318); ZEPHIR_MM_RESTORE(); return; } @@ -7724,7 +7707,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight) { ZEPHIR_CONCAT_SVSVS(&_9$$3, "Matrix A requires", &_6$$3, " rows but Matrix B has ", &_8$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 3, &_9$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2341); + zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2336); ZEPHIR_MM_RESTORE(); return; } @@ -7783,7 +7766,7 @@ PHP_METHOD(Tensor_Matrix, repeat) { array_init(&temp); if (n > 0) { zephir_read_property(&_0$$3, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_0$$3, 0, "tensor/matrix.zep", 2372); + zephir_is_iterable(&_0$$3, 0, "tensor/matrix.zep", 2367); if (Z_TYPE_P(&_0$$3) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0$$3), _1$$3) { @@ -7795,14 +7778,14 @@ PHP_METHOD(Tensor_Matrix, repeat) { if (!(zephir_fast_count_int(&temp) <= n)) { break; } - zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2367); + zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2362); } ZEPHIR_INIT_NVAR(&_3$$4); ZEPHIR_INIT_NVAR(&_4$$4); ZVAL_STRING(&_4$$4, "array_merge"); ZEPHIR_CALL_USER_FUNC_ARRAY(&_3$$4, &_4$$4, &temp); zephir_check_call_status(); - zephir_array_append(&b, &_3$$4, PH_SEPARATE, "tensor/matrix.zep", 2370); + zephir_array_append(&b, &_3$$4, PH_SEPARATE, "tensor/matrix.zep", 2365); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_0$$3, "rewind", NULL, 0); @@ -7821,14 +7804,14 @@ PHP_METHOD(Tensor_Matrix, repeat) { if (!(zephir_fast_count_int(&temp) <= n)) { break; } - zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2367); + zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2362); } ZEPHIR_INIT_NVAR(&_5$$6); ZEPHIR_INIT_NVAR(&_6$$6); ZVAL_STRING(&_6$$6, "array_merge"); ZEPHIR_CALL_USER_FUNC_ARRAY(&_5$$6, &_6$$6, &temp); zephir_check_call_status(); - zephir_array_append(&b, &_5$$6, PH_SEPARATE, "tensor/matrix.zep", 2370); + zephir_array_append(&b, &_5$$6, PH_SEPARATE, "tensor/matrix.zep", 2365); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "next", NULL, 0); zephir_check_call_status(); } @@ -7841,7 +7824,7 @@ PHP_METHOD(Tensor_Matrix, repeat) { if (!(zephir_fast_count_int(&temp) <= m)) { break; } - zephir_array_append(&temp, &b, PH_SEPARATE, "tensor/matrix.zep", 2377); + zephir_array_append(&temp, &b, PH_SEPARATE, "tensor/matrix.zep", 2372); } ZEPHIR_INIT_VAR(&_7); ZEPHIR_INIT_VAR(&_8); @@ -7920,7 +7903,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2394); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2389); ZEPHIR_MM_RESTORE(); return; } @@ -7930,7 +7913,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2413); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2408); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -7944,10 +7927,10 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2402); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2397); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2410); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2405); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -7959,10 +7942,10 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); - zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2407); + zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2402); ZEPHIR_INIT_NVAR(&_17$$5); mul_function(&_17$$5, &valueA, &_16$$5); - zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2407); + zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2402); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -7977,17 +7960,17 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2407); + zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2402); ZEPHIR_INIT_NVAR(&_19$$6); mul_function(&_19$$6, &valueA, &_18$$6); - zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2407); + zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2402); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2410); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2405); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -8004,10 +7987,10 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2402); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2397); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2410); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2405); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -8019,10 +8002,10 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); - zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2407); + zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2402); ZEPHIR_INIT_NVAR(&_26$$8); mul_function(&_26$$8, &valueA, &_25$$8); - zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2407); + zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2402); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -8037,17 +8020,17 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2407); + zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2402); ZEPHIR_INIT_NVAR(&_28$$9); mul_function(&_28$$9, &valueA, &_27$$9); - zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2407); + zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2402); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2410); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2405); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -8126,7 +8109,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2427); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2422); ZEPHIR_MM_RESTORE(); return; } @@ -8136,7 +8119,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2446); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2441); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -8150,10 +8133,10 @@ PHP_METHOD(Tensor_Matrix, divideMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2435); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2430); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2443); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2438); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -8165,10 +8148,10 @@ PHP_METHOD(Tensor_Matrix, divideMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); - zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2440); + zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2435); ZEPHIR_INIT_NVAR(&_17$$5); div_function(&_17$$5, &valueA, &_16$$5); - zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2440); + zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2435); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -8183,17 +8166,17 @@ PHP_METHOD(Tensor_Matrix, divideMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2440); + zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2435); ZEPHIR_INIT_NVAR(&_19$$6); div_function(&_19$$6, &valueA, &_18$$6); - zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2440); + zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2435); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2443); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2438); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -8210,10 +8193,10 @@ PHP_METHOD(Tensor_Matrix, divideMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2435); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2430); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2443); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2438); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -8225,10 +8208,10 @@ PHP_METHOD(Tensor_Matrix, divideMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); - zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2440); + zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2435); ZEPHIR_INIT_NVAR(&_26$$8); div_function(&_26$$8, &valueA, &_25$$8); - zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2440); + zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2435); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -8243,17 +8226,17 @@ PHP_METHOD(Tensor_Matrix, divideMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2440); + zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2435); ZEPHIR_INIT_NVAR(&_28$$9); div_function(&_28$$9, &valueA, &_27$$9); - zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2440); + zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2435); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2443); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2438); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -8332,7 +8315,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2460); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2455); ZEPHIR_MM_RESTORE(); return; } @@ -8342,7 +8325,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2479); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2474); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -8356,10 +8339,10 @@ PHP_METHOD(Tensor_Matrix, addMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2468); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2463); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2476); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2471); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -8371,10 +8354,10 @@ PHP_METHOD(Tensor_Matrix, addMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); - zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2473); + zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2468); ZEPHIR_INIT_NVAR(&_17$$5); zephir_add_function(&_17$$5, &valueA, &_16$$5); - zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2473); + zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2468); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -8389,17 +8372,17 @@ PHP_METHOD(Tensor_Matrix, addMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2473); + zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2468); ZEPHIR_INIT_NVAR(&_19$$6); zephir_add_function(&_19$$6, &valueA, &_18$$6); - zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2473); + zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2468); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2476); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2471); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -8416,10 +8399,10 @@ PHP_METHOD(Tensor_Matrix, addMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2468); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2463); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2476); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2471); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -8431,10 +8414,10 @@ PHP_METHOD(Tensor_Matrix, addMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); - zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2473); + zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2468); ZEPHIR_INIT_NVAR(&_26$$8); zephir_add_function(&_26$$8, &valueA, &_25$$8); - zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2473); + zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2468); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -8449,17 +8432,17 @@ PHP_METHOD(Tensor_Matrix, addMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2473); + zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2468); ZEPHIR_INIT_NVAR(&_28$$9); zephir_add_function(&_28$$9, &valueA, &_27$$9); - zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2473); + zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2468); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2476); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2471); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -8538,7 +8521,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2493); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2488); ZEPHIR_MM_RESTORE(); return; } @@ -8548,7 +8531,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2512); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2507); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -8562,10 +8545,10 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2501); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2496); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2509); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2504); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -8577,10 +8560,10 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); - zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2506); + zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2501); ZEPHIR_INIT_NVAR(&_17$$5); zephir_sub_function(&_17$$5, &valueA, &_16$$5); - zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2506); + zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2501); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -8595,17 +8578,17 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2506); + zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2501); ZEPHIR_INIT_NVAR(&_19$$6); zephir_sub_function(&_19$$6, &valueA, &_18$$6); - zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2506); + zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2501); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2509); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2504); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -8622,10 +8605,10 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2501); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2496); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2509); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2504); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -8637,10 +8620,10 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); - zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2506); + zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2501); ZEPHIR_INIT_NVAR(&_26$$8); zephir_sub_function(&_26$$8, &valueA, &_25$$8); - zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2506); + zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2501); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -8655,17 +8638,17 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2506); + zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2501); ZEPHIR_INIT_NVAR(&_28$$9); zephir_sub_function(&_28$$9, &valueA, &_27$$9); - zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2506); + zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2501); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2509); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2504); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -8745,7 +8728,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2527); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2522); ZEPHIR_MM_RESTORE(); return; } @@ -8755,7 +8738,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2546); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2541); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -8769,10 +8752,10 @@ PHP_METHOD(Tensor_Matrix, powMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2535); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2530); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2543); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2538); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -8785,9 +8768,9 @@ PHP_METHOD(Tensor_Matrix, powMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); ZEPHIR_INIT_NVAR(&_16$$5); - zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2540); + zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2535); zephir_pow_function(&_16$$5, &valueA, &_17$$5); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2540); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2535); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -8803,16 +8786,16 @@ PHP_METHOD(Tensor_Matrix, powMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_18$$6); - zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2540); + zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2535); zephir_pow_function(&_18$$6, &valueA, &_19$$6); - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2540); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2535); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2543); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2538); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -8829,10 +8812,10 @@ PHP_METHOD(Tensor_Matrix, powMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2535); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2530); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2543); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2538); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -8845,9 +8828,9 @@ PHP_METHOD(Tensor_Matrix, powMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); ZEPHIR_INIT_NVAR(&_25$$8); - zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2540); + zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2535); zephir_pow_function(&_25$$8, &valueA, &_26$$8); - zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2540); + zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2535); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -8863,16 +8846,16 @@ PHP_METHOD(Tensor_Matrix, powMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_27$$9); - zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2540); + zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2535); zephir_pow_function(&_27$$9, &valueA, &_28$$9); - zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2540); + zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2535); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2543); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2538); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -8952,7 +8935,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2561); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2556); ZEPHIR_MM_RESTORE(); return; } @@ -8962,7 +8945,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2580); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2575); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -8976,10 +8959,10 @@ PHP_METHOD(Tensor_Matrix, modMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2569); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2564); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2577); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2572); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -8991,10 +8974,10 @@ PHP_METHOD(Tensor_Matrix, modMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); - zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2574); + zephir_array_fetch(&_16$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2569); ZEPHIR_INIT_NVAR(&_17$$5); mod_function(&_17$$5, &valueA, &_16$$5); - zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2574); + zephir_array_append(&rowC, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2569); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9009,17 +8992,17 @@ PHP_METHOD(Tensor_Matrix, modMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2574); + zephir_array_fetch(&_18$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2569); ZEPHIR_INIT_NVAR(&_19$$6); mod_function(&_19$$6, &valueA, &_18$$6); - zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2574); + zephir_array_append(&rowC, &_19$$6, PH_SEPARATE, "tensor/matrix.zep", 2569); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2577); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2572); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -9036,10 +9019,10 @@ PHP_METHOD(Tensor_Matrix, modMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2569); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2564); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2577); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2572); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -9051,10 +9034,10 @@ PHP_METHOD(Tensor_Matrix, modMatrix) { } ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); - zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2574); + zephir_array_fetch(&_25$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2569); ZEPHIR_INIT_NVAR(&_26$$8); mod_function(&_26$$8, &valueA, &_25$$8); - zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2574); + zephir_array_append(&rowC, &_26$$8, PH_SEPARATE, "tensor/matrix.zep", 2569); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9069,17 +9052,17 @@ PHP_METHOD(Tensor_Matrix, modMatrix) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2574); + zephir_array_fetch(&_27$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2569); ZEPHIR_INIT_NVAR(&_28$$9); mod_function(&_28$$9, &valueA, &_27$$9); - zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2574); + zephir_array_append(&rowC, &_28$$9, PH_SEPARATE, "tensor/matrix.zep", 2569); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2577); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2572); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -9159,7 +9142,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2595); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2590); ZEPHIR_MM_RESTORE(); return; } @@ -9169,7 +9152,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2614); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2609); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -9183,10 +9166,10 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2603); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2598); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2611); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2606); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -9199,7 +9182,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); ZEPHIR_INIT_NVAR(&_16$$5); - zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2608); + zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2603); if (ZEPHIR_IS_EQUAL(&valueA, &_17$$5)) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 1); @@ -9207,7 +9190,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2608); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2603); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9223,7 +9206,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_18$$6); - zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2608); + zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2603); if (ZEPHIR_IS_EQUAL(&valueA, &_19$$6)) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 1); @@ -9231,14 +9214,14 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 0); } - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2608); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2603); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2611); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2606); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -9255,10 +9238,10 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2603); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2598); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2611); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2606); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -9271,7 +9254,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); ZEPHIR_INIT_NVAR(&_25$$8); - zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2608); + zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2603); if (ZEPHIR_IS_EQUAL(&valueA, &_26$$8)) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 1); @@ -9279,7 +9262,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 0); } - zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2608); + zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2603); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9295,7 +9278,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_27$$9); - zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2608); + zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2603); if (ZEPHIR_IS_EQUAL(&valueA, &_28$$9)) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 1); @@ -9303,14 +9286,14 @@ PHP_METHOD(Tensor_Matrix, equalMatrix) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 0); } - zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2608); + zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2603); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2611); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2606); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -9390,7 +9373,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2629); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2624); ZEPHIR_MM_RESTORE(); return; } @@ -9400,7 +9383,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2648); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2643); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -9414,10 +9397,10 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2637); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2632); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2645); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2640); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -9430,7 +9413,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); ZEPHIR_INIT_NVAR(&_16$$5); - zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2642); + zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2637); if (!ZEPHIR_IS_EQUAL(&valueA, &_17$$5)) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 1); @@ -9438,7 +9421,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2642); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2637); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9454,7 +9437,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_18$$6); - zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2642); + zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2637); if (!ZEPHIR_IS_EQUAL(&valueA, &_19$$6)) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 1); @@ -9462,14 +9445,14 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 0); } - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2642); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2637); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2645); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2640); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -9486,10 +9469,10 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2637); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2632); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2645); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2640); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -9502,7 +9485,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); ZEPHIR_INIT_NVAR(&_25$$8); - zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2642); + zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2637); if (!ZEPHIR_IS_EQUAL(&valueA, &_26$$8)) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 1); @@ -9510,7 +9493,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 0); } - zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2642); + zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2637); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9526,7 +9509,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_27$$9); - zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2642); + zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2637); if (!ZEPHIR_IS_EQUAL(&valueA, &_28$$9)) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 1); @@ -9534,14 +9517,14 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 0); } - zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2642); + zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2637); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2645); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2640); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -9621,7 +9604,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2663); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2658); ZEPHIR_MM_RESTORE(); return; } @@ -9631,7 +9614,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2682); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2677); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -9645,10 +9628,10 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2671); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2666); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2679); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2674); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -9661,7 +9644,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); ZEPHIR_INIT_NVAR(&_16$$5); - zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2676); + zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2671); if (ZEPHIR_GT(&valueA, &_17$$5)) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 1); @@ -9669,7 +9652,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2676); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2671); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9685,7 +9668,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_18$$6); - zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2676); + zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2671); if (ZEPHIR_GT(&valueA, &_19$$6)) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 1); @@ -9693,14 +9676,14 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 0); } - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2676); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2671); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2679); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2674); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -9717,10 +9700,10 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2671); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2666); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2679); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2674); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -9733,7 +9716,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); ZEPHIR_INIT_NVAR(&_25$$8); - zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2676); + zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2671); if (ZEPHIR_GT(&valueA, &_26$$8)) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 1); @@ -9741,7 +9724,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 0); } - zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2676); + zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2671); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9757,7 +9740,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_27$$9); - zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2676); + zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2671); if (ZEPHIR_GT(&valueA, &_28$$9)) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 1); @@ -9765,14 +9748,14 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 0); } - zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2676); + zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2671); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2679); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2674); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -9852,7 +9835,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2697); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2692); ZEPHIR_MM_RESTORE(); return; } @@ -9862,7 +9845,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2716); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2711); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -9876,10 +9859,10 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2705); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2700); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2713); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2708); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -9892,7 +9875,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); ZEPHIR_INIT_NVAR(&_16$$5); - zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2710); + zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2705); if (ZEPHIR_GE(&valueA, &_17$$5)) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 1); @@ -9900,7 +9883,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2710); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2705); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9916,7 +9899,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_18$$6); - zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2710); + zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2705); if (ZEPHIR_GE(&valueA, &_19$$6)) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 1); @@ -9924,14 +9907,14 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 0); } - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2710); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2705); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2713); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2708); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -9948,10 +9931,10 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2705); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2700); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2713); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2708); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -9964,7 +9947,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); ZEPHIR_INIT_NVAR(&_25$$8); - zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2710); + zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2705); if (ZEPHIR_GE(&valueA, &_26$$8)) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 1); @@ -9972,7 +9955,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 0); } - zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2710); + zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2705); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -9988,7 +9971,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_27$$9); - zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2710); + zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2705); if (ZEPHIR_GE(&valueA, &_28$$9)) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 1); @@ -9996,14 +9979,14 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 0); } - zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2710); + zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2705); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2713); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2708); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -10083,7 +10066,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2731); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2726); ZEPHIR_MM_RESTORE(); return; } @@ -10093,7 +10076,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2750); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2745); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -10107,10 +10090,10 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2739); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2734); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2747); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2742); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -10123,7 +10106,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); ZEPHIR_INIT_NVAR(&_16$$5); - zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2744); + zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2739); if (ZEPHIR_LT(&valueA, &_17$$5)) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 1); @@ -10131,7 +10114,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2744); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2739); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -10147,7 +10130,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_18$$6); - zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2744); + zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2739); if (ZEPHIR_LT(&valueA, &_19$$6)) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 1); @@ -10155,14 +10138,14 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 0); } - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2744); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2739); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2747); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2742); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -10179,10 +10162,10 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2739); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2734); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2747); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2742); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -10195,7 +10178,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); ZEPHIR_INIT_NVAR(&_25$$8); - zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2744); + zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2739); if (ZEPHIR_LT(&valueA, &_26$$8)) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 1); @@ -10203,7 +10186,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 0); } - zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2744); + zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2739); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -10219,7 +10202,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_27$$9); - zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2744); + zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2739); if (ZEPHIR_LT(&valueA, &_28$$9)) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 1); @@ -10227,14 +10210,14 @@ PHP_METHOD(Tensor_Matrix, lessMatrix) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 0); } - zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2744); + zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2739); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2747); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2742); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -10314,7 +10297,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix needed but ", &_4$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2765); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2760); ZEPHIR_MM_RESTORE(); return; } @@ -10324,7 +10307,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2784); + zephir_is_iterable(&_6, 0, "tensor/matrix.zep", 2779); if (Z_TYPE_P(&_6) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_6), _9, _10, _7) { @@ -10338,10 +10321,10 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZVAL_COPY(&rowB, _7); zephir_read_property(&_11$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2773); + zephir_array_fetch(&rowA, &_11$$4, &i, PH_NOISY, "tensor/matrix.zep", 2768); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2781); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2776); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _14$$4, _15$$4, _12$$4) { @@ -10354,7 +10337,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _12$$4); ZEPHIR_INIT_NVAR(&_16$$5); - zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2778); + zephir_array_fetch(&_17$$5, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2773); if (ZEPHIR_LE(&valueA, &_17$$5)) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 1); @@ -10362,7 +10345,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2778); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2773); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -10378,7 +10361,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_18$$6); - zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2778); + zephir_array_fetch(&_19$$6, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2773); if (ZEPHIR_LE(&valueA, &_19$$6)) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 1); @@ -10386,14 +10369,14 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZEPHIR_INIT_NVAR(&_18$$6); ZVAL_LONG(&_18$$6, 0); } - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2778); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2773); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2781); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2776); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_6, "rewind", NULL, 0); @@ -10410,10 +10393,10 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { zephir_check_call_status(); zephir_read_property(&_20$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2773); + zephir_array_fetch(&rowA, &_20$$7, &i, PH_NOISY, "tensor/matrix.zep", 2768); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2781); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 2776); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&rowA), _23$$7, _24$$7, _21$$7) { @@ -10426,7 +10409,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZEPHIR_INIT_NVAR(&valueA); ZVAL_COPY(&valueA, _21$$7); ZEPHIR_INIT_NVAR(&_25$$8); - zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2778); + zephir_array_fetch(&_26$$8, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2773); if (ZEPHIR_LE(&valueA, &_26$$8)) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 1); @@ -10434,7 +10417,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZEPHIR_INIT_NVAR(&_25$$8); ZVAL_LONG(&_25$$8, 0); } - zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2778); + zephir_array_append(&rowC, &_25$$8, PH_SEPARATE, "tensor/matrix.zep", 2773); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -10450,7 +10433,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZEPHIR_CALL_METHOD(&valueA, &rowA, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_27$$9); - zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2778); + zephir_array_fetch(&_28$$9, &rowB, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2773); if (ZEPHIR_LE(&valueA, &_28$$9)) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 1); @@ -10458,14 +10441,14 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix) { ZEPHIR_INIT_NVAR(&_27$$9); ZVAL_LONG(&_27$$9, 0); } - zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2778); + zephir_array_append(&rowC, &_27$$9, PH_SEPARATE, "tensor/matrix.zep", 2773); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2781); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2776); ZEPHIR_CALL_METHOD(NULL, &_6, "next", NULL, 0); zephir_check_call_status(); } @@ -10545,7 +10528,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2799); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2794); ZEPHIR_MM_RESTORE(); return; } @@ -10556,7 +10539,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2818); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2813); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -10564,7 +10547,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2815); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2810); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -10576,10 +10559,10 @@ PHP_METHOD(Tensor_Matrix, multiplyVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); - zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2812); + zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2807); ZEPHIR_INIT_NVAR(&_16$$5); mul_function(&_16$$5, &_15$$5, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2812); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2807); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -10594,17 +10577,17 @@ PHP_METHOD(Tensor_Matrix, multiplyVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2812); + zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2807); ZEPHIR_INIT_NVAR(&_18$$6); mul_function(&_18$$6, &_17$$6, &valueB); - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2812); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2807); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2815); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2810); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -10619,7 +10602,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2815); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2810); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -10631,10 +10614,10 @@ PHP_METHOD(Tensor_Matrix, multiplyVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); - zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2812); + zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2807); ZEPHIR_INIT_NVAR(&_24$$8); mul_function(&_24$$8, &_23$$8, &valueB); - zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2812); + zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2807); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -10649,17 +10632,17 @@ PHP_METHOD(Tensor_Matrix, multiplyVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2812); + zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2807); ZEPHIR_INIT_NVAR(&_26$$9); mul_function(&_26$$9, &_25$$9, &valueB); - zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2812); + zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2807); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2815); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2810); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -10738,7 +10721,7 @@ PHP_METHOD(Tensor_Matrix, divideVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2833); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2828); ZEPHIR_MM_RESTORE(); return; } @@ -10749,7 +10732,7 @@ PHP_METHOD(Tensor_Matrix, divideVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2852); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2847); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -10757,7 +10740,7 @@ PHP_METHOD(Tensor_Matrix, divideVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2849); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2844); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -10769,10 +10752,10 @@ PHP_METHOD(Tensor_Matrix, divideVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); - zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2846); + zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2841); ZEPHIR_INIT_NVAR(&_16$$5); div_function(&_16$$5, &_15$$5, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2846); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2841); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -10787,17 +10770,17 @@ PHP_METHOD(Tensor_Matrix, divideVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2846); + zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2841); ZEPHIR_INIT_NVAR(&_18$$6); div_function(&_18$$6, &_17$$6, &valueB); - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2846); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2841); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2849); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2844); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -10812,7 +10795,7 @@ PHP_METHOD(Tensor_Matrix, divideVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2849); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2844); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -10824,10 +10807,10 @@ PHP_METHOD(Tensor_Matrix, divideVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); - zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2846); + zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2841); ZEPHIR_INIT_NVAR(&_24$$8); div_function(&_24$$8, &_23$$8, &valueB); - zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2846); + zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2841); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -10842,17 +10825,17 @@ PHP_METHOD(Tensor_Matrix, divideVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2846); + zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2841); ZEPHIR_INIT_NVAR(&_26$$9); div_function(&_26$$9, &_25$$9, &valueB); - zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2846); + zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2841); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2849); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2844); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -10931,7 +10914,7 @@ PHP_METHOD(Tensor_Matrix, addVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2867); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2862); ZEPHIR_MM_RESTORE(); return; } @@ -10942,7 +10925,7 @@ PHP_METHOD(Tensor_Matrix, addVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2886); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2881); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -10950,7 +10933,7 @@ PHP_METHOD(Tensor_Matrix, addVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2883); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2878); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -10962,10 +10945,10 @@ PHP_METHOD(Tensor_Matrix, addVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); - zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2880); + zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2875); ZEPHIR_INIT_NVAR(&_16$$5); zephir_add_function(&_16$$5, &_15$$5, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2880); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2875); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -10980,17 +10963,17 @@ PHP_METHOD(Tensor_Matrix, addVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2880); + zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2875); ZEPHIR_INIT_NVAR(&_18$$6); zephir_add_function(&_18$$6, &_17$$6, &valueB); - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2880); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2875); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2883); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2878); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -11005,7 +10988,7 @@ PHP_METHOD(Tensor_Matrix, addVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2883); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2878); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -11017,10 +11000,10 @@ PHP_METHOD(Tensor_Matrix, addVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); - zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2880); + zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2875); ZEPHIR_INIT_NVAR(&_24$$8); zephir_add_function(&_24$$8, &_23$$8, &valueB); - zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2880); + zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2875); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11035,17 +11018,17 @@ PHP_METHOD(Tensor_Matrix, addVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2880); + zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2875); ZEPHIR_INIT_NVAR(&_26$$9); zephir_add_function(&_26$$9, &_25$$9, &valueB); - zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2880); + zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2875); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2883); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2878); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -11124,7 +11107,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2901); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2896); ZEPHIR_MM_RESTORE(); return; } @@ -11135,7 +11118,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2920); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2915); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -11143,7 +11126,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2917); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2912); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -11155,10 +11138,10 @@ PHP_METHOD(Tensor_Matrix, subtractVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); - zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2914); + zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2909); ZEPHIR_INIT_NVAR(&_16$$5); zephir_sub_function(&_16$$5, &_15$$5, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2914); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2909); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11173,17 +11156,17 @@ PHP_METHOD(Tensor_Matrix, subtractVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2914); + zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2909); ZEPHIR_INIT_NVAR(&_18$$6); zephir_sub_function(&_18$$6, &_17$$6, &valueB); - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2914); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2909); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2917); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2912); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -11198,7 +11181,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2917); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2912); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -11210,10 +11193,10 @@ PHP_METHOD(Tensor_Matrix, subtractVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); - zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2914); + zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2909); ZEPHIR_INIT_NVAR(&_24$$8); zephir_sub_function(&_24$$8, &_23$$8, &valueB); - zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2914); + zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2909); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11228,17 +11211,17 @@ PHP_METHOD(Tensor_Matrix, subtractVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2914); + zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2909); ZEPHIR_INIT_NVAR(&_26$$9); zephir_sub_function(&_26$$9, &_25$$9, &valueB); - zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2914); + zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2909); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2917); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2912); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -11317,7 +11300,7 @@ PHP_METHOD(Tensor_Matrix, powVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2935); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2930); ZEPHIR_MM_RESTORE(); return; } @@ -11328,7 +11311,7 @@ PHP_METHOD(Tensor_Matrix, powVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2954); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2949); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -11336,7 +11319,7 @@ PHP_METHOD(Tensor_Matrix, powVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2951); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2946); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -11349,9 +11332,9 @@ PHP_METHOD(Tensor_Matrix, powVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); ZEPHIR_INIT_NVAR(&_15$$5); - zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2948); + zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2943); zephir_pow_function(&_15$$5, &_16$$5, &valueB); - zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2948); + zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2943); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11367,16 +11350,16 @@ PHP_METHOD(Tensor_Matrix, powVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); - zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2948); + zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2943); zephir_pow_function(&_17$$6, &_18$$6, &valueB); - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 2948); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 2943); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2951); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2946); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -11391,7 +11374,7 @@ PHP_METHOD(Tensor_Matrix, powVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2951); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2946); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -11404,9 +11387,9 @@ PHP_METHOD(Tensor_Matrix, powVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); ZEPHIR_INIT_NVAR(&_23$$8); - zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2948); + zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2943); zephir_pow_function(&_23$$8, &_24$$8, &valueB); - zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 2948); + zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 2943); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11422,16 +11405,16 @@ PHP_METHOD(Tensor_Matrix, powVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_25$$9); - zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2948); + zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2943); zephir_pow_function(&_25$$9, &_26$$9, &valueB); - zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 2948); + zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 2943); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2951); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2946); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -11510,7 +11493,7 @@ PHP_METHOD(Tensor_Matrix, modVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2969); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2964); ZEPHIR_MM_RESTORE(); return; } @@ -11521,7 +11504,7 @@ PHP_METHOD(Tensor_Matrix, modVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2988); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 2983); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -11529,7 +11512,7 @@ PHP_METHOD(Tensor_Matrix, modVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2985); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2980); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -11541,10 +11524,10 @@ PHP_METHOD(Tensor_Matrix, modVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); - zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2982); + zephir_array_fetch(&_15$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2977); ZEPHIR_INIT_NVAR(&_16$$5); mod_function(&_16$$5, &_15$$5, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2982); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 2977); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11559,17 +11542,17 @@ PHP_METHOD(Tensor_Matrix, modVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2982); + zephir_array_fetch(&_17$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2977); ZEPHIR_INIT_NVAR(&_18$$6); mod_function(&_18$$6, &_17$$6, &valueB); - zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2982); + zephir_array_append(&rowC, &_18$$6, PH_SEPARATE, "tensor/matrix.zep", 2977); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2985); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2980); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -11584,7 +11567,7 @@ PHP_METHOD(Tensor_Matrix, modVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2985); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 2980); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -11596,10 +11579,10 @@ PHP_METHOD(Tensor_Matrix, modVector) { } ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); - zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2982); + zephir_array_fetch(&_23$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2977); ZEPHIR_INIT_NVAR(&_24$$8); mod_function(&_24$$8, &_23$$8, &valueB); - zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2982); + zephir_array_append(&rowC, &_24$$8, PH_SEPARATE, "tensor/matrix.zep", 2977); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11614,17 +11597,17 @@ PHP_METHOD(Tensor_Matrix, modVector) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); - zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2982); + zephir_array_fetch(&_25$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 2977); ZEPHIR_INIT_NVAR(&_26$$9); mod_function(&_26$$9, &_25$$9, &valueB); - zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2982); + zephir_array_append(&rowC, &_26$$9, PH_SEPARATE, "tensor/matrix.zep", 2977); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2985); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 2980); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -11704,7 +11687,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3004); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2999); ZEPHIR_MM_RESTORE(); return; } @@ -11715,7 +11698,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3023); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3018); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -11723,7 +11706,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3020); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3015); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -11736,7 +11719,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); ZEPHIR_INIT_NVAR(&_15$$5); - zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3017); + zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3012); if (ZEPHIR_IS_EQUAL(&_16$$5, &valueB)) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 1); @@ -11744,7 +11727,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 0); } - zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3017); + zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3012); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11760,7 +11743,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); - zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3017); + zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3012); if (ZEPHIR_IS_EQUAL(&_18$$6, &valueB)) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 1); @@ -11768,14 +11751,14 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3017); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3012); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3020); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3015); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -11790,7 +11773,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3020); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3015); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -11803,7 +11786,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); ZEPHIR_INIT_NVAR(&_23$$8); - zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3017); + zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3012); if (ZEPHIR_IS_EQUAL(&_24$$8, &valueB)) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 1); @@ -11811,7 +11794,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 0); } - zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3017); + zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3012); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11827,7 +11810,7 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_25$$9); - zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3017); + zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3012); if (ZEPHIR_IS_EQUAL(&_26$$9, &valueB)) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 1); @@ -11835,14 +11818,14 @@ PHP_METHOD(Tensor_Matrix, equalVector) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 0); } - zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3017); + zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3012); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3020); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3015); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -11922,7 +11905,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3039); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3034); ZEPHIR_MM_RESTORE(); return; } @@ -11933,7 +11916,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3058); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3053); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -11941,7 +11924,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3055); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3050); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -11954,7 +11937,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); ZEPHIR_INIT_NVAR(&_15$$5); - zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3052); + zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3047); if (!ZEPHIR_IS_EQUAL(&_16$$5, &valueB)) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 1); @@ -11962,7 +11945,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 0); } - zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3052); + zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3047); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -11978,7 +11961,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); - zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3052); + zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3047); if (!ZEPHIR_IS_EQUAL(&_18$$6, &valueB)) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 1); @@ -11986,14 +11969,14 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3052); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3047); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3055); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3050); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -12008,7 +11991,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3055); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3050); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -12021,7 +12004,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); ZEPHIR_INIT_NVAR(&_23$$8); - zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3052); + zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3047); if (!ZEPHIR_IS_EQUAL(&_24$$8, &valueB)) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 1); @@ -12029,7 +12012,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 0); } - zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3052); + zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3047); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -12045,7 +12028,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_25$$9); - zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3052); + zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3047); if (!ZEPHIR_IS_EQUAL(&_26$$9, &valueB)) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 1); @@ -12053,14 +12036,14 @@ PHP_METHOD(Tensor_Matrix, notEqualVector) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 0); } - zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3052); + zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3047); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3055); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3050); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -12140,7 +12123,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3074); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3069); ZEPHIR_MM_RESTORE(); return; } @@ -12151,7 +12134,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3093); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3088); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -12159,7 +12142,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3090); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3085); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -12172,7 +12155,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); ZEPHIR_INIT_NVAR(&_15$$5); - zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3087); + zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3082); if (ZEPHIR_GT(&_16$$5, &valueB)) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 1); @@ -12180,7 +12163,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 0); } - zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3087); + zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3082); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -12196,7 +12179,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); - zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3087); + zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3082); if (ZEPHIR_GT(&_18$$6, &valueB)) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 1); @@ -12204,14 +12187,14 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3087); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3082); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3090); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3085); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -12226,7 +12209,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3090); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3085); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -12239,7 +12222,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); ZEPHIR_INIT_NVAR(&_23$$8); - zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3087); + zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3082); if (ZEPHIR_GT(&_24$$8, &valueB)) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 1); @@ -12247,7 +12230,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 0); } - zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3087); + zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3082); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -12263,7 +12246,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_25$$9); - zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3087); + zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3082); if (ZEPHIR_GT(&_26$$9, &valueB)) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 1); @@ -12271,14 +12254,14 @@ PHP_METHOD(Tensor_Matrix, greaterVector) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 0); } - zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3087); + zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3082); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3090); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3085); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -12358,7 +12341,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3109); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3104); ZEPHIR_MM_RESTORE(); return; } @@ -12369,7 +12352,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3128); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3123); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -12377,7 +12360,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3125); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3120); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -12390,7 +12373,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); ZEPHIR_INIT_NVAR(&_15$$5); - zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3122); + zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3117); if (ZEPHIR_GE(&_16$$5, &valueB)) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 1); @@ -12398,7 +12381,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 0); } - zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3122); + zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3117); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -12414,7 +12397,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); - zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3122); + zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3117); if (ZEPHIR_GE(&_18$$6, &valueB)) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 1); @@ -12422,14 +12405,14 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3122); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3117); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3125); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3120); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -12444,7 +12427,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3125); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3120); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -12457,7 +12440,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); ZEPHIR_INIT_NVAR(&_23$$8); - zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3122); + zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3117); if (ZEPHIR_GE(&_24$$8, &valueB)) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 1); @@ -12465,7 +12448,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 0); } - zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3122); + zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3117); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -12481,7 +12464,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_25$$9); - zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3122); + zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3117); if (ZEPHIR_GE(&_26$$9, &valueB)) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 1); @@ -12489,14 +12472,14 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 0); } - zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3122); + zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3117); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3125); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3120); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -12576,7 +12559,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3144); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3139); ZEPHIR_MM_RESTORE(); return; } @@ -12587,7 +12570,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3163); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3158); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -12595,7 +12578,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3160); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3155); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -12608,7 +12591,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); ZEPHIR_INIT_NVAR(&_15$$5); - zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3157); + zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3152); if (ZEPHIR_LT(&_16$$5, &valueB)) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 1); @@ -12616,7 +12599,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 0); } - zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3157); + zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3152); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -12632,7 +12615,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); - zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3157); + zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3152); if (ZEPHIR_LT(&_18$$6, &valueB)) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 1); @@ -12640,14 +12623,14 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3157); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3152); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3160); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3155); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -12662,7 +12645,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3160); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3155); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -12675,7 +12658,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); ZEPHIR_INIT_NVAR(&_23$$8); - zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3157); + zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3152); if (ZEPHIR_LT(&_24$$8, &valueB)) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 1); @@ -12683,7 +12666,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 0); } - zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3157); + zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3152); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -12699,7 +12682,7 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_25$$9); - zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3157); + zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3152); if (ZEPHIR_LT(&_26$$9, &valueB)) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 1); @@ -12707,14 +12690,14 @@ PHP_METHOD(Tensor_Matrix, lessVector) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 0); } - zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3157); + zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3152); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3160); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3155); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -12794,7 +12777,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " columns but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3179); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3174); ZEPHIR_MM_RESTORE(); return; } @@ -12805,7 +12788,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0); zephir_check_call_status(); zephir_read_property(&_8, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3198); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3193); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) { @@ -12813,7 +12796,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZVAL_COPY(&rowA, _9); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3195); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3190); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$4, _14$$4, _11$$4) { @@ -12826,7 +12809,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _11$$4); ZEPHIR_INIT_NVAR(&_15$$5); - zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3192); + zephir_array_fetch(&_16$$5, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3187); if (ZEPHIR_LE(&_16$$5, &valueB)) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 1); @@ -12834,7 +12817,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, 0); } - zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3192); + zephir_array_append(&rowC, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 3187); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -12850,7 +12833,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); - zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3192); + zephir_array_fetch(&_18$$6, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3187); if (ZEPHIR_LE(&_18$$6, &valueB)) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 1); @@ -12858,14 +12841,14 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3192); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3187); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3195); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3190); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -12880,7 +12863,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3195); + zephir_is_iterable(&bHat, 0, "tensor/matrix.zep", 3190); if (Z_TYPE_P(&bHat) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _21$$7, _22$$7, _19$$7) { @@ -12893,7 +12876,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_INIT_NVAR(&valueB); ZVAL_COPY(&valueB, _19$$7); ZEPHIR_INIT_NVAR(&_23$$8); - zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3192); + zephir_array_fetch(&_24$$8, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3187); if (ZEPHIR_LE(&_24$$8, &valueB)) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 1); @@ -12901,7 +12884,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_INIT_NVAR(&_23$$8); ZVAL_LONG(&_23$$8, 0); } - zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3192); + zephir_array_append(&rowC, &_23$$8, PH_SEPARATE, "tensor/matrix.zep", 3187); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &bHat, "rewind", NULL, 0); @@ -12917,7 +12900,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_CALL_METHOD(&valueB, &bHat, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_25$$9); - zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3192); + zephir_array_fetch(&_26$$9, &rowA, &j, PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3187); if (ZEPHIR_LE(&_26$$9, &valueB)) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 1); @@ -12925,14 +12908,14 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector) { ZEPHIR_INIT_NVAR(&_25$$9); ZVAL_LONG(&_25$$9, 0); } - zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3192); + zephir_array_append(&rowC, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 3187); ZEPHIR_CALL_METHOD(NULL, &bHat, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueB); ZEPHIR_INIT_NVAR(&j); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3195); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3190); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -13009,7 +12992,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3213); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3208); ZEPHIR_MM_RESTORE(); return; } @@ -13019,7 +13002,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3232); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3227); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -13033,10 +13016,10 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3221); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3216); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3229); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3224); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -13044,7 +13027,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector) { ZVAL_COPY(&valueA, _14$$4); ZEPHIR_INIT_NVAR(&_16$$5); mul_function(&_16$$5, &valueA, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3226); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3221); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13059,13 +13042,13 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); mul_function(&_17$$6, &valueA, &valueB); - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3226); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3221); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3229); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3224); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -13082,10 +13065,10 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3221); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3216); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3229); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3224); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -13093,7 +13076,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector) { ZVAL_COPY(&valueA, _19$$7); ZEPHIR_INIT_NVAR(&_21$$8); mul_function(&_21$$8, &valueA, &valueB); - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3226); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3221); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13108,13 +13091,13 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_22$$9); mul_function(&_22$$9, &valueA, &valueB); - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3226); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3221); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3229); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3224); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -13192,7 +13175,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3247); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3242); ZEPHIR_MM_RESTORE(); return; } @@ -13202,7 +13185,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3266); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3261); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -13216,10 +13199,10 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3255); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3250); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3263); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3258); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -13227,7 +13210,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector) { ZVAL_COPY(&valueA, _14$$4); ZEPHIR_INIT_NVAR(&_16$$5); div_function(&_16$$5, &valueA, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3260); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3255); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13242,13 +13225,13 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); div_function(&_17$$6, &valueA, &valueB); - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3260); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3255); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3263); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3258); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -13265,10 +13248,10 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3255); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3250); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3263); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3258); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -13276,7 +13259,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector) { ZVAL_COPY(&valueA, _19$$7); ZEPHIR_INIT_NVAR(&_21$$8); div_function(&_21$$8, &valueA, &valueB); - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3260); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3255); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13291,13 +13274,13 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_22$$9); div_function(&_22$$9, &valueA, &valueB); - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3260); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3255); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3263); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3258); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -13375,7 +13358,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3281); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3276); ZEPHIR_MM_RESTORE(); return; } @@ -13385,7 +13368,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3300); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3295); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -13399,10 +13382,10 @@ PHP_METHOD(Tensor_Matrix, addColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3289); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3284); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3297); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3292); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -13410,7 +13393,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector) { ZVAL_COPY(&valueA, _14$$4); ZEPHIR_INIT_NVAR(&_16$$5); zephir_add_function(&_16$$5, &valueA, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3294); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3289); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13425,13 +13408,13 @@ PHP_METHOD(Tensor_Matrix, addColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); zephir_add_function(&_17$$6, &valueA, &valueB); - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3294); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3289); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3297); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3292); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -13448,10 +13431,10 @@ PHP_METHOD(Tensor_Matrix, addColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3289); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3284); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3297); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3292); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -13459,7 +13442,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector) { ZVAL_COPY(&valueA, _19$$7); ZEPHIR_INIT_NVAR(&_21$$8); zephir_add_function(&_21$$8, &valueA, &valueB); - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3294); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3289); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13474,13 +13457,13 @@ PHP_METHOD(Tensor_Matrix, addColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_22$$9); zephir_add_function(&_22$$9, &valueA, &valueB); - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3294); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3289); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3297); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3292); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -13558,7 +13541,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3315); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3310); ZEPHIR_MM_RESTORE(); return; } @@ -13568,7 +13551,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3334); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3329); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -13582,10 +13565,10 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3323); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3318); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3331); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3326); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -13593,7 +13576,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector) { ZVAL_COPY(&valueA, _14$$4); ZEPHIR_INIT_NVAR(&_16$$5); zephir_sub_function(&_16$$5, &valueA, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3328); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3323); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13608,13 +13591,13 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); zephir_sub_function(&_17$$6, &valueA, &valueB); - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3328); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3323); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3331); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3326); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -13631,10 +13614,10 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3323); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3318); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3331); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3326); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -13642,7 +13625,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector) { ZVAL_COPY(&valueA, _19$$7); ZEPHIR_INIT_NVAR(&_21$$8); zephir_sub_function(&_21$$8, &valueA, &valueB); - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3328); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3323); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13657,13 +13640,13 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_22$$9); zephir_sub_function(&_22$$9, &valueA, &valueB); - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3328); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3323); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3331); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3326); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -13741,7 +13724,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3349); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3344); ZEPHIR_MM_RESTORE(); return; } @@ -13751,7 +13734,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3368); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3363); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -13765,10 +13748,10 @@ PHP_METHOD(Tensor_Matrix, powColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3357); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3352); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3365); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3360); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -13776,7 +13759,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector) { ZVAL_COPY(&valueA, _14$$4); ZEPHIR_INIT_NVAR(&_16$$5); zephir_pow_function(&_16$$5, &valueA, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3362); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3357); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13791,13 +13774,13 @@ PHP_METHOD(Tensor_Matrix, powColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); zephir_pow_function(&_17$$6, &valueA, &valueB); - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3362); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3357); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3365); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3360); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -13814,10 +13797,10 @@ PHP_METHOD(Tensor_Matrix, powColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3357); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3352); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3365); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3360); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -13825,7 +13808,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector) { ZVAL_COPY(&valueA, _19$$7); ZEPHIR_INIT_NVAR(&_21$$8); zephir_pow_function(&_21$$8, &valueA, &valueB); - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3362); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3357); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13840,13 +13823,13 @@ PHP_METHOD(Tensor_Matrix, powColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_22$$9); zephir_pow_function(&_22$$9, &valueA, &valueB); - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3362); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3357); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3365); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3360); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -13924,7 +13907,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3383); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3378); ZEPHIR_MM_RESTORE(); return; } @@ -13934,7 +13917,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3402); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3397); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -13948,10 +13931,10 @@ PHP_METHOD(Tensor_Matrix, modColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3391); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3386); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3399); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3394); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -13959,7 +13942,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector) { ZVAL_COPY(&valueA, _14$$4); ZEPHIR_INIT_NVAR(&_16$$5); mod_function(&_16$$5, &valueA, &valueB); - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3396); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3391); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -13974,13 +13957,13 @@ PHP_METHOD(Tensor_Matrix, modColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$6); mod_function(&_17$$6, &valueA, &valueB); - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3396); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3391); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3399); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3394); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -13997,10 +13980,10 @@ PHP_METHOD(Tensor_Matrix, modColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3391); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3386); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3399); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3394); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -14008,7 +13991,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector) { ZVAL_COPY(&valueA, _19$$7); ZEPHIR_INIT_NVAR(&_21$$8); mod_function(&_21$$8, &valueA, &valueB); - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3396); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3391); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -14023,13 +14006,13 @@ PHP_METHOD(Tensor_Matrix, modColumnVector) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_22$$9); mod_function(&_22$$9, &valueA, &valueB); - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3396); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3391); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3399); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3394); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -14108,7 +14091,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3418); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3413); ZEPHIR_MM_RESTORE(); return; } @@ -14118,7 +14101,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3437); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3432); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -14132,10 +14115,10 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3426); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3421); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3434); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3429); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -14149,7 +14132,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3431); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3426); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -14170,13 +14153,13 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3431); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3426); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3434); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3429); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -14193,10 +14176,10 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3426); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3421); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3434); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3429); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -14210,7 +14193,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector) { ZEPHIR_INIT_NVAR(&_21$$8); ZVAL_LONG(&_21$$8, 0); } - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3431); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3426); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -14231,13 +14214,13 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector) { ZEPHIR_INIT_NVAR(&_22$$9); ZVAL_LONG(&_22$$9, 0); } - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3431); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3426); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3434); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3429); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -14316,7 +14299,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3453); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3448); ZEPHIR_MM_RESTORE(); return; } @@ -14326,7 +14309,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3472); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3467); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -14340,10 +14323,10 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3461); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3456); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3469); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3464); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -14357,7 +14340,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3466); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3461); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -14378,13 +14361,13 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3466); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3461); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3469); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3464); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -14401,10 +14384,10 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3461); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3456); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3469); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3464); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -14418,7 +14401,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector) { ZEPHIR_INIT_NVAR(&_21$$8); ZVAL_LONG(&_21$$8, 0); } - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3466); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3461); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -14439,13 +14422,13 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector) { ZEPHIR_INIT_NVAR(&_22$$9); ZVAL_LONG(&_22$$9, 0); } - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3466); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3461); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3469); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3464); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -14524,7 +14507,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3488); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3483); ZEPHIR_MM_RESTORE(); return; } @@ -14534,7 +14517,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3507); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3502); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -14548,10 +14531,10 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3496); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3491); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3504); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3499); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -14565,7 +14548,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3501); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3496); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -14586,13 +14569,13 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3501); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3496); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3504); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3499); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -14609,10 +14592,10 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3496); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3491); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3504); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3499); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -14626,7 +14609,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector) { ZEPHIR_INIT_NVAR(&_21$$8); ZVAL_LONG(&_21$$8, 0); } - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3501); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3496); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -14647,13 +14630,13 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector) { ZEPHIR_INIT_NVAR(&_22$$9); ZVAL_LONG(&_22$$9, 0); } - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3501); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3496); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3504); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3499); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -14732,7 +14715,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3523); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3518); ZEPHIR_MM_RESTORE(); return; } @@ -14742,7 +14725,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3542); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3537); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -14756,10 +14739,10 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3531); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3526); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3539); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3534); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -14773,7 +14756,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3536); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3531); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -14794,13 +14777,13 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3536); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3531); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3539); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3534); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -14817,10 +14800,10 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3531); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3526); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3539); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3534); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -14834,7 +14817,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector) { ZEPHIR_INIT_NVAR(&_21$$8); ZVAL_LONG(&_21$$8, 0); } - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3536); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3531); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -14855,13 +14838,13 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector) { ZEPHIR_INIT_NVAR(&_22$$9); ZVAL_LONG(&_22$$9, 0); } - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3536); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3531); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3539); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3534); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -14940,7 +14923,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3558); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3553); ZEPHIR_MM_RESTORE(); return; } @@ -14950,7 +14933,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3577); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3572); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -14964,10 +14947,10 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3566); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3561); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3574); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3569); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -14981,7 +14964,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3571); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3566); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15002,13 +14985,13 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3571); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3566); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3574); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3569); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -15025,10 +15008,10 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3566); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3561); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3574); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3569); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -15042,7 +15025,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector) { ZEPHIR_INIT_NVAR(&_21$$8); ZVAL_LONG(&_21$$8, 0); } - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3571); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3566); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15063,13 +15046,13 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector) { ZEPHIR_INIT_NVAR(&_22$$9); ZVAL_LONG(&_22$$9, 0); } - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3571); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3566); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3574); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3569); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -15148,7 +15131,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector) { ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Vector B has ", &_6$$3, "."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3593); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3588); ZEPHIR_MM_RESTORE(); return; } @@ -15158,7 +15141,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector) { array_init(&rowC); ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0); zephir_check_call_status(); - zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3612); + zephir_is_iterable(&_8, 0, "tensor/matrix.zep", 3607); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9) { @@ -15172,10 +15155,10 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector) { ZVAL_COPY(&valueB, _9); zephir_read_property(&_13$$4, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3601); + zephir_array_fetch(&rowA, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 3596); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3609); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3604); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _14$$4) { @@ -15189,7 +15172,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector) { ZEPHIR_INIT_NVAR(&_16$$5); ZVAL_LONG(&_16$$5, 0); } - zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3606); + zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 3601); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15210,13 +15193,13 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector) { ZEPHIR_INIT_NVAR(&_17$$6); ZVAL_LONG(&_17$$6, 0); } - zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3606); + zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/matrix.zep", 3601); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3609); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3604); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0); @@ -15233,10 +15216,10 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector) { zephir_check_call_status(); zephir_read_property(&_18$$7, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&rowA); - zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3601); + zephir_array_fetch(&rowA, &_18$$7, &i, PH_NOISY, "tensor/matrix.zep", 3596); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3609); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3604); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _19$$7) { @@ -15250,7 +15233,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector) { ZEPHIR_INIT_NVAR(&_21$$8); ZVAL_LONG(&_21$$8, 0); } - zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3606); + zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 3601); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15271,13 +15254,13 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector) { ZEPHIR_INIT_NVAR(&_22$$9); ZVAL_LONG(&_22$$9, 0); } - zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3606); + zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/matrix.zep", 3601); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3609); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3604); ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); zephir_check_call_status(); } @@ -15344,7 +15327,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3626); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3621); ZEPHIR_MM_RESTORE(); return; } @@ -15353,7 +15336,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3643); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3638); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -15361,7 +15344,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3640); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3635); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -15369,7 +15352,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar) { ZVAL_COPY(&valueA, _8$$4); ZEPHIR_INIT_NVAR(&_10$$5); mul_function(&_10$$5, &valueA, b); - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3637); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3632); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15384,13 +15367,13 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_11$$6); mul_function(&_11$$6, &valueA, b); - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3637); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3632); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3640); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3635); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -15405,7 +15388,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3640); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3635); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -15413,7 +15396,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar) { ZVAL_COPY(&valueA, _12$$7); ZEPHIR_INIT_NVAR(&_14$$8); mul_function(&_14$$8, &valueA, b); - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3637); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3632); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15428,13 +15411,13 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_15$$9); mul_function(&_15$$9, &valueA, b); - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3637); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3632); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3640); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3635); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -15500,7 +15483,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3657); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3652); ZEPHIR_MM_RESTORE(); return; } @@ -15509,7 +15492,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3674); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3669); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -15517,7 +15500,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3671); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3666); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -15525,7 +15508,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar) { ZVAL_COPY(&valueA, _8$$4); ZEPHIR_INIT_NVAR(&_10$$5); div_function(&_10$$5, &valueA, b); - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3668); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3663); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15540,13 +15523,13 @@ PHP_METHOD(Tensor_Matrix, divideScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_11$$6); div_function(&_11$$6, &valueA, b); - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3668); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3663); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3671); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3666); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -15561,7 +15544,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3671); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3666); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -15569,7 +15552,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar) { ZVAL_COPY(&valueA, _12$$7); ZEPHIR_INIT_NVAR(&_14$$8); div_function(&_14$$8, &valueA, b); - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3668); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3663); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15584,13 +15567,13 @@ PHP_METHOD(Tensor_Matrix, divideScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_15$$9); div_function(&_15$$9, &valueA, b); - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3668); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3663); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3671); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3666); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -15656,7 +15639,7 @@ PHP_METHOD(Tensor_Matrix, addScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3688); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3683); ZEPHIR_MM_RESTORE(); return; } @@ -15665,7 +15648,7 @@ PHP_METHOD(Tensor_Matrix, addScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3705); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3700); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -15673,7 +15656,7 @@ PHP_METHOD(Tensor_Matrix, addScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3702); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3697); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -15681,7 +15664,7 @@ PHP_METHOD(Tensor_Matrix, addScalar) { ZVAL_COPY(&valueA, _8$$4); ZEPHIR_INIT_NVAR(&_10$$5); zephir_add_function(&_10$$5, &valueA, b); - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3699); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3694); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15696,13 +15679,13 @@ PHP_METHOD(Tensor_Matrix, addScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_11$$6); zephir_add_function(&_11$$6, &valueA, b); - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3699); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3694); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3702); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3697); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -15717,7 +15700,7 @@ PHP_METHOD(Tensor_Matrix, addScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3702); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3697); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -15725,7 +15708,7 @@ PHP_METHOD(Tensor_Matrix, addScalar) { ZVAL_COPY(&valueA, _12$$7); ZEPHIR_INIT_NVAR(&_14$$8); zephir_add_function(&_14$$8, &valueA, b); - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3699); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3694); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15740,13 +15723,13 @@ PHP_METHOD(Tensor_Matrix, addScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_15$$9); zephir_add_function(&_15$$9, &valueA, b); - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3699); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3694); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3702); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3697); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -15812,7 +15795,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3719); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3714); ZEPHIR_MM_RESTORE(); return; } @@ -15821,7 +15804,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3736); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3731); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -15829,7 +15812,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3733); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3728); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -15837,7 +15820,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar) { ZVAL_COPY(&valueA, _8$$4); ZEPHIR_INIT_NVAR(&_10$$5); zephir_sub_function(&_10$$5, &valueA, b); - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3730); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3725); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15852,13 +15835,13 @@ PHP_METHOD(Tensor_Matrix, subtractScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_11$$6); zephir_sub_function(&_11$$6, &valueA, b); - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3730); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3725); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3733); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3728); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -15873,7 +15856,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3733); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3728); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -15881,7 +15864,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar) { ZVAL_COPY(&valueA, _12$$7); ZEPHIR_INIT_NVAR(&_14$$8); zephir_sub_function(&_14$$8, &valueA, b); - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3730); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3725); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -15896,13 +15879,13 @@ PHP_METHOD(Tensor_Matrix, subtractScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_15$$9); zephir_sub_function(&_15$$9, &valueA, b); - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3730); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3725); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3733); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3728); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -15968,7 +15951,7 @@ PHP_METHOD(Tensor_Matrix, powScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an", " integnr or floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3751); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3746); ZEPHIR_MM_RESTORE(); return; } @@ -15977,7 +15960,7 @@ PHP_METHOD(Tensor_Matrix, powScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3768); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3763); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -15985,7 +15968,7 @@ PHP_METHOD(Tensor_Matrix, powScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3765); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3760); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -15993,7 +15976,7 @@ PHP_METHOD(Tensor_Matrix, powScalar) { ZVAL_COPY(&valueA, _8$$4); ZEPHIR_INIT_NVAR(&_10$$5); zephir_pow_function(&_10$$5, &valueA, b); - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3762); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3757); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16008,13 +15991,13 @@ PHP_METHOD(Tensor_Matrix, powScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_11$$6); zephir_pow_function(&_11$$6, &valueA, b); - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3762); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3757); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3765); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3760); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -16029,7 +16012,7 @@ PHP_METHOD(Tensor_Matrix, powScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3765); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3760); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -16037,7 +16020,7 @@ PHP_METHOD(Tensor_Matrix, powScalar) { ZVAL_COPY(&valueA, _12$$7); ZEPHIR_INIT_NVAR(&_14$$8); zephir_pow_function(&_14$$8, &valueA, b); - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3762); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3757); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16052,13 +16035,13 @@ PHP_METHOD(Tensor_Matrix, powScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_15$$9); zephir_pow_function(&_15$$9, &valueA, b); - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3762); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3757); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3765); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3760); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -16124,7 +16107,7 @@ PHP_METHOD(Tensor_Matrix, modScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3782); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3777); ZEPHIR_MM_RESTORE(); return; } @@ -16133,7 +16116,7 @@ PHP_METHOD(Tensor_Matrix, modScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3799); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3794); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -16141,7 +16124,7 @@ PHP_METHOD(Tensor_Matrix, modScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3796); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3791); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -16149,7 +16132,7 @@ PHP_METHOD(Tensor_Matrix, modScalar) { ZVAL_COPY(&valueA, _8$$4); ZEPHIR_INIT_NVAR(&_10$$5); mod_function(&_10$$5, &valueA, b); - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3793); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3788); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16164,13 +16147,13 @@ PHP_METHOD(Tensor_Matrix, modScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_11$$6); mod_function(&_11$$6, &valueA, b); - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3793); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3788); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3796); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3791); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -16185,7 +16168,7 @@ PHP_METHOD(Tensor_Matrix, modScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3796); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3791); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -16193,7 +16176,7 @@ PHP_METHOD(Tensor_Matrix, modScalar) { ZVAL_COPY(&valueA, _12$$7); ZEPHIR_INIT_NVAR(&_14$$8); mod_function(&_14$$8, &valueA, b); - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3793); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3788); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16208,13 +16191,13 @@ PHP_METHOD(Tensor_Matrix, modScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_15$$9); mod_function(&_15$$9, &valueA, b); - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3793); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3788); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3796); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3791); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -16281,7 +16264,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3814); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3809); ZEPHIR_MM_RESTORE(); return; } @@ -16290,7 +16273,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3831); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3826); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -16298,7 +16281,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3828); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3823); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -16312,7 +16295,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar) { ZEPHIR_INIT_NVAR(&_10$$5); ZVAL_LONG(&_10$$5, 0); } - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3825); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3820); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16333,13 +16316,13 @@ PHP_METHOD(Tensor_Matrix, equalScalar) { ZEPHIR_INIT_NVAR(&_11$$6); ZVAL_LONG(&_11$$6, 0); } - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3825); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3820); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3828); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3823); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -16354,7 +16337,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3828); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3823); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -16368,7 +16351,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar) { ZEPHIR_INIT_NVAR(&_14$$8); ZVAL_LONG(&_14$$8, 0); } - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3825); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3820); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16389,13 +16372,13 @@ PHP_METHOD(Tensor_Matrix, equalScalar) { ZEPHIR_INIT_NVAR(&_15$$9); ZVAL_LONG(&_15$$9, 0); } - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3825); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3820); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3828); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3823); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -16462,7 +16445,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3846); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3841); ZEPHIR_MM_RESTORE(); return; } @@ -16471,7 +16454,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3863); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3858); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -16479,7 +16462,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3860); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3855); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -16493,7 +16476,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar) { ZEPHIR_INIT_NVAR(&_10$$5); ZVAL_LONG(&_10$$5, 0); } - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3857); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3852); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16514,13 +16497,13 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar) { ZEPHIR_INIT_NVAR(&_11$$6); ZVAL_LONG(&_11$$6, 0); } - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3857); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3852); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3860); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3855); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -16535,7 +16518,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3860); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3855); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -16549,7 +16532,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar) { ZEPHIR_INIT_NVAR(&_14$$8); ZVAL_LONG(&_14$$8, 0); } - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3857); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3852); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16570,13 +16553,13 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar) { ZEPHIR_INIT_NVAR(&_15$$9); ZVAL_LONG(&_15$$9, 0); } - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3857); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3852); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3860); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3855); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -16643,7 +16626,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3878); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3873); ZEPHIR_MM_RESTORE(); return; } @@ -16652,7 +16635,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3895); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3890); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -16660,7 +16643,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3892); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3887); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -16674,7 +16657,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar) { ZEPHIR_INIT_NVAR(&_10$$5); ZVAL_LONG(&_10$$5, 0); } - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3889); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3884); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16695,13 +16678,13 @@ PHP_METHOD(Tensor_Matrix, greaterScalar) { ZEPHIR_INIT_NVAR(&_11$$6); ZVAL_LONG(&_11$$6, 0); } - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3889); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3884); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3892); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3887); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -16716,7 +16699,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3892); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3887); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -16730,7 +16713,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar) { ZEPHIR_INIT_NVAR(&_14$$8); ZVAL_LONG(&_14$$8, 0); } - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3889); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3884); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16751,13 +16734,13 @@ PHP_METHOD(Tensor_Matrix, greaterScalar) { ZEPHIR_INIT_NVAR(&_15$$9); ZVAL_LONG(&_15$$9, 0); } - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3889); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3884); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3892); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3887); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -16824,7 +16807,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3910); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3905); ZEPHIR_MM_RESTORE(); return; } @@ -16833,7 +16816,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3927); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3922); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -16841,7 +16824,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3924); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3919); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -16855,7 +16838,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar) { ZEPHIR_INIT_NVAR(&_10$$5); ZVAL_LONG(&_10$$5, 0); } - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3921); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3916); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16876,13 +16859,13 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar) { ZEPHIR_INIT_NVAR(&_11$$6); ZVAL_LONG(&_11$$6, 0); } - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3921); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3916); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3924); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3919); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -16897,7 +16880,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3924); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3919); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -16911,7 +16894,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar) { ZEPHIR_INIT_NVAR(&_14$$8); ZVAL_LONG(&_14$$8, 0); } - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3921); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3916); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -16932,13 +16915,13 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar) { ZEPHIR_INIT_NVAR(&_15$$9); ZVAL_LONG(&_15$$9, 0); } - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3921); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3916); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3924); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3919); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -17005,7 +16988,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3942); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3937); ZEPHIR_MM_RESTORE(); return; } @@ -17014,7 +16997,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3959); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3954); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -17022,7 +17005,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3956); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3951); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -17036,7 +17019,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar) { ZEPHIR_INIT_NVAR(&_10$$5); ZVAL_LONG(&_10$$5, 0); } - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3953); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3948); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -17057,13 +17040,13 @@ PHP_METHOD(Tensor_Matrix, lessScalar) { ZEPHIR_INIT_NVAR(&_11$$6); ZVAL_LONG(&_11$$6, 0); } - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3953); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3948); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3956); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3951); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -17078,7 +17061,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3956); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3951); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -17092,7 +17075,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar) { ZEPHIR_INIT_NVAR(&_14$$8); ZVAL_LONG(&_14$$8, 0); } - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3953); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3948); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -17113,13 +17096,13 @@ PHP_METHOD(Tensor_Matrix, lessScalar) { ZEPHIR_INIT_NVAR(&_15$$9); ZVAL_LONG(&_15$$9, 0); } - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3953); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3948); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3956); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3951); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -17186,7 +17169,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar) { ZEPHIR_CONCAT_SSVS(&_4$$3, "Scalar must be an integer or", " floating point number, ", &_3$$3, " given."); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_4$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3974); + zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3969); ZEPHIR_MM_RESTORE(); return; } @@ -17195,7 +17178,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar) { ZEPHIR_INIT_VAR(&rowC); array_init(&rowC); zephir_read_property(&_5, this_ptr, SL("a"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3991); + zephir_is_iterable(&_5, 0, "tensor/matrix.zep", 3986); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) { @@ -17203,7 +17186,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar) { ZVAL_COPY(&rowA, _6); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3988); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3983); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _8$$4) { @@ -17217,7 +17200,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar) { ZEPHIR_INIT_NVAR(&_10$$5); ZVAL_LONG(&_10$$5, 0); } - zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3985); + zephir_array_append(&rowC, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 3980); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -17238,13 +17221,13 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar) { ZEPHIR_INIT_NVAR(&_11$$6); ZVAL_LONG(&_11$$6, 0); } - zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3985); + zephir_array_append(&rowC, &_11$$6, PH_SEPARATE, "tensor/matrix.zep", 3980); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3988); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3983); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &_5, "rewind", NULL, 0); @@ -17259,7 +17242,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar) { zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowC); array_init(&rowC); - zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3988); + zephir_is_iterable(&rowA, 0, "tensor/matrix.zep", 3983); if (Z_TYPE_P(&rowA) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowA), _12$$7) { @@ -17273,7 +17256,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar) { ZEPHIR_INIT_NVAR(&_14$$8); ZVAL_LONG(&_14$$8, 0); } - zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3985); + zephir_array_append(&rowC, &_14$$8, PH_SEPARATE, "tensor/matrix.zep", 3980); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &rowA, "rewind", NULL, 0); @@ -17294,13 +17277,13 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar) { ZEPHIR_INIT_NVAR(&_15$$9); ZVAL_LONG(&_15$$9, 0); } - zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3985); + zephir_array_append(&rowC, &_15$$9, PH_SEPARATE, "tensor/matrix.zep", 3980); ZEPHIR_CALL_METHOD(NULL, &rowA, "next", NULL, 0); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(&valueA); - zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3988); + zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/matrix.zep", 3983); ZEPHIR_CALL_METHOD(NULL, &_5, "next", NULL, 0); zephir_check_call_status(); } @@ -17347,7 +17330,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet) { - ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(spl_ce_RuntimeException, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 4009); + ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(spl_ce_RuntimeException, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 4004); return; } @@ -17390,7 +17373,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset) { - ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(spl_ce_RuntimeException, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 4029); + ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(spl_ce_RuntimeException, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 4024); return; } @@ -17434,7 +17417,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet) { ZEPHIR_CONCAT_SSVS(&_3, "Element not found at", " offset ", &_2, "."); ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 3, &_3); zephir_check_call_status(); - zephir_throw_exception_debug(&_1, "tensor/matrix.zep", 4048); + zephir_throw_exception_debug(&_1, "tensor/matrix.zep", 4043); ZEPHIR_MM_RESTORE(); return;