text: 
  #ifdef HAVE_CONFIG_H
  #include "../ext_config.h"
  #endif
  
  #include <php.h>
  #include "../php_ext.h"
  #include "../ext.h"
  
  #include <Zend/zend_operators.h>
  #include <Zend/zend_exceptions.h>
  #include <Zend/zend_interfaces.h>
  
  #include "kernel/main.h"
  #include "kernel/fcall.h"
  #include "kernel/memory.h"
  #include "kernel/operators.h"
  #include "kernel/object.h"
  #include "kernel/exception.h"
  #include "kernel/concat.h"
  #include "kernel/array.h"
  
  
  /**
   * Column Vector
   *
   * A one dimensional (rank 1) tensor with integer and/or floating point elements.
   *
   * @category    Scientific Computing
   * @package     Rubix/Tensor
   * @author      Andrew DalPino
   */
  ZEPHIR_INIT_CLASS(Tensor_ColumnVector)
  {
  	ZEPHIR_REGISTER_CLASS_EX(Tensor, ColumnVector, tensor, columnvector, tensor_vector_ce, tensor_columnvector_method_entry, 0);
  
  	return SUCCESS;
  }
  
  /**
   * Factory method to build a new vector from an array.
   *
   * @param (int|float)[] a
   * @return self
   */
  PHP_METHOD(Tensor_ColumnVector, build)
  {
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *a_param = NULL, _0;
  	zval a;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&a);
  	ZVAL_UNDEF(&_0);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(0, 1)
  		Z_PARAM_OPTIONAL
  		Z_PARAM_ARRAY(a)
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 0, 1, &a_param);
  	if (!a_param) {
  		ZEPHIR_INIT_VAR(&a);
  		array_init(&a);
  	} else {
  		zephir_get_arrval(&a, a_param);
  	}
  
  
  	object_init_ex(return_value, tensor_columnvector_ce);
  	ZVAL_BOOL(&_0, 1);
  	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 1, &a, &_0);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Build a vector foregoing any validation for quicker instantiation.
   *
   * @param (int|float)[] a
   * @return self
   */
  PHP_METHOD(Tensor_ColumnVector, quick)
  {
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *a_param = NULL, _0;
  	zval a;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&a);
  	ZVAL_UNDEF(&_0);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(0, 1)
  		Z_PARAM_OPTIONAL
  		Z_PARAM_ARRAY(a)
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 0, 1, &a_param);
  	if (!a_param) {
  		ZEPHIR_INIT_VAR(&a);
  		array_init(&a);
  	} else {
  		zephir_get_arrval(&a, a_param);
  	}
  
  
  	object_init_ex(return_value, tensor_columnvector_ce);
  	ZVAL_BOOL(&_0, 0);
  	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 1, &a, &_0);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Return the number of rows in the vector.
   *
   * @return int
   */
  PHP_METHOD(Tensor_ColumnVector, m)
  {
  	zval *this_ptr = getThis();
  
  
  
  	RETURN_MEMBER(getThis(), "n");
  }
  
  /**
   * Return the number of columns in the vector.
   *
   * @return int
   */
  PHP_METHOD(Tensor_ColumnVector, n)
  {
  	zval *this_ptr = getThis();
  
  
  
  	RETURN_LONG(1);
  }
  
  /**
   * Transpose the vector i.e. rotate it.
   *
   * @return mixed
   */
  PHP_METHOD(Tensor_ColumnVector, transpose)
  {
  	zval _1;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zephir_fcall_cache_entry *_0 = NULL;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&_1);
  
  
  	ZEPHIR_MM_GROW();
  
  	zephir_read_property(&_1, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "quick", &_0, 0, &_1);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Compute the vector-matrix product of this vector and matrix a.
   *
   * @param \Tensor\Matrix b
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, matmul)
  {
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	ZEPHIR_CALL_METHOD(&_0, this_ptr, "ascolumnmatrix", NULL, 0);
  	zephir_check_call_status();
  	ZEPHIR_RETURN_CALL_METHOD(&_0, "matmul", NULL, 0, b);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Multiply this column vector with a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 92);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 112);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 101);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 109);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					mul_function(&_16$$5, &valueA, &valueB);
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 106);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					zephir_check_call_status();
  						ZEPHIR_INIT_NVAR(&_17$$6);
  						mul_function(&_17$$6, &valueA, &valueB);
  						zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/columnvector.zep", 106);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 109);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 101);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 109);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						mul_function(&_21$$8, &valueA, &valueB);
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 106);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						zephir_check_call_status();
  							ZEPHIR_INIT_NVAR(&_22$$9);
  							mul_function(&_22$$9, &valueA, &valueB);
  							zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/columnvector.zep", 106);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 109);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Divide this column vector with a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, divideMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 127);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 147);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 136);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 144);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					div_function(&_16$$5, &valueA, &valueB);
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 141);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					zephir_check_call_status();
  						ZEPHIR_INIT_NVAR(&_17$$6);
  						div_function(&_17$$6, &valueA, &valueB);
  						zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/columnvector.zep", 141);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 144);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 136);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 144);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						div_function(&_21$$8, &valueA, &valueB);
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 141);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						zephir_check_call_status();
  							ZEPHIR_INIT_NVAR(&_22$$9);
  							div_function(&_22$$9, &valueA, &valueB);
  							zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/columnvector.zep", 141);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 144);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Add this column vector to a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, addMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 162);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 182);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 171);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 179);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					zephir_add_function(&_16$$5, &valueA, &valueB);
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 176);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					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/columnvector.zep", 176);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 179);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 171);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 179);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						zephir_add_function(&_21$$8, &valueA, &valueB);
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 176);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						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/columnvector.zep", 176);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 179);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Subtract a matrix from this column vector.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 197);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 217);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 206);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 214);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					zephir_sub_function(&_16$$5, &valueA, &valueB);
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 211);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					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/columnvector.zep", 211);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 214);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 206);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 214);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						zephir_sub_function(&_21$$8, &valueA, &valueB);
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 211);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						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/columnvector.zep", 211);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 214);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Raise this column vector to the power of a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, powMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 232);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 252);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 241);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 249);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					zephir_pow_function(&_16$$5, &valueA, &valueB);
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 246);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					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/columnvector.zep", 246);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 249);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 241);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 249);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						zephir_pow_function(&_21$$8, &valueA, &valueB);
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 246);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						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/columnvector.zep", 246);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 249);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Mod this column vector with a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, modMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 267);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 287);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 276);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 284);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					mod_function(&_16$$5, &valueA, &valueB);
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 281);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					zephir_check_call_status();
  						ZEPHIR_INIT_NVAR(&_17$$6);
  						mod_function(&_17$$6, &valueA, &valueB);
  						zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/columnvector.zep", 281);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 284);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 276);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 284);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						mod_function(&_21$$8, &valueA, &valueB);
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 281);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						zephir_check_call_status();
  							ZEPHIR_INIT_NVAR(&_22$$9);
  							mod_function(&_22$$9, &valueA, &valueB);
  							zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/columnvector.zep", 281);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 284);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Return the element-wise equality comparison of this column vector and a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, equalMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 302);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 322);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 311);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 319);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					if (ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 1);
  					} else {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 0);
  					}
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 316);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					zephir_check_call_status();
  						ZEPHIR_INIT_NVAR(&_17$$6);
  						if (ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 0);
  						}
  						zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/columnvector.zep", 316);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 319);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 311);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 319);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						if (ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 0);
  						}
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 316);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						zephir_check_call_status();
  							ZEPHIR_INIT_NVAR(&_22$$9);
  							if (ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 1);
  							} else {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 0);
  							}
  							zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/columnvector.zep", 316);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 319);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Return the element-wise not equal comparison of this column vector and a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 337);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 357);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 346);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 354);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					if (!ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 1);
  					} else {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 0);
  					}
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 351);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					zephir_check_call_status();
  						ZEPHIR_INIT_NVAR(&_17$$6);
  						if (!ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 0);
  						}
  						zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/columnvector.zep", 351);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 354);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 346);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 354);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						if (!ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 0);
  						}
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 351);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						zephir_check_call_status();
  							ZEPHIR_INIT_NVAR(&_22$$9);
  							if (!ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 1);
  							} else {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 0);
  							}
  							zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/columnvector.zep", 351);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 354);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Return the element-wise greater than comparison of this column vector and a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 372);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 392);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 381);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 389);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					if (ZEPHIR_GT(&valueA, &valueB)) {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 1);
  					} else {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 0);
  					}
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 386);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					zephir_check_call_status();
  						ZEPHIR_INIT_NVAR(&_17$$6);
  						if (ZEPHIR_GT(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 0);
  						}
  						zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/columnvector.zep", 386);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 389);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 381);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 389);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						if (ZEPHIR_GT(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 0);
  						}
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 386);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						zephir_check_call_status();
  							ZEPHIR_INIT_NVAR(&_22$$9);
  							if (ZEPHIR_GT(&valueA, &valueB)) {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 1);
  							} else {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 0);
  							}
  							zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/columnvector.zep", 386);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 389);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Return the element-wise greater than or equal to comparison of this column vector and a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 407);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 427);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 416);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 424);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					if (ZEPHIR_GE(&valueA, &valueB)) {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 1);
  					} else {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 0);
  					}
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 421);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					zephir_check_call_status();
  						ZEPHIR_INIT_NVAR(&_17$$6);
  						if (ZEPHIR_GE(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 0);
  						}
  						zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/columnvector.zep", 421);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 424);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 416);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 424);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						if (ZEPHIR_GE(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 0);
  						}
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 421);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						zephir_check_call_status();
  							ZEPHIR_INIT_NVAR(&_22$$9);
  							if (ZEPHIR_GE(&valueA, &valueB)) {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 1);
  							} else {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 0);
  							}
  							zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/columnvector.zep", 421);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 424);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Return the element-wise less than comparison of this column vector and a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, lessMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 442);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 462);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 451);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 459);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					if (ZEPHIR_LT(&valueA, &valueB)) {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 1);
  					} else {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 0);
  					}
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 456);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					zephir_check_call_status();
  						ZEPHIR_INIT_NVAR(&_17$$6);
  						if (ZEPHIR_LT(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 0);
  						}
  						zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/columnvector.zep", 456);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 459);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 451);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 459);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						if (ZEPHIR_LT(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 0);
  						}
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 456);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						zephir_check_call_status();
  							ZEPHIR_INIT_NVAR(&_22$$9);
  							if (ZEPHIR_LT(&valueA, &valueB)) {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 1);
  							} else {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 0);
  							}
  							zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/columnvector.zep", 456);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 459);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  /**
   * Return the element-wise less than or equal to comparison of this column vector and a matrix.
   *
   * @param \Tensor\Matrix b
   * @throws \Tensor\Exceptions\DimensionalityMismatch
   * @return \Tensor\Matrix
   */
  PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
  {
  	zval _4$$3, _6$$3, _7$$3;
  	zend_string *_12;
  	zend_ulong _11;
  	zval c, rowC;
  	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
  	zephir_fcall_cache_entry *_23 = NULL;
  	zend_long ZEPHIR_LAST_CALL_STATUS;
  	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, _2$$3, _3$$3, _5$$3, _13$$4, *_14$$4, _15$$4, _16$$5, _17$$6, _18$$7, *_19$$7, _20$$7, _21$$8, _22$$9;
  	zval *this_ptr = getThis();
  
  	ZVAL_UNDEF(&b_sub);
  	ZVAL_UNDEF(&_0);
  	ZVAL_UNDEF(&_1);
  	ZVAL_UNDEF(&i);
  	ZVAL_UNDEF(&rowB);
  	ZVAL_UNDEF(&valueB);
  	ZVAL_UNDEF(&valueA);
  	ZVAL_UNDEF(&_8);
  	ZVAL_UNDEF(&_10);
  	ZVAL_UNDEF(&_2$$3);
  	ZVAL_UNDEF(&_3$$3);
  	ZVAL_UNDEF(&_5$$3);
  	ZVAL_UNDEF(&_13$$4);
  	ZVAL_UNDEF(&_15$$4);
  	ZVAL_UNDEF(&_16$$5);
  	ZVAL_UNDEF(&_17$$6);
  	ZVAL_UNDEF(&_18$$7);
  	ZVAL_UNDEF(&_20$$7);
  	ZVAL_UNDEF(&_21$$8);
  	ZVAL_UNDEF(&_22$$9);
  	ZVAL_UNDEF(&c);
  	ZVAL_UNDEF(&rowC);
  	ZVAL_UNDEF(&_4$$3);
  	ZVAL_UNDEF(&_6$$3);
  	ZVAL_UNDEF(&_7$$3);
  #if PHP_VERSION_ID >= 80000
  	bool is_null_true = 1;
  	ZEND_PARSE_PARAMETERS_START(1, 1)
  		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
  	ZEND_PARSE_PARAMETERS_END();
  #endif
  
  
  	ZEPHIR_MM_GROW();
  	zephir_fetch_params(1, 1, 0, &b);
  
  
  	zephir_read_property(&_0, this_ptr, ZEND_STRL("n"), PH_NOISY_CC | PH_READONLY);
  	ZEPHIR_CALL_METHOD(&_1, b, "m", NULL, 0);
  	zephir_check_call_status();
  	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
  		ZEPHIR_INIT_VAR(&_2$$3);
  		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
  		ZEPHIR_OBS_VAR(&_3$$3);
  		zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("n"), PH_NOISY_CC);
  		zephir_cast_to_string(&_4$$3, &_3$$3);
  		ZEPHIR_CALL_METHOD(&_5$$3, b, "m", NULL, 0);
  		zephir_check_call_status();
  		zephir_cast_to_string(&_6$$3, &_5$$3);
  		ZEPHIR_INIT_VAR(&_7$$3);
  		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " rows but Matrix 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/columnvector.zep", 477);
  		ZEPHIR_MM_RESTORE();
  		return;
  	}
  	ZEPHIR_INIT_VAR(&c);
  	array_init(&c);
  	ZEPHIR_INIT_VAR(&rowC);
  	array_init(&rowC);
  	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
  	zephir_check_call_status();
  	zephir_is_iterable(&_8, 0, "tensor/columnvector.zep", 497);
  	if (Z_TYPE_P(&_8) == IS_ARRAY) {
  		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_8), _11, _12, _9)
  		{
  			ZEPHIR_INIT_NVAR(&i);
  			if (_12 != NULL) { 
  				ZVAL_STR_COPY(&i, _12);
  			} else {
  				ZVAL_LONG(&i, _11);
  			}
  			ZEPHIR_INIT_NVAR(&rowB);
  			ZVAL_COPY(&rowB, _9);
  			zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  			ZEPHIR_OBS_NVAR(&valueA);
  			zephir_array_fetch(&valueA, &_13$$4, &i, PH_NOISY, "tensor/columnvector.zep", 486);
  			ZEPHIR_INIT_NVAR(&rowC);
  			array_init(&rowC);
  			zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 494);
  			if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _14$$4)
  				{
  					ZEPHIR_INIT_NVAR(&valueB);
  					ZVAL_COPY(&valueB, _14$$4);
  					ZEPHIR_INIT_NVAR(&_16$$5);
  					if (ZEPHIR_LE(&valueA, &valueB)) {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 1);
  					} else {
  						ZEPHIR_INIT_NVAR(&_16$$5);
  						ZVAL_LONG(&_16$$5, 0);
  					}
  					zephir_array_append(&rowC, &_16$$5, PH_SEPARATE, "tensor/columnvector.zep", 491);
  				} ZEND_HASH_FOREACH_END();
  			} else {
  				ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  				zephir_check_call_status();
  				while (1) {
  					ZEPHIR_CALL_METHOD(&_15$$4, &rowB, "valid", NULL, 0);
  					zephir_check_call_status();
  					if (!zend_is_true(&_15$$4)) {
  						break;
  					}
  					ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  					zephir_check_call_status();
  						ZEPHIR_INIT_NVAR(&_17$$6);
  						if (ZEPHIR_LE(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_17$$6);
  							ZVAL_LONG(&_17$$6, 0);
  						}
  						zephir_array_append(&rowC, &_17$$6, PH_SEPARATE, "tensor/columnvector.zep", 491);
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  					zephir_check_call_status();
  				}
  			}
  			ZEPHIR_INIT_NVAR(&valueB);
  			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 494);
  		} ZEND_HASH_FOREACH_END();
  	} else {
  		ZEPHIR_CALL_METHOD(NULL, &_8, "rewind", NULL, 0);
  		zephir_check_call_status();
  		while (1) {
  			ZEPHIR_CALL_METHOD(&_10, &_8, "valid", NULL, 0);
  			zephir_check_call_status();
  			if (!zend_is_true(&_10)) {
  				break;
  			}
  			ZEPHIR_CALL_METHOD(&i, &_8, "key", NULL, 0);
  			zephir_check_call_status();
  			ZEPHIR_CALL_METHOD(&rowB, &_8, "current", NULL, 0);
  			zephir_check_call_status();
  				zephir_read_property(&_18$$7, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY);
  				ZEPHIR_OBS_NVAR(&valueA);
  				zephir_array_fetch(&valueA, &_18$$7, &i, PH_NOISY, "tensor/columnvector.zep", 486);
  				ZEPHIR_INIT_NVAR(&rowC);
  				array_init(&rowC);
  				zephir_is_iterable(&rowB, 0, "tensor/columnvector.zep", 494);
  				if (Z_TYPE_P(&rowB) == IS_ARRAY) {
  					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&rowB), _19$$7)
  					{
  						ZEPHIR_INIT_NVAR(&valueB);
  						ZVAL_COPY(&valueB, _19$$7);
  						ZEPHIR_INIT_NVAR(&_21$$8);
  						if (ZEPHIR_LE(&valueA, &valueB)) {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 1);
  						} else {
  							ZEPHIR_INIT_NVAR(&_21$$8);
  							ZVAL_LONG(&_21$$8, 0);
  						}
  						zephir_array_append(&rowC, &_21$$8, PH_SEPARATE, "tensor/columnvector.zep", 491);
  					} ZEND_HASH_FOREACH_END();
  				} else {
  					ZEPHIR_CALL_METHOD(NULL, &rowB, "rewind", NULL, 0);
  					zephir_check_call_status();
  					while (1) {
  						ZEPHIR_CALL_METHOD(&_20$$7, &rowB, "valid", NULL, 0);
  						zephir_check_call_status();
  						if (!zend_is_true(&_20$$7)) {
  							break;
  						}
  						ZEPHIR_CALL_METHOD(&valueB, &rowB, "current", NULL, 0);
  						zephir_check_call_status();
  							ZEPHIR_INIT_NVAR(&_22$$9);
  							if (ZEPHIR_LE(&valueA, &valueB)) {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 1);
  							} else {
  								ZEPHIR_INIT_NVAR(&_22$$9);
  								ZVAL_LONG(&_22$$9, 0);
  							}
  							zephir_array_append(&rowC, &_22$$9, PH_SEPARATE, "tensor/columnvector.zep", 491);
  						ZEPHIR_CALL_METHOD(NULL, &rowB, "next", NULL, 0);
  						zephir_check_call_status();
  					}
  				}
  				ZEPHIR_INIT_NVAR(&valueB);
  				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 494);
  			ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0);
  			zephir_check_call_status();
  		}
  	}
  	ZEPHIR_INIT_NVAR(&rowB);
  	ZEPHIR_INIT_NVAR(&i);
  	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", &_23, 0, &c);
  	zephir_check_call_status();
  	RETURN_MM();
  }
  
  