From bea38e8d26e64aa81f88be2b9616f99e7c569dd9 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Sat, 19 Sep 2026 12:21:01 -0500
Subject: [PATCH 01/51] Initial commit

---
 composer.json | 2 +-
 config.json   | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/composer.json b/composer.json
index c5f9c9a..f817200 100644
--- a/composer.json
+++ b/composer.json
@@ -27,7 +27,7 @@
     },
     "require-dev": {
         "friendsofphp/php-cs-fixer": "^3.0",
-        "phalcon/zephir": "^1.0",
+        "phalcon/zephir": "dev-development",
         "phpbench/phpbench": "^1.0",
         "phpstan/extension-installer": "^1.0",
         "phpstan/phpstan": "^1.0",
diff --git a/config.json b/config.json
index e70a270..c93092d 100644
--- a/config.json
+++ b/config.json
@@ -49,5 +49,8 @@
     "extra": {
         "export-classes": false,
         "indent": "spaces"
+    },
+    "kernel-classes": {
+        "buffer": true
     }
 }

From 5908b98bb785385ac01a265e7744dd7ca8b1851b Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Sat, 19 Sep 2026 13:40:44 -0500
Subject: [PATCH 02/51] Save game

---
 ext/config.m4                            |  24 +-
 ext/config.w32                           |   2 +-
 ext/kernel/array.c                       |  41 +
 ext/kernel/buffer.c                      | 905 +++++++++++++++++++++++
 ext/kernel/buffer.h                      | 134 ++++
 ext/kernel/fcall.c                       |  33 +-
 ext/kernel/fcall.h                       |  44 +-
 ext/kernel/main.c                        |   2 +
 ext/php_tensor.h                         |   3 +
 ext/tensor/columnvector.zep.c            |  52 +-
 ext/tensor/decompositions/cholesky.zep.c |  10 +-
 ext/tensor/decompositions/eigen.zep.c    |  12 +-
 ext/tensor/decompositions/lu.zep.c       |  14 +-
 ext/tensor/decompositions/svd.zep.c      |   8 +-
 ext/tensor/matrix.zep.c                  | 362 ++++-----
 ext/tensor/reductions/ref.zep.c          |   6 +-
 ext/tensor/reductions/rref.zep.c         |   6 +-
 ext/tensor/vector.zep.c                  | 194 ++---
 18 files changed, 1477 insertions(+), 375 deletions(-)
 create mode 100644 ext/kernel/buffer.c
 create mode 100644 ext/kernel/buffer.h

diff --git a/ext/config.m4 b/ext/config.m4
index 96f4d7a..f66b680 100644
--- a/ext/config.m4
+++ b/ext/config.m4
@@ -9,7 +9,7 @@ if test "$PHP_TENSOR" = "yes"; then
 	fi
 
 	AC_DEFINE(HAVE_TENSOR, 1, [Whether you have Tensor])
-	tensor_sources="tensor.c kernel/main.c kernel/memory.c kernel/exception.c kernel/debug.c kernel/backtrace.c kernel/object.c kernel/array.c kernel/string.c kernel/fcall.c kernel/require.c kernel/file.c kernel/operators.c kernel/math.c kernel/concat.c kernel/variables.c kernel/filter.c kernel/iterator.c kernel/time.c kernel/exit.c kernel/generator.c tensor/algebraic.zep.c
+	tensor_sources="tensor.c kernel/main.c kernel/memory.c kernel/exception.c kernel/debug.c kernel/backtrace.c kernel/object.c kernel/array.c kernel/string.c kernel/fcall.c kernel/require.c kernel/file.c kernel/operators.c kernel/math.c kernel/concat.c kernel/variables.c kernel/filter.c kernel/iterator.c kernel/time.c kernel/exit.c kernel/generator.c kernel/buffer.c tensor/algebraic.zep.c
 	tensor/arithmetic.zep.c
 	tensor/arraylike.zep.c
 	tensor/comparable.zep.c
@@ -74,21 +74,19 @@ if test "$PHP_TENSOR" = "yes"; then
 		[[#include "php_config.h"]]
 	)
 
-	AC_CHECK_DECL(
-		[HAVE_JSON],
+	dnl php-src stopped declaring HAVE_JSON in php_config.h in 8.4, so probing
+	dnl for it left ZEPHIR_USE_PHP_JSON undefined on 8.4 and 8.5 even though
+	dnl ext/json has been built in unconditionally since 8.0 -- which quietly
+	dnl demoted zephir_json_encode() to calling the userland json_encode()
+	dnl function. Probe for the header, which is what the code actually needs.
+	AC_CHECK_HEADERS(
+		[ext/json/php_json.h],
 		[
-			AC_CHECK_HEADERS(
-				[ext/json/php_json.h],
-				[
-					PHP_ADD_EXTENSION_DEP([tensor], [json])
-					AC_DEFINE([ZEPHIR_USE_PHP_JSON], [1], [Whether PHP json extension is present at compile time])
-				],
-				,
-				[[#include "main/php.h"]]
-			)
+			PHP_ADD_EXTENSION_DEP([tensor], [json])
+			AC_DEFINE([ZEPHIR_USE_PHP_JSON], [1], [Whether PHP json extension is present at compile time])
 		],
 		,
-		[[#include "php_config.h"]]
+		[[#include "main/php.h"]]
 	)
 
 	CPPFLAGS=$old_CPPFLAGS
diff --git a/ext/config.w32 b/ext/config.w32
index fc4ecb6..6d03289 100644
--- a/ext/config.w32
+++ b/ext/config.w32
@@ -6,7 +6,7 @@ if (PHP_TENSOR != "no") {
     ERROR("tensor requires OpenBLAS libraries and headers");
   }
   EXTENSION("tensor", "tensor.c", null, "-I"+configure_module_dirname);
-  ADD_SOURCES(configure_module_dirname + "/kernel", "main.c memory.c exception.c debug.c backtrace.c object.c array.c string.c fcall.c require.c file.c operators.c math.c concat.c variables.c filter.c iterator.c exit.c time.c generator.c", "tensor");
+  ADD_SOURCES(configure_module_dirname + "/kernel", "main.c memory.c exception.c debug.c backtrace.c object.c array.c string.c fcall.c require.c file.c operators.c math.c concat.c variables.c filter.c iterator.c exit.c time.c generator.c buffer.c", "tensor");
   /* PCRE is always included on WIN32 */
   AC_DEFINE("ZEPHIR_USE_PHP_PCRE", 1, "Whether PHP pcre extension is present at compile time");
   if (PHP_JSON != "no") {
diff --git a/ext/kernel/array.c b/ext/kernel/array.c
index bac163a..9ac93ff 100644
--- a/ext/kernel/array.c
+++ b/ext/kernel/array.c
@@ -24,6 +24,7 @@
 #include "kernel/memory.h"
 #include "kernel/debug.h"
 #include "kernel/array.h"
+#include "kernel/buffer.h"
 #include "kernel/operators.h"
 #include "kernel/backtrace.h"
 #include "kernel/object.h"
@@ -464,6 +465,12 @@ int ZEPHIR_FASTCALL zephir_array_isset(const zval *arr, zval *index)
 		return 0;
 	}
 
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr))) {
+		return zephir_buffer_dim_isset(arr, index);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev((zval *)arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		zval container, exist;
@@ -555,6 +562,12 @@ int ZEPHIR_FASTCALL zephir_array_isset_string(const zval *arr, const char *index
 
 int ZEPHIR_FASTCALL zephir_array_isset_long(const zval *arr, zend_long index)
 {
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr))) {
+		return zephir_buffer_dim_isset_long(arr, index);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev((zval *)arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		zval container, exist, offset;
@@ -938,6 +951,12 @@ int zephir_array_fetch(zval *return_value, zval *arr, zval *index, int flags ZEP
 		arr = zephir_array_write_container(arr);
 	}
 
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr)) && (flags & PH_WRITE) != PH_WRITE) {
+		return zephir_buffer_dim_read(return_value, arr, index);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev(arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		ZEPHIR_CALL_METHOD_WITHOUT_OBSERVE(return_value, arr, "offsetget", NULL, 0, index);
@@ -1097,6 +1116,16 @@ int zephir_array_fetch_long(zval *return_value, zval *arr, zend_long index, int
 		arr = zephir_array_write_container(arr);
 	}
 
+#ifdef ZEPHIR_BUFFER_ENABLED
+	/* A <Ns>\Buffer element is a raw C scalar: one class-entry pointer compare
+	 * and a direct load, instead of an offsetGet() call. A write-context fetch
+	 * deliberately falls through to the ArrayAccess path below, so the engine
+	 * still reports the element as unmodifiable. */
+	if (UNEXPECTED(zephir_is_buffer(arr)) && (flags & PH_WRITE) != PH_WRITE) {
+		return zephir_buffer_dim_read_long(return_value, arr, index);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev(arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		zval offset;
@@ -1179,6 +1208,12 @@ int zephir_array_update_zval(zval *arr, zval *index, zval *value, int flags)
 	HashTable *ht;
 	zval *ret = NULL;
 
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr))) {
+		return zephir_buffer_dim_write(arr, index, value);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev(arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		ZEPHIR_CALL_METHOD_WITHOUT_OBSERVE(NULL, arr, "offsetset", NULL, 0, index, value);
@@ -1287,6 +1322,12 @@ int zephir_array_update_string(zval *arr, const char *index, uint32_t index_leng
 
 int zephir_array_update_long(zval *arr, zend_long index, zval *value, int flags ZEPHIR_DEBUG_PARAMS)
 {
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr))) {
+		return zephir_buffer_dim_write_long(arr, index, value);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev(arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		zval offset;
diff --git a/ext/kernel/buffer.c b/ext/kernel/buffer.c
new file mode 100644
index 0000000..3962641
--- /dev/null
+++ b/ext/kernel/buffer.c
@@ -0,0 +1,905 @@
+/**
+ * This file is part of the Zephir.
+ *
+ * (c) Phalcon Team <team@zephir-lang.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code. If you did not receive
+ * a copy of the license it is available through the world-wide-web at the
+ * following url: https://docs.zephir-lang.com/en/latest/license
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php_ext.h"
+#include "kernel/buffer.h"
+
+#ifndef ZEPHIR_BUFFER_ENABLED
+
+/* The project did not opt in: the class is compiled out and MINIT
+ * registration is a no-op. */
+void zephir_buffer_module_init(void) {}
+
+#else
+
+#ifndef ZEPHIR_BUFFER_NAMESPACE
+#error "ZEPHIR_BUFFER_NAMESPACE must be defined together with ZEPHIR_BUFFER_ENABLED"
+#endif
+
+#include <Zend/zend_exceptions.h>
+#include <Zend/zend_interfaces.h>
+#include <ext/spl/spl_array.h>
+#include <ext/spl/spl_exceptions.h>
+
+/* Unconditional on purpose. ext/json cannot be disabled in PHP 8, and gating
+ * JsonSerializable on a build-time probe would mean json_encode() silently
+ * emitting `{}` and dropping every element wherever the probe happened to
+ * fail. kernel/string.c's ZEPHIR_USE_PHP_JSON gate is about an optional
+ * *optimisation*; this is about not losing data. */
+#include <ext/json/php_json.h>
+
+/* zend_object_count_elements_t returned `int` up to PHP 8.1 and `zend_result`
+ * from 8.2. The two are different types, so the handler has to be declared
+ * with whichever one this build expects. */
+#if PHP_VERSION_ID >= 80200
+# define ZEPHIR_BUFFER_COUNT_RESULT zend_result
+#else
+# define ZEPHIR_BUFFER_COUNT_RESULT int
+#endif
+
+zend_class_entry *zephir_buffer_ce;
+
+static zend_object_handlers zephir_buffer_object_handlers;
+
+/* ---------------------------------------------------------------- storage */
+
+static zend_always_inline size_t zephir_buffer_elem_size(uint8_t kind)
+{
+	return kind == ZEPHIR_BUFFER_LONG ? sizeof(zend_long) : sizeof(double);
+}
+
+static zend_always_inline int zephir_buffer_kind_is_valid(uint8_t kind)
+{
+	return kind == ZEPHIR_BUFFER_DOUBLE || kind == ZEPHIR_BUFFER_LONG;
+}
+
+/**
+ * (Re)allocates the element array, zero-filled.
+ *
+ * All-bits-zero is 0.0 for an IEEE 754 double and 0 for a zend_long, so one
+ * ecalloc covers both kinds.
+ */
+static int zephir_buffer_alloc(zephir_buffer_object *b, zend_long len, uint8_t kind)
+{
+	if (b->data.raw) {
+		efree(b->data.raw);
+		b->data.raw = NULL;
+	}
+
+	b->kind = kind;
+	b->len  = len;
+
+	if (len > 0) {
+		b->data.raw = ecalloc((size_t) len, zephir_buffer_elem_size(kind));
+	}
+
+	return SUCCESS;
+}
+
+static zend_always_inline void zephir_buffer_get(const zephir_buffer_object *b, zend_long index, zval *rv)
+{
+	if (b->kind == ZEPHIR_BUFFER_LONG) {
+		ZVAL_LONG(rv, b->data.l[index]);
+	} else {
+		ZVAL_DOUBLE(rv, b->data.d[index]);
+	}
+}
+
+/**
+ * Stores `value` at `index`, converted with the engine's own cast, so an
+ * element ends up holding exactly what `(float)` / `(int)` would have produced.
+ */
+static zend_always_inline void zephir_buffer_put(zephir_buffer_object *b, zend_long index, zval *value)
+{
+	if (b->kind == ZEPHIR_BUFFER_LONG) {
+		b->data.l[index] = zval_get_long(value);
+	} else {
+		b->data.d[index] = zval_get_double(value);
+	}
+}
+
+static zend_always_inline int zephir_buffer_in_range(const zephir_buffer_object *b, zend_long index)
+{
+	/* One compare: a negative index wraps to a huge unsigned value. */
+	return (zend_ulong) index < (zend_ulong) b->len;
+}
+
+/* ------------------------------------------------------------- diagnostics */
+
+/**
+ * php-src moved this from RuntimeException to OutOfBoundsException in 8.4
+ * (OutOfBoundsException extends RuntimeException, so catching the older one
+ * still works). Follow it, so a Buffer raises on each version whatever
+ * SplFixedArray raises there.
+ */
+static ZEND_COLD void zephir_buffer_throw_out_of_range(void)
+{
+#if PHP_VERSION_ID >= 80400
+	zend_throw_exception(spl_ce_OutOfBoundsException, "Index invalid or out of range", 0);
+#else
+	zend_throw_exception(spl_ce_RuntimeException, "Index invalid or out of range", 0);
+#endif
+}
+
+/**
+ * Converts an arbitrary offset zval to an index, following php-src's own
+ * spl_offset_convert_to_long() -- including the three regimes its failure
+ * branch went through:
+ *
+ *   8.0        no type check at all; an unusable offset became -1 and was
+ *              reported by the range check
+ *   8.1, 8.2   TypeError, "Illegal offset type"
+ *   8.3+       TypeError naming the container and the offset type
+ *
+ * On failure from 8.1 up an exception is pending, so callers must check
+ * EG(exception) before using the result. php-src reports BP_VAR_R here even
+ * from isset(), so do the same rather than varying the message by context.
+ */
+static zend_long zephir_buffer_offset_to_long(zval *offset)
+{
+	zend_ulong idx;
+
+try_again:
+	switch (Z_TYPE_P(offset)) {
+		case IS_STRING:
+			if (ZEND_HANDLE_NUMERIC(Z_STR_P(offset), idx)) {
+				return (zend_long) idx;
+			}
+			break;
+
+		case IS_DOUBLE:
+#if PHP_VERSION_ID >= 80100
+			return zend_dval_to_lval_safe(Z_DVAL_P(offset));
+#else
+			return zend_dval_to_lval(Z_DVAL_P(offset));
+#endif
+
+		case IS_LONG:
+			return Z_LVAL_P(offset);
+
+		case IS_FALSE:
+			return 0;
+
+		case IS_TRUE:
+			return 1;
+
+		case IS_REFERENCE:
+			offset = Z_REFVAL_P(offset);
+			goto try_again;
+
+		case IS_RESOURCE:
+#if PHP_VERSION_ID >= 80100
+			zend_use_resource_as_offset(offset);
+#endif
+			return Z_RES_HANDLE_P(offset);
+	}
+
+#if PHP_VERSION_ID >= 80300
+	zend_illegal_container_offset(zephir_buffer_ce->name, offset, BP_VAR_R);
+	return 0;
+#elif PHP_VERSION_ID >= 80100
+	zend_type_error("Illegal offset type");
+	return 0;
+#else
+	return -1;
+#endif
+}
+
+/**
+ * Resolves an offset to an in-range index, or returns FAILURE with an
+ * exception pending.
+ */
+static int zephir_buffer_resolve(const zephir_buffer_object *b, zval *offset, zend_long *index)
+{
+	zend_long resolved = zephir_buffer_offset_to_long(offset);
+
+	if (EG(exception)) {
+		return FAILURE;
+	}
+
+	if (!zephir_buffer_in_range(b, resolved)) {
+		zephir_buffer_throw_out_of_range();
+		return FAILURE;
+	}
+
+	*index = resolved;
+
+	return SUCCESS;
+}
+
+/* ----------------------------------------------------------------- object */
+
+static zend_object *zephir_buffer_create_object(zend_class_entry *ce)
+{
+	zephir_buffer_object *b = zend_object_alloc(sizeof(zephir_buffer_object), ce);
+
+	b->data.raw = NULL;
+	b->len      = 0;
+	b->kind     = ZEPHIR_BUFFER_DOUBLE;
+
+	zend_object_std_init(&b->std, ce);
+	object_properties_init(&b->std, ce);
+	b->std.handlers = &zephir_buffer_object_handlers;
+
+	return &b->std;
+}
+
+static void zephir_buffer_free_object(zend_object *object)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+
+	if (b->data.raw) {
+		efree(b->data.raw);
+		b->data.raw = NULL;
+	}
+
+	zend_object_std_dtor(&b->std);
+}
+
+static zend_object *zephir_buffer_clone_object(zend_object *object)
+{
+	zephir_buffer_object *source = zephir_buffer_fetch(object);
+	zend_object          *cloned = zephir_buffer_create_object(object->ce);
+	zephir_buffer_object *copy   = zephir_buffer_fetch(cloned);
+
+	copy->kind = source->kind;
+	copy->len  = source->len;
+
+	if (source->len > 0) {
+		size_t bytes = (size_t) source->len * zephir_buffer_elem_size(source->kind);
+
+		copy->data.raw = emalloc(bytes);
+		memcpy(copy->data.raw, source->data.raw, bytes);
+	}
+
+	zend_objects_clone_members(cloned, object);
+
+	return cloned;
+}
+
+/* Without this var_dump()/print_r() would show an object with no state at all,
+ * because the elements are not properties. */
+static HashTable *zephir_buffer_get_debug_info(zend_object *object, int *is_temp)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	HashTable            *info;
+	zend_long             i;
+
+	ALLOC_HASHTABLE(info);
+	zend_hash_init(info, (uint32_t) (b->len > 0 ? b->len : 0), NULL, ZVAL_PTR_DTOR, 0);
+
+	for (i = 0; i < b->len; ++i) {
+		zval element;
+
+		zephir_buffer_get(b, i, &element);
+		zend_hash_index_update(info, (zend_ulong) i, &element);
+	}
+
+	*is_temp = 1;
+
+	return info;
+}
+
+static ZEPHIR_BUFFER_COUNT_RESULT zephir_buffer_count_elements(zend_object *object, zend_long *count)
+{
+	*count = zephir_buffer_fetch(object)->len;
+
+	return SUCCESS;
+}
+
+/* ------------------------------------------------------------- dimensions */
+
+static int zephir_buffer_has_dimension(zend_object *object, zval *offset, int check_empty);
+
+/**
+ * `$buffer[$i]`.
+ *
+ * The value is returned in `rv`, never as a pointer into the buffer -- the
+ * elements are raw C scalars, not zvals, so there is nothing to point at. In a
+ * write context (`$buffer[0] += 1`, `$r =& $buffer[0]`) the engine therefore
+ * raises its standard "Indirect modification of overloaded element" notice and
+ * the write is dropped, exactly as it does for any ArrayAccess object that
+ * does not hand back a reference.
+ */
+static zval *zephir_buffer_read_dimension(zend_object *object, zval *offset, int type, zval *rv)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	zend_long             index;
+
+	/* `$buffer[$i] ?? $default` must not raise for a merely absent index --
+	 * but an offset of an unusable *type* still does, as it does for
+	 * SplFixedArray. */
+	if (type == BP_VAR_IS && !zephir_buffer_has_dimension(object, offset, 0)) {
+		return &EG(uninitialized_zval);
+	}
+
+	if (!offset) {
+		zend_throw_error(NULL, "Cannot use [] for reading");
+		return NULL;
+	}
+
+	if (zephir_buffer_resolve(b, offset, &index) == FAILURE) {
+		return NULL;
+	}
+
+	zephir_buffer_get(b, index, rv);
+
+	return rv;
+}
+
+static void zephir_buffer_write_dimension(zend_object *object, zval *offset, zval *value)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	zend_long             index;
+
+	if (!offset) {
+		/* `$buffer[] = v`. A Buffer is fixed-size, so there is nothing to
+		 * append to. php-src changed SplFixedArray's report here in 8.1. */
+#if PHP_VERSION_ID >= 80100
+		zend_throw_error(NULL, "[] operator not supported for %s", ZSTR_VAL(object->ce->name));
+#else
+		zephir_buffer_throw_out_of_range();
+#endif
+		return;
+	}
+
+	if (zephir_buffer_resolve(b, offset, &index) == FAILURE) {
+		return;
+	}
+
+	zephir_buffer_put(b, index, value);
+}
+
+static int zephir_buffer_has_dimension(zend_object *object, zval *offset, int check_empty)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	zend_long             index;
+	zval                  element;
+
+	index = zephir_buffer_offset_to_long(offset);
+
+	if (EG(exception)) {
+		return 0;
+	}
+
+	if (!zephir_buffer_in_range(b, index)) {
+		return 0;
+	}
+
+	/* Every in-range element is set. A Buffer holds numbers, so unlike
+	 * SplFixedArray -- whose slots start out null, and where isset() is
+	 * therefore false on a freshly constructed one -- there is no element
+	 * value that isset() reports as absent. */
+	if (!check_empty) {
+		return 1;
+	}
+
+	zephir_buffer_get(b, index, &element);
+
+	return zend_is_true(&element);
+}
+
+/* A numeric buffer cannot hold null, so unset() writes the zero element. */
+static void zephir_buffer_unset_dimension(zend_object *object, zval *offset)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	zend_long             index;
+
+	if (zephir_buffer_resolve(b, offset, &index) == FAILURE) {
+		return;
+	}
+
+	if (b->kind == ZEPHIR_BUFFER_LONG) {
+		b->data.l[index] = 0;
+	} else {
+		b->data.d[index] = 0.0;
+	}
+}
+
+/* -------------------------------------------------------------- C-side API */
+
+int zephir_buffer_create(zval *ret, zend_long len, uint8_t kind)
+{
+	zephir_buffer_object *b;
+
+	if (!zephir_buffer_kind_is_valid(kind) || len < 0) {
+		ZVAL_NULL(ret);
+
+		return FAILURE;
+	}
+
+	object_init_ex(ret, zephir_buffer_ce);
+	b = ZEPHIR_BUFFER_P(ret);
+
+	return zephir_buffer_alloc(b, len, kind);
+}
+
+int zephir_buffer_create_from_array(zval *ret, zval *arr, uint8_t kind)
+{
+	zephir_buffer_object *b;
+	zval                 *value;
+	zend_long             i = 0;
+
+	if (Z_TYPE_P(arr) != IS_ARRAY) {
+		ZVAL_NULL(ret);
+
+		return FAILURE;
+	}
+
+	if (zephir_buffer_create(ret, (zend_long) zend_hash_num_elements(Z_ARRVAL_P(arr)), kind) == FAILURE) {
+		return FAILURE;
+	}
+
+	b = ZEPHIR_BUFFER_P(ret);
+
+	/* Positional: the keys of the source array are discarded, the values are
+	 * taken in iteration order. */
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arr), value) {
+		zephir_buffer_put(b, i++, value);
+	} ZEND_HASH_FOREACH_END();
+
+	return SUCCESS;
+}
+
+int zephir_buffer_to_array(zval *ret, const zval *obj)
+{
+	zephir_buffer_object *b;
+	zend_long             i;
+
+	if (!zephir_is_buffer(obj)) {
+		ZVAL_NULL(ret);
+
+		return FAILURE;
+	}
+
+	b = ZEPHIR_BUFFER_P((zval *) obj);
+
+	array_init_size(ret, (uint32_t) (b->len > 0 ? b->len : 0));
+
+	for (i = 0; i < b->len; ++i) {
+		if (b->kind == ZEPHIR_BUFFER_LONG) {
+			add_next_index_long(ret, b->data.l[i]);
+		} else {
+			add_next_index_double(ret, b->data.d[i]);
+		}
+	}
+
+	return SUCCESS;
+}
+
+uint8_t zephir_buffer_kind(const zval *obj)
+{
+	return zephir_is_buffer(obj) ? ZEPHIR_BUFFER_P((zval *) obj)->kind : 0;
+}
+
+zend_long zephir_buffer_len(const zval *obj)
+{
+	return zephir_is_buffer(obj) ? ZEPHIR_BUFFER_P((zval *) obj)->len : 0;
+}
+
+double *zephir_buffer_doubles(const zval *obj)
+{
+	zephir_buffer_object *b;
+
+	if (!zephir_is_buffer(obj)) {
+		return NULL;
+	}
+
+	b = ZEPHIR_BUFFER_P((zval *) obj);
+
+	return b->kind == ZEPHIR_BUFFER_DOUBLE ? b->data.d : NULL;
+}
+
+zend_long *zephir_buffer_longs(const zval *obj)
+{
+	zephir_buffer_object *b;
+
+	if (!zephir_is_buffer(obj)) {
+		return NULL;
+	}
+
+	b = ZEPHIR_BUFFER_P((zval *) obj);
+
+	return b->kind == ZEPHIR_BUFFER_LONG ? b->data.l : NULL;
+}
+
+/* ------------------------------------------------ kernel/array.c fast paths */
+
+int zephir_buffer_dim_read_long(zval *return_value, zval *obj, zend_long index)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(obj);
+
+	if (UNEXPECTED(!zephir_buffer_in_range(b, index))) {
+		zephir_buffer_throw_out_of_range();
+		ZVAL_NULL(return_value);
+
+		return FAILURE;
+	}
+
+	zephir_buffer_get(b, index, return_value);
+
+	return SUCCESS;
+}
+
+int zephir_buffer_dim_read(zval *return_value, zval *obj, zval *offset)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(obj);
+	zend_long             index;
+
+	if (UNEXPECTED(zephir_buffer_resolve(b, offset, &index) == FAILURE)) {
+		ZVAL_NULL(return_value);
+
+		return FAILURE;
+	}
+
+	zephir_buffer_get(b, index, return_value);
+
+	return SUCCESS;
+}
+
+int zephir_buffer_dim_write_long(zval *obj, zend_long index, zval *value)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(obj);
+
+	if (UNEXPECTED(!zephir_buffer_in_range(b, index))) {
+		zephir_buffer_throw_out_of_range();
+
+		return FAILURE;
+	}
+
+	zephir_buffer_put(b, index, value);
+
+	return SUCCESS;
+}
+
+int zephir_buffer_dim_write(zval *obj, zval *offset, zval *value)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(obj);
+	zend_long             index;
+
+	if (UNEXPECTED(zephir_buffer_resolve(b, offset, &index) == FAILURE)) {
+		return FAILURE;
+	}
+
+	zephir_buffer_put(b, index, value);
+
+	return SUCCESS;
+}
+
+int zephir_buffer_dim_isset_long(const zval *obj, zend_long index)
+{
+	return zephir_buffer_in_range(ZEPHIR_BUFFER_P((zval *) obj), index);
+}
+
+int zephir_buffer_dim_isset(const zval *obj, zval *offset)
+{
+	return zephir_buffer_has_dimension(Z_OBJ_P((zval *) obj), offset, 0);
+}
+
+/* ---------------------------------------------------------------- methods */
+
+PHP_METHOD(ZephirBuffer, __construct)
+{
+	zephir_buffer_object *b    = ZEPHIR_BUFFER_P(getThis());
+	zend_long             size;
+	zend_long             type = ZEPHIR_BUFFER_DOUBLE;
+
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		Z_PARAM_LONG(size)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_LONG(type)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (size < 0) {
+		zend_argument_value_error(1, "must be greater than or equal to 0");
+		RETURN_THROWS();
+	}
+
+	if (!zephir_buffer_kind_is_valid((uint8_t) type)) {
+		zend_argument_value_error(2, "must be Buffer::TYPE_DOUBLE or Buffer::TYPE_LONG");
+		RETURN_THROWS();
+	}
+
+	zephir_buffer_alloc(b, size, (uint8_t) type);
+}
+
+PHP_METHOD(ZephirBuffer, fromArray)
+{
+	zval      *values;
+	zend_long  type = ZEPHIR_BUFFER_DOUBLE;
+
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		Z_PARAM_ARRAY(values)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_LONG(type)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (!zephir_buffer_kind_is_valid((uint8_t) type)) {
+		zend_argument_value_error(2, "must be Buffer::TYPE_DOUBLE or Buffer::TYPE_LONG");
+		RETURN_THROWS();
+	}
+
+	zephir_buffer_create_from_array(return_value, values, (uint8_t) type);
+}
+
+PHP_METHOD(ZephirBuffer, toArray)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zephir_buffer_to_array(return_value, getThis());
+}
+
+PHP_METHOD(ZephirBuffer, type)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	RETURN_LONG(ZEPHIR_BUFFER_P(getThis())->kind);
+}
+
+PHP_METHOD(ZephirBuffer, count)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	RETURN_LONG(ZEPHIR_BUFFER_P(getThis())->len);
+}
+
+PHP_METHOD(ZephirBuffer, fill)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(getThis());
+	zval                 *value;
+	zend_long             i;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(value)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (b->kind == ZEPHIR_BUFFER_LONG) {
+		zend_long converted = zval_get_long(value);
+
+		for (i = 0; i < b->len; ++i) {
+			b->data.l[i] = converted;
+		}
+	} else {
+		double converted = zval_get_double(value);
+
+		for (i = 0; i < b->len; ++i) {
+			b->data.d[i] = converted;
+		}
+	}
+}
+
+PHP_METHOD(ZephirBuffer, offsetExists)
+{
+	zval *offset;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(offset)
+	ZEND_PARSE_PARAMETERS_END();
+
+	RETURN_BOOL(zephir_buffer_has_dimension(Z_OBJ_P(getThis()), offset, 0));
+}
+
+PHP_METHOD(ZephirBuffer, offsetGet)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(getThis());
+	zval                 *offset;
+	zend_long             index;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(offset)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (zephir_buffer_resolve(b, offset, &index) == FAILURE) {
+		RETURN_THROWS();
+	}
+
+	zephir_buffer_get(b, index, return_value);
+}
+
+PHP_METHOD(ZephirBuffer, offsetSet)
+{
+	zval *offset;
+	zval *value;
+
+	ZEND_PARSE_PARAMETERS_START(2, 2)
+		Z_PARAM_ZVAL(offset)
+		Z_PARAM_ZVAL(value)
+	ZEND_PARSE_PARAMETERS_END();
+
+	zephir_buffer_write_dimension(Z_OBJ_P(getThis()), offset, value);
+}
+
+PHP_METHOD(ZephirBuffer, offsetUnset)
+{
+	zval *offset;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(offset)
+	ZEND_PARSE_PARAMETERS_END();
+
+	zephir_buffer_unset_dimension(Z_OBJ_P(getThis()), offset);
+}
+
+/**
+ * foreach materialises the elements. A Buffer exists so that hot loops happen
+ * in C over the raw pointer; iterating one element at a time through the VM is
+ * the slow path by definition, so it is not worth a lazy iterator.
+ */
+PHP_METHOD(ZephirBuffer, getIterator)
+{
+	zval elements;
+
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zephir_buffer_to_array(&elements, getThis());
+
+	object_init_ex(return_value, spl_ce_ArrayIterator);
+	zend_call_method_with_1_params(
+		Z_OBJ_P(return_value), spl_ce_ArrayIterator, NULL, "__construct", NULL, &elements);
+
+	zval_ptr_dtor(&elements);
+}
+
+/* Without this json_encode() would serialise an object with no properties as
+ * `{}` and drop every element. */
+PHP_METHOD(ZephirBuffer, jsonSerialize)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zephir_buffer_to_array(return_value, getThis());
+}
+
+PHP_METHOD(ZephirBuffer, __serialize)
+{
+	zval elements;
+
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zephir_buffer_to_array(&elements, getThis());
+
+	array_init_size(return_value, 2);
+	add_next_index_long(return_value, ZEPHIR_BUFFER_P(getThis())->kind);
+	add_next_index_zval(return_value, &elements);
+}
+
+PHP_METHOD(ZephirBuffer, __unserialize)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(getThis());
+	zval                 *payload;
+	zval                 *kind;
+	zval                 *elements;
+	zval                 *value;
+	zend_long             i = 0;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ARRAY(payload)
+	ZEND_PARSE_PARAMETERS_END();
+
+	kind     = zend_hash_index_find(Z_ARRVAL_P(payload), 0);
+	elements = zend_hash_index_find(Z_ARRVAL_P(payload), 1);
+
+	if (!kind || Z_TYPE_P(kind) != IS_LONG || !elements || Z_TYPE_P(elements) != IS_ARRAY
+		|| !zephir_buffer_kind_is_valid((uint8_t) Z_LVAL_P(kind))) {
+		zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object",
+			ZSTR_VAL(zephir_buffer_ce->name));
+		RETURN_THROWS();
+	}
+
+	zephir_buffer_alloc(b, (zend_long) zend_hash_num_elements(Z_ARRVAL_P(elements)),
+		(uint8_t) Z_LVAL_P(kind));
+
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(elements), value) {
+		zephir_buffer_put(b, i++, value);
+	} ZEND_HASH_FOREACH_END();
+}
+
+/* ------------------------------------------------------------- class init */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_zephir_buffer_construct, 0, 0, 1)
+	ZEND_ARG_TYPE_INFO(0, size, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, type, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_zephir_buffer_from_array, 0, 0, 1)
+	ZEND_ARG_TYPE_INFO(0, values, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, type, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_to_array, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_long, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_fill, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_offset_exists, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_offset_get, 0, 1, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_offset_set, 0, 2, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_offset_unset, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_zephir_buffer_get_iterator, 0, 0, Traversable, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_json_serialize, 0, 0, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_serialize, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_unserialize, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, data, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+static const zend_function_entry zephir_buffer_methods[] = {
+	PHP_ME(ZephirBuffer, __construct,   arginfo_zephir_buffer_construct,      ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
+	PHP_ME(ZephirBuffer, fromArray,     arginfo_zephir_buffer_from_array,     ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+	PHP_ME(ZephirBuffer, toArray,       arginfo_zephir_buffer_to_array,       ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, type,          arginfo_zephir_buffer_long,           ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, count,         arginfo_zephir_buffer_long,           ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, fill,          arginfo_zephir_buffer_fill,           ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, offsetExists,  arginfo_zephir_buffer_offset_exists,  ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, offsetGet,     arginfo_zephir_buffer_offset_get,     ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, offsetSet,     arginfo_zephir_buffer_offset_set,     ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, offsetUnset,   arginfo_zephir_buffer_offset_unset,   ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, getIterator,   arginfo_zephir_buffer_get_iterator,   ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, jsonSerialize, arginfo_zephir_buffer_json_serialize, ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, __serialize,   arginfo_zephir_buffer_serialize,      ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, __unserialize, arginfo_zephir_buffer_unserialize,    ZEND_ACC_PUBLIC)
+	PHP_FE_END
+};
+
+void zephir_buffer_module_init(void)
+{
+	zend_class_entry ce;
+
+	INIT_NS_CLASS_ENTRY(ce, ZEPHIR_BUFFER_NAMESPACE, "Buffer", zephir_buffer_methods);
+	zephir_buffer_ce = zend_register_internal_class(&ce);
+	zephir_buffer_ce->ce_flags |= ZEND_ACC_FINAL | ZEND_ACC_NO_DYNAMIC_PROPERTIES;
+	zephir_buffer_ce->create_object = zephir_buffer_create_object;
+
+	zend_declare_class_constant_long(zephir_buffer_ce, ZEND_STRL("TYPE_DOUBLE"), ZEPHIR_BUFFER_DOUBLE);
+	zend_declare_class_constant_long(zephir_buffer_ce, ZEND_STRL("TYPE_LONG"), ZEPHIR_BUFFER_LONG);
+
+	memcpy(&zephir_buffer_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+	zephir_buffer_object_handlers.offset           = XtOffsetOf(zephir_buffer_object, std);
+	zephir_buffer_object_handlers.free_obj         = zephir_buffer_free_object;
+	zephir_buffer_object_handlers.clone_obj        = zephir_buffer_clone_object;
+	zephir_buffer_object_handlers.get_debug_info   = zephir_buffer_get_debug_info;
+	zephir_buffer_object_handlers.count_elements   = zephir_buffer_count_elements;
+	zephir_buffer_object_handlers.read_dimension   = zephir_buffer_read_dimension;
+	zephir_buffer_object_handlers.write_dimension  = zephir_buffer_write_dimension;
+	zephir_buffer_object_handlers.has_dimension    = zephir_buffer_has_dimension;
+	zephir_buffer_object_handlers.unset_dimension  = zephir_buffer_unset_dimension;
+
+	zend_class_implements(zephir_buffer_ce, 4,
+		zend_ce_arrayaccess, zend_ce_countable, zend_ce_aggregate, php_json_serializable_ce);
+}
+
+#endif /* ZEPHIR_BUFFER_ENABLED */
diff --git a/ext/kernel/buffer.h b/ext/kernel/buffer.h
new file mode 100644
index 0000000..4c4ca1c
--- /dev/null
+++ b/ext/kernel/buffer.h
@@ -0,0 +1,134 @@
+/**
+ * This file is part of the Zephir.
+ *
+ * (c) Phalcon Team <team@zephir-lang.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code. If you did not receive
+ * a copy of the license it is available through the world-wide-web at the
+ * following url: https://docs.zephir-lang.com/en/latest/license
+ */
+
+#ifndef ZEPHIR_KERNEL_BUFFER_H
+#define ZEPHIR_KERNEL_BUFFER_H
+
+#include <php.h>
+#include <Zend/zend.h>
+
+/**
+ * <Namespace>\Buffer -- a fixed-size, contiguous, C-typed numeric buffer,
+ * issue #2721.
+ *
+ * A PHP array of floats costs a zval plus a hash slot per element and can only
+ * be handed to a C numeric library by walking it into a scratch buffer and
+ * walking the result back out again. Where that pack/unpack happens once per
+ * operation it dominates the operation. This class is the place to keep the
+ * data between operations instead: the elements live in one `emalloc`'d C
+ * array, hand-written C reads and writes them through a raw pointer, and the
+ * PHP array is materialised only at the boundary, by toArray().
+ *
+ * It is an ordinary refcounted zend_object, so it can be held in a Zephir
+ * property, passed between methods and garbage collected like anything else.
+ *
+ * The whole class is compiled out unless the project opts in
+ * (ZEPHIR_BUFFER_ENABLED is defined in php_<project>.h by the compiler when
+ * `kernel-classes.buffer` is true in config.json).
+ */
+
+/* Element kinds. Fixed at construction; a buffer never changes kind. */
+#define ZEPHIR_BUFFER_DOUBLE 1
+#define ZEPHIR_BUFFER_LONG   2
+
+typedef struct _zephir_buffer_object {
+	/* `len` contiguous elements of the kind named by `kind`, or NULL when
+	 * len == 0. Never a zval: this is the whole point of the class. */
+	union {
+		double    *d;
+		zend_long *l;
+		void      *raw;
+	} data;
+
+	zend_long len;
+	uint8_t   kind;
+
+	/* MUST stay last: handlers.offset is XtOffsetOf(..., std). */
+	zend_object std;
+} zephir_buffer_object;
+
+#ifdef ZEPHIR_BUFFER_ENABLED
+extern zend_class_entry *zephir_buffer_ce;
+#endif
+
+/* Registered in every extension's MINIT (no-op when compiled out). */
+void zephir_buffer_module_init(void);
+
+#ifdef ZEPHIR_BUFFER_ENABLED
+
+static inline zephir_buffer_object *zephir_buffer_fetch(zend_object *obj)
+{
+	return (zephir_buffer_object *) ((char *) obj - XtOffsetOf(zephir_buffer_object, std));
+}
+
+#define ZEPHIR_BUFFER_P(zv) zephir_buffer_fetch(Z_OBJ_P(zv))
+
+/* True when `zv` is a Buffer object. The check is a class-entry pointer
+ * compare, so it is cheap enough for the kernel array fast paths. */
+static inline int zephir_is_buffer(const zval *zv)
+{
+	return Z_TYPE_P(zv) == IS_OBJECT && Z_OBJCE_P((zval *) zv) == zephir_buffer_ce;
+}
+
+/**
+ * Creates a zero-filled buffer of `len` elements into `ret`.
+ * Returns FAILURE (and throws) for a negative length or an unknown kind.
+ */
+int zephir_buffer_create(zval *ret, zend_long len, uint8_t kind);
+
+/**
+ * Creates a buffer holding the values of `arr` in iteration order. Keys are
+ * discarded -- a Buffer is positional. Each value is converted with PHP's own
+ * cast, so the result matches `(float)` / `(int)` element for element.
+ */
+int zephir_buffer_create_from_array(zval *ret, zval *arr, uint8_t kind);
+
+/** Materialises the elements as a packed PHP list into `ret`. */
+int zephir_buffer_to_array(zval *ret, const zval *obj);
+
+/** The element kind, or 0 when `obj` is not a Buffer. */
+uint8_t zephir_buffer_kind(const zval *obj);
+
+/** The element count, or 0 when `obj` is not a Buffer. */
+zend_long zephir_buffer_len(const zval *obj);
+
+/**
+ * The raw element pointers. Each returns NULL unless `obj` is a Buffer of
+ * that kind -- asking for the wrong one is a NULL, never a silently
+ * reinterpreted buffer. NULL is also returned for an empty buffer.
+ *
+ * This is the extension author's entry point: pass the result straight to
+ * cblas_daxpy(), a hand-written loop, or anything else expecting a contiguous
+ * array. The pointer stays valid until the buffer is destroyed; buffers are
+ * fixed-size, so it is never reallocated.
+ */
+double    *zephir_buffer_doubles(const zval *obj);
+zend_long *zephir_buffer_longs(const zval *obj);
+
+/**
+ * Fast paths for kernel/array.c.
+ *
+ * `buf[i]` in Zephir source compiles to a zephir_array_* call, which would
+ * otherwise see an ordinary ArrayAccess object and dispatch a full
+ * offsetGet()/offsetSet() method call per element. These do the same work
+ * without leaving C, and raise the same diagnostics when the offset is
+ * unusable.
+ */
+int zephir_buffer_dim_read_long(zval *return_value, zval *obj, zend_long index);
+int zephir_buffer_dim_read(zval *return_value, zval *obj, zval *offset);
+int zephir_buffer_dim_write_long(zval *obj, zend_long index, zval *value);
+int zephir_buffer_dim_write(zval *obj, zval *offset, zval *value);
+int zephir_buffer_dim_isset_long(const zval *obj, zend_long index);
+int zephir_buffer_dim_isset(const zval *obj, zval *offset);
+
+#endif /* ZEPHIR_BUFFER_ENABLED */
+
+#endif /* ZEPHIR_KERNEL_BUFFER_H */
diff --git a/ext/kernel/fcall.c b/ext/kernel/fcall.c
index c16a985..11c3406 100644
--- a/ext/kernel/fcall.c
+++ b/ext/kernel/fcall.c
@@ -232,6 +232,21 @@ static void resolve_callable(zval* retval, zephir_call_type type, zend_class_ent
  * scope assignments are unchanged, only the redundant resolution is skipped.
  * See the FastCall investigation: https://github.com/zephir-lang/zephir/issues/1510
  */
+/**
+ * Resolves the handler a call will use, so the engine can skip its own lookup.
+ *
+ * `func` carries the method name as it was written at the call site, while
+ * `function_table` is keyed by the lower-cased name, so every lookup here has
+ * to fold the case the way PHP folds it: `zend_std_get_method()` lower-cases
+ * for the table and keeps the original only for the `__call()` trampoline, and
+ * `zend_is_callable_check_method()` uses this very function.
+ *
+ * At most one of the lookups below runs per call, and none of them runs once a
+ * handler has been cached, so the fold costs one `zend_string_tolower()` per
+ * cache miss.
+ *
+ * @see https://github.com/zephir-lang/zephir/issues/2715
+ */
 static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, zend_class_entry* ce, zval *this_ptr, zval *func, zend_class_entry* called_scope, zend_function* cached_handler)
 {
 	zend_class_entry* calling_scope;
@@ -251,11 +266,11 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 	switch (type) {
 		case zephir_fcall_parent:
 			if (ce && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->parent->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->parent->function_table, Z_STR_P(func));
 				fcic->calling_scope = ce->parent;
 			} else if (EXPECTED(calling_scope && calling_scope->parent)) {
 				if (Z_TYPE_P(func) == IS_STRING) {
-					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&calling_scope->parent->function_table, Z_STR_P(func));
+					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&calling_scope->parent->function_table, Z_STR_P(func));
 				}
 				fcic->calling_scope = calling_scope->parent;
 			} else {
@@ -271,10 +286,10 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 
 		case zephir_fcall_static:
 			if (ce && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->function_table, Z_STR_P(func));
 				fcic->calling_scope = ce;
 			} else if (calling_scope && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&calling_scope->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&calling_scope->function_table, Z_STR_P(func));
 				fcic->calling_scope = called_scope;
 			}
 
@@ -282,10 +297,10 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 
 		case zephir_fcall_self:
 			if (ce && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->function_table, Z_STR_P(func));
 				fcic->calling_scope = ce;
 			} else if (calling_scope && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&calling_scope->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&calling_scope->function_table, Z_STR_P(func));
 				// TODO: Review when error will be enabled in zend_is_callable_ex() calls
 				//fcic->object = zend_get_this_object(EG(current_execute_data));
 				//fcic->called_scope = zend_get_called_scope(EG(current_execute_data));
@@ -306,9 +321,9 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 #if PHP_VERSION_ID >= 80000
 			if (Z_TYPE_P(func) == IS_STRING) {
 				if (ce) {
-					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->function_table, Z_STR_P(func));
+					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->function_table, Z_STR_P(func));
 				} else if (calling_scope) {
-					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&calling_scope->function_table, Z_STR_P(func));
+					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&calling_scope->function_table, Z_STR_P(func));
 					fcic->calling_scope = calling_scope;
 				}
 			}
@@ -362,7 +377,7 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 					fcic->calling_scope = ce;
 
 #if PHP_VERSION_ID >= 80000
-					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->function_table, Z_STR_P(func));
+					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->function_table, Z_STR_P(func));
 #endif
 				} else {
 					fcic->calling_scope = this_ptr ? Z_OBJCE_P(this_ptr) : NULL;
diff --git a/ext/kernel/fcall.h b/ext/kernel/fcall.h
index 91e121b..4dfba18 100644
--- a/ext/kernel/fcall.h
+++ b/ext/kernel/fcall.h
@@ -150,37 +150,43 @@ extern zend_internal_function zephir_internal_call_frame_func;
 		ZEPHIR_LAST_CALL_STATUS = zephir_call_class_method_aparams(return_value_ptr, Z_TYPE_P(object) == IS_OBJECT ? Z_OBJCE_P(object) : NULL, zephir_fcall_method, object, method, strlen(method), cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
 	} while (0)
 
+/**
+ * The `_ZVAL` macros take the method name from a variable, and pass it on as it
+ * was spelled: `__call()` is defined to receive the name as written, and the
+ * lookup that dispatches the call folds the case itself (see populate_fcic()
+ * in kernel/fcall.c). They used to lower-case it into a copy on every call.
+ *
+ * @see https://github.com/zephir-lang/zephir/issues/2715
+ */
 #define ZEPHIR_RETURN_CALL_METHOD_ZVAL(object, method, cache, cache_slot, ...) \
 	do { \
-		char *method_name; \
-		int method_len; \
+		const char *method_name; \
+		uint32_t method_len; \
 		zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \
 		if (Z_TYPE_P(method) == IS_STRING) { \
 			method_len = Z_STRLEN_P(method); \
-			method_name = zend_str_tolower_dup(Z_STRVAL_P(method), method_len); \
+			method_name = Z_STRVAL_P(method); \
 		} else { \
 			method_len = 0; \
-			method_name = zend_str_tolower_dup("", 0); \
+			method_name = ""; \
 		} \
 		ZEPHIR_LAST_CALL_STATUS = zephir_return_call_class_method(return_value, Z_TYPE_P(object) == IS_OBJECT ? Z_OBJCE_P(object) : NULL, zephir_fcall_method, object, method_name, method_len, cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
-		efree(method_name); \
 	} while (0)
 
 #define ZEPHIR_CALL_METHOD_ZVAL(return_value_ptr, object, method, cache, cache_slot, ...) \
 	do { \
-		char *method_name; \
-		int method_len; \
+		const char *method_name; \
+		uint32_t method_len; \
 		zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \
 		if (Z_TYPE_P(method) == IS_STRING) { \
 			method_len = Z_STRLEN_P(method); \
-			method_name = zend_str_tolower_dup(Z_STRVAL_P(method), method_len); \
+			method_name = Z_STRVAL_P(method); \
 		} else { \
 			method_len = 0; \
-			method_name = zend_str_tolower_dup("", 0); \
+			method_name = ""; \
 		} \
 		ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(return_value_ptr); \
 		ZEPHIR_LAST_CALL_STATUS = zephir_call_class_method_aparams(return_value_ptr, Z_TYPE_P(object) == IS_OBJECT ? Z_OBJCE_P(object) : NULL, zephir_fcall_method, object, method_name, method_len, cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
-		efree(method_name); \
 	} while (0)
 
 #define ZEPHIR_CALL_PARENT(return_value_ptr, class_entry, this_ptr, method, cache, cache_slot, ...) \
@@ -243,35 +249,33 @@ extern zend_internal_function zephir_internal_call_frame_func;
 
 #define ZEPHIR_CALL_CE_STATIC_ZVAL(return_value_ptr, class_entry, method, cache, cache_slot, ...) \
 	do { \
-		char *method_name; \
-		int method_len; \
+		const char *method_name; \
+		uint32_t method_len; \
 		zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \
 		if (Z_TYPE(method) == IS_STRING) { \
 			method_len = Z_STRLEN(method); \
-			method_name = zend_str_tolower_dup(Z_STRVAL(method), method_len); \
+			method_name = Z_STRVAL(method); \
 		} else { \
 			method_len = 0; \
-			method_name = zend_str_tolower_dup("", 0); \
+			method_name = ""; \
 		} \
 		ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(return_value_ptr); \
 		ZEPHIR_LAST_CALL_STATUS = zephir_call_class_method_aparams(return_value_ptr, class_entry, zephir_fcall_ce, NULL, method_name, method_len, cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
-		efree(method_name); \
 	} while (0)
 
 #define ZEPHIR_RETURN_CALL_CE_STATIC_ZVAL(class_entry, method, cache, cache_slot, ...) \
 	do { \
-		char *method_name; \
-		int method_len; \
+		const char *method_name; \
+		uint32_t method_len; \
 		zval *params_[] = { ZEPHIR_FETCH_VA_ARGS __VA_ARGS__ }; \
 		if (Z_TYPE(method) == IS_STRING) { \
 			method_len = Z_STRLEN(method); \
-			method_name = zend_str_tolower_dup(Z_STRVAL(method), method_len); \
+			method_name = Z_STRVAL(method); \
 		} else { \
 			method_len = 0; \
-			method_name = zend_str_tolower_dup("", 0); \
+			method_name = ""; \
 		} \
 		ZEPHIR_LAST_CALL_STATUS = zephir_return_call_class_method(return_value, class_entry, zephir_fcall_ce, NULL, method_name, method_len, cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
-		efree(method_name); \
 	} while (0)
 
 /** Use these functions to call functions in the PHP userland using an arbitrary zval as callable */
diff --git a/ext/kernel/main.c b/ext/kernel/main.c
index 80776c6..59e6a4d 100644
--- a/ext/kernel/main.c
+++ b/ext/kernel/main.c
@@ -26,6 +26,7 @@
 #include "kernel/fcall.h"
 #include "kernel/object.h"
 #include "kernel/exception.h"
+#include "kernel/buffer.h"
 #include "kernel/generator.h"
 
 
@@ -1184,6 +1185,7 @@ void zephir_module_init()
 	i_static = zend_new_interned_string(zend_string_init(ZEND_STRL("static"), 1));
 	i_self   = zend_new_interned_string(zend_string_init(ZEND_STRL("self"), 1));
 
+	zephir_buffer_module_init();
 	zephir_generator_module_init();
 	zephir_closure_module_init();
 }
diff --git a/ext/php_tensor.h b/ext/php_tensor.h
index d788231..b9ddfd0 100644
--- a/ext/php_tensor.h
+++ b/ext/php_tensor.h
@@ -19,6 +19,9 @@
 
 
 
+#define ZEPHIR_BUFFER_ENABLED 1
+#define ZEPHIR_BUFFER_NAMESPACE "Tensor"
+
 
 
 ZEND_BEGIN_MODULE_GLOBALS(tensor)
diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index bdca23a..5680679 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -172,12 +172,12 @@ PHP_METHOD(Tensor_ColumnVector, matmul)
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b);
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "ascolumnmatrix", NULL, 0);
+	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();
@@ -241,7 +241,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -270,7 +270,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -472,7 +472,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -501,7 +501,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -703,7 +703,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -732,7 +732,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -934,7 +934,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -963,7 +963,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -1166,7 +1166,7 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -1195,7 +1195,7 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -1397,7 +1397,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -1426,7 +1426,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -1628,7 +1628,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -1657,7 +1657,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -1883,7 +1883,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -1912,7 +1912,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -2138,7 +2138,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -2167,7 +2167,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -2393,7 +2393,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -2422,7 +2422,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -2648,7 +2648,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -2677,7 +2677,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -2903,7 +2903,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -2932,7 +2932,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
diff --git a/ext/tensor/decompositions/cholesky.zep.c b/ext/tensor/decompositions/cholesky.zep.c
index 2234521..b6e4e73 100644
--- a/ext/tensor/decompositions/cholesky.zep.c
+++ b/ext/tensor/decompositions/cholesky.zep.c
@@ -66,17 +66,17 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (!(zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -87,7 +87,7 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&l);
-	ZEPHIR_CALL_METHOD(&_4, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, a, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_cholesky(&l, &_4);
 	if (Z_TYPE_P(&l) == IS_NULL) {
@@ -117,7 +117,7 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, __construct)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(l, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(l, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &l);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 5, l);
diff --git a/ext/tensor/decompositions/eigen.zep.c b/ext/tensor/decompositions/eigen.zep.c
index 3386ee4..f96b093 100644
--- a/ext/tensor/decompositions/eigen.zep.c
+++ b/ext/tensor/decompositions/eigen.zep.c
@@ -84,7 +84,7 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	ZVAL_UNDEF(&eig);
 	ZVAL_UNDEF(&_7);
 	ZEND_PARSE_PARAMETERS_START(1, 2)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 		Z_PARAM_OPTIONAL
 		Z_PARAM_BOOL(symmetric)
 	ZEND_PARSE_PARAMETERS_END();
@@ -95,12 +95,12 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 		symmetric = 0;
 	} else {
 		}
-	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -112,12 +112,12 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	}
 	if (symmetric) {
 		ZEPHIR_INIT_VAR(&result);
-		ZEPHIR_CALL_METHOD(&_4$$4, a, "asarray", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$4, a, "asArray", NULL, 0);
 		zephir_check_call_status();
 		tensor_eig_symmetric(&result, &_4$$4);
 	} else {
 		ZEPHIR_INIT_NVAR(&result);
-		ZEPHIR_CALL_METHOD(&_5$$5, a, "asarray", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_5$$5, a, "asArray", NULL, 0);
 		zephir_check_call_status();
 		tensor_eig(&result, &_5$$5);
 	}
@@ -167,7 +167,7 @@ PHP_METHOD(Tensor_Decompositions_Eigen, __construct)
 
 	ZEND_PARSE_PARAMETERS_START(2, 2)
 		ZEPHIR_Z_PARAM_ARRAY(eigenvalues, eigenvalues_param)
-		Z_PARAM_OBJECT_OF_CLASS(eigenvectors, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(eigenvectors, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
diff --git a/ext/tensor/decompositions/lu.zep.c b/ext/tensor/decompositions/lu.zep.c
index 8f07729..39b2774 100644
--- a/ext/tensor/decompositions/lu.zep.c
+++ b/ext/tensor/decompositions/lu.zep.c
@@ -89,17 +89,17 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 	ZVAL_UNDEF(&lup);
 	ZVAL_UNDEF(&_6);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -110,7 +110,7 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_4, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, a, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_lu(&result, &_4);
 	if (Z_TYPE_P(&result) == IS_NULL) {
@@ -164,9 +164,9 @@ PHP_METHOD(Tensor_Decompositions_Lu, __construct)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(3, 3)
-		Z_PARAM_OBJECT_OF_CLASS(l, tensor_matrix_ce)
-		Z_PARAM_OBJECT_OF_CLASS(u, tensor_matrix_ce)
-		Z_PARAM_OBJECT_OF_CLASS(p, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(l, zephir_get_internal_ce(SL("tensor\\matrix")))
+		Z_PARAM_OBJECT_OF_CLASS(u, zephir_get_internal_ce(SL("tensor\\matrix")))
+		Z_PARAM_OBJECT_OF_CLASS(p, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(3, 0, &l, &u, &p);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 8, l);
diff --git a/ext/tensor/decompositions/svd.zep.c b/ext/tensor/decompositions/svd.zep.c
index 2e5f3fe..34d89cf 100644
--- a/ext/tensor/decompositions/svd.zep.c
+++ b/ext/tensor/decompositions/svd.zep.c
@@ -79,13 +79,13 @@ PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 	ZVAL_UNDEF(&usvT);
 	ZVAL_UNDEF(&_2);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_0, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_svd(&result, &_0);
 	if (Z_TYPE_P(&result) == IS_NULL) {
@@ -140,9 +140,9 @@ PHP_METHOD(Tensor_Decompositions_Svd, __construct)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(3, 3)
-		Z_PARAM_OBJECT_OF_CLASS(u, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(u, zephir_get_internal_ce(SL("tensor\\matrix")))
 		ZEPHIR_Z_PARAM_ARRAY(singularValues, singularValues_param)
-		Z_PARAM_OBJECT_OF_CLASS(vT, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(vT, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 2152fd1..b44bdef 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -1278,7 +1278,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &index_param);
 	ZVAL_LONG(&_0, index);
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "offsetget", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "offsetGet", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1355,12 +1355,12 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -1520,7 +1520,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			}
 			i = _2;
 			ZVAL_LONG(&_5$$3, i);
-			ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "columnasvector", &_6, 0, &_5$$3);
+			ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "columnAsVector", &_6, 0, &_5$$3);
 			zephir_check_call_status();
 			zephir_array_append(&vectors, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 553);
 		}
@@ -1913,12 +1913,12 @@ PHP_METHOD(Tensor_Matrix, inverse)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -1928,7 +1928,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&_4, this_ptr, "fullrank", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, this_ptr, "fullRank", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_4))) {
 		ZEPHIR_INIT_VAR(&_5$$4);
@@ -2030,12 +2030,12 @@ PHP_METHOD(Tensor_Matrix, det)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -2049,7 +2049,7 @@ PHP_METHOD(Tensor_Matrix, det)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_4, &ref, "a", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_5, &_4, "diagonalasvector", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_5, &_4, "diagonalAsVector", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&pi, &_5, "product", NULL, 0);
 	zephir_check_call_status();
@@ -2078,7 +2078,7 @@ PHP_METHOD(Tensor_Matrix, trace)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "diagonalasvector", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "diagonalAsVector", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_METHOD(&_0, "sum", NULL, 0);
 	zephir_check_call_status();
@@ -2121,7 +2121,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_1, &_0, "a", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_2, &_1, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_2, &_1, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_get_arrval(&_3, &_2);
 	ZEPHIR_CPY_WRT(&a, &_3);
@@ -2255,7 +2255,7 @@ PHP_METHOD(Tensor_Matrix, symmetric)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (!(zephir_is_true(&_0))) {
 		RETURN_MM_BOOL(0);
@@ -2347,7 +2347,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -2374,7 +2374,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_matmul(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_8);
@@ -2415,7 +2415,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -2440,12 +2440,12 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&_9, b, "ascolumnmatrix", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_9, b, "asColumnMatrix", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_8, this_ptr, "matmul", NULL, 0, &_9);
 	zephir_check_call_status();
 	ZVAL_LONG(&_10, 0);
-	ZEPHIR_RETURN_CALL_METHOD(&_8, "columnasvector", NULL, 0, &_10);
+	ZEPHIR_RETURN_CALL_METHOD(&_8, "columnAsVector", NULL, 0, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2496,7 +2496,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 2)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 		Z_PARAM_OPTIONAL
 		Z_PARAM_LONG(stride)
 	ZEND_PARSE_PARAMETERS_END();
@@ -2544,7 +2544,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 	}
 	ZEPHIR_INIT_VAR(&_11);
 	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_13, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_13, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_LONG(&_14, stride);
 	tensor_convolve_2d(&_11, &_12, &_13, &_14);
@@ -2828,15 +2828,15 @@ PHP_METHOD(Tensor_Matrix, multiply)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplymatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplycolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2844,7 +2844,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2899,15 +2899,15 @@ PHP_METHOD(Tensor_Matrix, divide)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividematrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividecolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividevector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2915,7 +2915,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividescalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2971,15 +2971,15 @@ PHP_METHOD(Tensor_Matrix, add)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2987,7 +2987,7 @@ PHP_METHOD(Tensor_Matrix, add)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3043,15 +3043,15 @@ PHP_METHOD(Tensor_Matrix, subtract)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3059,7 +3059,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3115,15 +3115,15 @@ PHP_METHOD(Tensor_Matrix, pow)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3131,7 +3131,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3187,15 +3187,15 @@ PHP_METHOD(Tensor_Matrix, mod)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3203,7 +3203,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3259,15 +3259,15 @@ PHP_METHOD(Tensor_Matrix, equal)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3275,7 +3275,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3331,15 +3331,15 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3347,7 +3347,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3403,15 +3403,15 @@ PHP_METHOD(Tensor_Matrix, greater)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatermatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatercolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatervector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3419,7 +3419,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3475,15 +3475,15 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3491,7 +3491,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3547,15 +3547,15 @@ PHP_METHOD(Tensor_Matrix, less)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lesscolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3563,7 +3563,7 @@ PHP_METHOD(Tensor_Matrix, less)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3619,15 +3619,15 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3635,7 +3635,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3681,7 +3681,7 @@ PHP_METHOD(Tensor_Matrix, reciprocal)
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_SELF(&_0, "ones", NULL, 0, &_1, &_2);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "dividematrix", NULL, 0, this_ptr);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "divideMatrix", NULL, 0, this_ptr);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3722,7 +3722,7 @@ PHP_METHOD(Tensor_Matrix, square)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplymatrix", NULL, 0, this_ptr);
+	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyMatrix", NULL, 0, this_ptr);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4353,7 +4353,7 @@ PHP_METHOD(Tensor_Matrix, mean)
 	ZEPHIR_CALL_METHOD(&_0, this_ptr, "sum", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "dividescalar", NULL, 0, &_1);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "divideScalar", NULL, 0, &_1);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4746,14 +4746,14 @@ PHP_METHOD(Tensor_Matrix, variance)
 		ZEPHIR_CALL_METHOD(mean, this_ptr, "mean", NULL, 0);
 		zephir_check_call_status();
 	}
-	ZEPHIR_CALL_METHOD(&_11, this_ptr, "subtractcolumnvector", NULL, 0, mean);
+	ZEPHIR_CALL_METHOD(&_11, this_ptr, "subtractColumnVector", NULL, 0, mean);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_12, &_11, "square", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_13, &_12, "sum", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_14, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_13, "dividescalar", NULL, 0, &_14);
+	ZEPHIR_RETURN_CALL_METHOD(&_13, "divideScalar", NULL, 0, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4799,7 +4799,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 	bool is_null_true = 1;
 	ZEND_PARSE_PARAMETERS_START(0, 1)
 		Z_PARAM_OPTIONAL
-		Z_PARAM_OBJECT_OF_CLASS_OR_NULL(mean, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS_OR_NULL(mean, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4835,14 +4835,14 @@ PHP_METHOD(Tensor_Matrix, covariance)
 		ZEPHIR_CALL_METHOD(mean, this_ptr, "mean", NULL, 0);
 		zephir_check_call_status();
 	}
-	ZEPHIR_CALL_METHOD(&b, this_ptr, "subtractcolumnvector", NULL, 0, mean);
+	ZEPHIR_CALL_METHOD(&b, this_ptr, "subtractColumnVector", NULL, 0, mean);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_9, &b, "transpose", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_8, &b, "matmul", NULL, 0, &_9);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_8, "dividescalar", NULL, 0, &_10);
+	ZEPHIR_RETURN_CALL_METHOD(&_8, "divideScalar", NULL, 0, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6150,7 +6150,7 @@ PHP_METHOD(Tensor_Matrix, augmentAbove)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6181,7 +6181,7 @@ PHP_METHOD(Tensor_Matrix, augmentAbove)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_10);
-	ZEPHIR_CALL_METHOD(&_11, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_fast_array_merge(&_10, &_11, &_12);
@@ -6233,7 +6233,7 @@ PHP_METHOD(Tensor_Matrix, augmentBelow)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6265,7 +6265,7 @@ PHP_METHOD(Tensor_Matrix, augmentBelow)
 	}
 	ZEPHIR_INIT_VAR(&_10);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_12, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_12, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_fast_array_merge(&_10, &_11, &_12);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_10);
@@ -6313,7 +6313,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6343,7 +6343,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_INIT_VAR(&_12);
@@ -6395,7 +6395,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6426,7 +6426,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 		return;
 	}
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_11, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&_12);
 	ZVAL_STRING(&_12, "array_merge");
@@ -6609,7 +6609,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6621,9 +6621,9 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -6635,7 +6635,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -6741,7 +6741,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6753,9 +6753,9 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -6767,7 +6767,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -6873,7 +6873,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6885,9 +6885,9 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -6899,7 +6899,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7005,7 +7005,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -7017,9 +7017,9 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7031,7 +7031,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7138,7 +7138,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -7150,9 +7150,9 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7164,7 +7164,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7271,7 +7271,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -7283,9 +7283,9 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7297,7 +7297,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7404,7 +7404,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -7416,9 +7416,9 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7430,7 +7430,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7536,7 +7536,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -7548,9 +7548,9 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7562,7 +7562,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7669,7 +7669,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -7681,9 +7681,9 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7695,7 +7695,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7802,7 +7802,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -7814,9 +7814,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7828,7 +7828,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7934,7 +7934,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -7946,9 +7946,9 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7960,7 +7960,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -8066,7 +8066,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -8078,9 +8078,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -8092,7 +8092,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -8199,7 +8199,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -8226,7 +8226,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8319,7 +8319,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -8346,7 +8346,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8439,7 +8439,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -8466,7 +8466,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8559,7 +8559,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -8586,7 +8586,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8679,7 +8679,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -8706,7 +8706,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8799,7 +8799,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -8826,7 +8826,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8920,7 +8920,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -8947,7 +8947,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9040,7 +9040,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -9067,7 +9067,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9160,7 +9160,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -9187,7 +9187,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9280,7 +9280,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -9307,7 +9307,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9400,7 +9400,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -9427,7 +9427,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9521,7 +9521,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -9548,7 +9548,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9647,7 +9647,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -9674,7 +9674,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -9787,7 +9787,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -9814,7 +9814,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -9927,7 +9927,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -9954,7 +9954,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10067,7 +10067,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -10094,7 +10094,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10207,7 +10207,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -10234,7 +10234,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10347,7 +10347,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -10374,7 +10374,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10487,7 +10487,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -10514,7 +10514,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10627,7 +10627,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -10654,7 +10654,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10767,7 +10767,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -10794,7 +10794,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10907,7 +10907,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -10934,7 +10934,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -11047,7 +11047,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -11074,7 +11074,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -11187,7 +11187,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_columnvector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -11214,7 +11214,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -12482,7 +12482,7 @@ PHP_METHOD(Tensor_Matrix, getIterator)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	object_init_ex(return_value, spl_ce_ArrayIterator);
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asvectors", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asVectors", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &_0);
 	zephir_check_call_status();
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index c65bcb5..af701fb 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -74,13 +74,13 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	ZVAL_UNDEF(&ref);
 	ZVAL_UNDEF(&_2);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_0, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_ref(&result, &_0);
 	if (Z_TYPE_P(&result) == IS_NULL) {
@@ -131,7 +131,7 @@ PHP_METHOD(Tensor_Reductions_Ref, __construct)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(2, 2)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 		Z_PARAM_LONG(swaps)
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index 45b4061..f6f0058 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -87,7 +87,7 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 	ZVAL_UNDEF(&_8$$3);
 	ZVAL_UNDEF(&_31$$11);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -111,7 +111,7 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_3, &_2, "a", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_4, &_3, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, &_3, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_get_arrval(&_5, &_4);
 	ZEPHIR_CPY_WRT(&b, &_5);
@@ -285,7 +285,7 @@ PHP_METHOD(Tensor_Reductions_Rref, __construct)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &a);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 19, a);
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index ae1d6b5..da3b454 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -1294,7 +1294,7 @@ PHP_METHOD(Tensor_Vector, dot)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -1320,7 +1320,7 @@ PHP_METHOD(Tensor_Vector, dot)
 		return;
 	}
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_9, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_9, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_dot(return_value, &_8, &_9);
 	RETURN_MM();
@@ -1365,7 +1365,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 2)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 		Z_PARAM_OPTIONAL
 		Z_PARAM_LONG(stride)
 	ZEND_PARSE_PARAMETERS_END();
@@ -1406,7 +1406,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_LONG(&_11, stride);
 	tensor_convolve_1d(&_8, &_9, &_10, &_11);
@@ -1431,12 +1431,12 @@ PHP_METHOD(Tensor_Vector, matmul)
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b);
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asrowmatrix", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asRowMatrix", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_METHOD(&_0, "matmul", NULL, 0, b);
 	zephir_check_call_status();
@@ -1458,7 +1458,7 @@ PHP_METHOD(Tensor_Vector, inner)
 
 	ZVAL_UNDEF(&b_sub);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -1505,7 +1505,7 @@ PHP_METHOD(Tensor_Vector, outer)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -1516,7 +1516,7 @@ PHP_METHOD(Tensor_Vector, outer)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_0, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_get_arrval(&_1, &_0);
 	ZEPHIR_CPY_WRT(&bHat, &_1);
@@ -1700,7 +1700,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 	ZEPHIR_CALL_METHOD(&_4, this_ptr, "abs", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_6, p);
-	ZEPHIR_CALL_METHOD(&_5, &_4, "powscalar", NULL, 0, &_6);
+	ZEPHIR_CALL_METHOD(&_5, &_4, "powScalar", NULL, 0, &_6);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_7, &_5, "sum", NULL, 0);
 	zephir_check_call_status();
@@ -1772,11 +1772,11 @@ PHP_METHOD(Tensor_Vector, multiply)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplymatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -1784,7 +1784,7 @@ PHP_METHOD(Tensor_Vector, multiply)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -1838,11 +1838,11 @@ PHP_METHOD(Tensor_Vector, divide)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividematrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividevector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -1850,7 +1850,7 @@ PHP_METHOD(Tensor_Vector, divide)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividescalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -1905,11 +1905,11 @@ PHP_METHOD(Tensor_Vector, add)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -1917,7 +1917,7 @@ PHP_METHOD(Tensor_Vector, add)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -1972,11 +1972,11 @@ PHP_METHOD(Tensor_Vector, subtract)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -1984,7 +1984,7 @@ PHP_METHOD(Tensor_Vector, subtract)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2039,11 +2039,11 @@ PHP_METHOD(Tensor_Vector, pow)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2051,7 +2051,7 @@ PHP_METHOD(Tensor_Vector, pow)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2106,11 +2106,11 @@ PHP_METHOD(Tensor_Vector, mod)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2118,7 +2118,7 @@ PHP_METHOD(Tensor_Vector, mod)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2173,11 +2173,11 @@ PHP_METHOD(Tensor_Vector, equal)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2185,7 +2185,7 @@ PHP_METHOD(Tensor_Vector, equal)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2240,11 +2240,11 @@ PHP_METHOD(Tensor_Vector, notEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2252,7 +2252,7 @@ PHP_METHOD(Tensor_Vector, notEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2307,11 +2307,11 @@ PHP_METHOD(Tensor_Vector, greater)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatermatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatervector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2319,7 +2319,7 @@ PHP_METHOD(Tensor_Vector, greater)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2374,11 +2374,11 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2386,7 +2386,7 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2441,11 +2441,11 @@ PHP_METHOD(Tensor_Vector, less)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2453,7 +2453,7 @@ PHP_METHOD(Tensor_Vector, less)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2508,11 +2508,11 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2520,7 +2520,7 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2560,7 +2560,7 @@ PHP_METHOD(Tensor_Vector, reciprocal)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_STATIC(&_0, "ones", NULL, 0, &_1);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "dividevector", NULL, 0, this_ptr);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "divideVector", NULL, 0, this_ptr);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2601,7 +2601,7 @@ PHP_METHOD(Tensor_Vector, square)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyvector", NULL, 0, this_ptr);
+	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyVector", NULL, 0, this_ptr);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3328,7 +3328,7 @@ PHP_METHOD(Tensor_Vector, variance)
 		ZEPHIR_CALL_METHOD(mean, this_ptr, "mean", NULL, 0);
 		zephir_check_call_status();
 	}
-	ZEPHIR_CALL_METHOD(&_4, this_ptr, "subtractscalar", NULL, 0, mean);
+	ZEPHIR_CALL_METHOD(&_4, this_ptr, "subtractScalar", NULL, 0, mean);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_5, &_4, "square", NULL, 0);
 	zephir_check_call_status();
@@ -4031,7 +4031,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4058,7 +4058,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4153,7 +4153,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4180,7 +4180,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4275,7 +4275,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4302,7 +4302,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4397,7 +4397,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4424,7 +4424,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4519,7 +4519,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4546,7 +4546,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4641,7 +4641,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4668,7 +4668,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4763,7 +4763,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4790,7 +4790,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4885,7 +4885,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4912,7 +4912,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5007,7 +5007,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5034,7 +5034,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5129,7 +5129,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5156,7 +5156,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5251,7 +5251,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5278,7 +5278,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5373,7 +5373,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_matrix_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5400,7 +5400,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5487,7 +5487,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5514,7 +5514,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_multiply(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5559,7 +5559,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5586,7 +5586,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_divide(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5631,7 +5631,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5658,7 +5658,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_add(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5703,7 +5703,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5730,7 +5730,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_subtract(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5775,7 +5775,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5802,7 +5802,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_pow(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5847,7 +5847,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5874,7 +5874,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_mod(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5920,7 +5920,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -5947,7 +5947,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_equal(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5992,7 +5992,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6019,7 +6019,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_not_equal(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -6064,7 +6064,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6091,7 +6091,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_greater(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -6136,7 +6136,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6163,7 +6163,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_greater_equal(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -6208,7 +6208,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6235,7 +6235,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_less(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -6280,7 +6280,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(b, tensor_vector_ce)
+		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -6307,7 +6307,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_less_equal(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);

From 98b3fe22c758f59684c3a1a552de4b17eb6edfe1 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 15:24:39 -0500
Subject: [PATCH 03/51] A little nicer

---
 composer.json                            |   1 -
 config.json                              |   5 +-
 ext/config.m4                            |  24 +-
 ext/config.w32                           |   2 +-
 ext/kernel/array.c                       |  41 +
 ext/kernel/buffer.c                      | 910 +++++++++++++++++++++++
 ext/kernel/buffer.h                      | 134 ++++
 ext/kernel/fcall.c                       |  33 +-
 ext/kernel/fcall.h                       |  44 +-
 ext/kernel/main.c                        |  32 +
 ext/kernel/main.h                        |  30 +
 ext/php_tensor_ext.h                     |   3 +
 ext/tensor/columnvector.zep.c            |  26 +-
 ext/tensor/decompositions/cholesky.zep.c |   6 +-
 ext/tensor/decompositions/eigen.zep.c    |   8 +-
 ext/tensor/decompositions/lu.zep.c       |   6 +-
 ext/tensor/decompositions/svd.zep.c      |   2 +-
 ext/tensor/matrix.zep.c                  | 274 +++----
 ext/tensor/reductions/ref.zep.c          |   2 +-
 ext/tensor/reductions/rref.zep.c         |   2 +-
 ext/tensor/vector.zep.c                  | 136 ++--
 ext/tensor_ext.c                         |  13 +
 22 files changed, 1455 insertions(+), 279 deletions(-)
 create mode 100644 ext/kernel/buffer.c
 create mode 100644 ext/kernel/buffer.h

diff --git a/composer.json b/composer.json
index 5b8dabe..3ade8f4 100644
--- a/composer.json
+++ b/composer.json
@@ -66,7 +66,6 @@
         "clean": "zephir fullclean",
         "compile": [
             "zephir generate",
-            "@php build-ext",
             "zephir compile --no-dev"
         ],
         "install-ext": "zephir install",
diff --git a/config.json b/config.json
index 791243f..2027c01 100644
--- a/config.json
+++ b/config.json
@@ -33,10 +33,7 @@
         "constant-folding": true,
         "static-constant-class-folding": true,
         "call-gatherer-pass": true,
-        "check-invalid-reads": false,
-        "private-internal-methods": false,
-        "public-internal-methods": false,
-        "public-internal-functions": true
+        "check-invalid-reads": false
     },
     "warnings": {
         "unused-variable": true,
diff --git a/ext/config.m4 b/ext/config.m4
index 92d193c..b6a9085 100644
--- a/ext/config.m4
+++ b/ext/config.m4
@@ -9,7 +9,7 @@ if test "$PHP_TENSOR_EXT" = "yes"; then
 	fi
 
 	AC_DEFINE(HAVE_TENSOR_EXT, 1, [Whether you have Tensor_ext])
-	tensor_ext_sources="tensor_ext.c kernel/main.c kernel/memory.c kernel/exception.c kernel/debug.c kernel/backtrace.c kernel/object.c kernel/array.c kernel/string.c kernel/fcall.c kernel/require.c kernel/file.c kernel/operators.c kernel/math.c kernel/concat.c kernel/variables.c kernel/filter.c kernel/iterator.c kernel/time.c kernel/exit.c kernel/generator.c tensor/algebraic.zep.c
+	tensor_ext_sources="tensor_ext.c kernel/main.c kernel/memory.c kernel/exception.c kernel/debug.c kernel/backtrace.c kernel/object.c kernel/array.c kernel/string.c kernel/fcall.c kernel/require.c kernel/file.c kernel/operators.c kernel/math.c kernel/concat.c kernel/variables.c kernel/filter.c kernel/iterator.c kernel/time.c kernel/exit.c kernel/generator.c kernel/buffer.c tensor/algebraic.zep.c
 	tensor/arithmetic.zep.c
 	tensor/arraylike.zep.c
 	tensor/comparable.zep.c
@@ -63,21 +63,19 @@ if test "$PHP_TENSOR_EXT" = "yes"; then
 		[[#include "php_config.h"]]
 	)
 
-	AC_CHECK_DECL(
-		[HAVE_JSON],
+	dnl php-src stopped declaring HAVE_JSON in php_config.h in 8.4, so probing
+	dnl for it left ZEPHIR_USE_PHP_JSON undefined on 8.4 and 8.5 even though
+	dnl ext/json has been built in unconditionally since 8.0 -- which quietly
+	dnl demoted zephir_json_encode() to calling the userland json_encode()
+	dnl function. Probe for the header, which is what the code actually needs.
+	AC_CHECK_HEADERS(
+		[ext/json/php_json.h],
 		[
-			AC_CHECK_HEADERS(
-				[ext/json/php_json.h],
-				[
-					PHP_ADD_EXTENSION_DEP([tensor_ext], [json])
-					AC_DEFINE([ZEPHIR_USE_PHP_JSON], [1], [Whether PHP json extension is present at compile time])
-				],
-				,
-				[[#include "main/php.h"]]
-			)
+			PHP_ADD_EXTENSION_DEP([tensor_ext], [json])
+			AC_DEFINE([ZEPHIR_USE_PHP_JSON], [1], [Whether PHP json extension is present at compile time])
 		],
 		,
-		[[#include "php_config.h"]]
+		[[#include "main/php.h"]]
 	)
 
 	CPPFLAGS=$old_CPPFLAGS
diff --git a/ext/config.w32 b/ext/config.w32
index a5a354d..2431b48 100644
--- a/ext/config.w32
+++ b/ext/config.w32
@@ -2,7 +2,7 @@ ARG_ENABLE("tensor_ext", "enable tensor_ext", "no");
 
 if (PHP_TENSOR_EXT != "no") {
   EXTENSION("tensor_ext", "tensor_ext.c", null, "-I"+configure_module_dirname);
-  ADD_SOURCES(configure_module_dirname + "/kernel", "main.c memory.c exception.c debug.c backtrace.c object.c array.c string.c fcall.c require.c file.c operators.c math.c concat.c variables.c filter.c iterator.c exit.c time.c generator.c", "tensor_ext");
+  ADD_SOURCES(configure_module_dirname + "/kernel", "main.c memory.c exception.c debug.c backtrace.c object.c array.c string.c fcall.c require.c file.c operators.c math.c concat.c variables.c filter.c iterator.c exit.c time.c generator.c buffer.c", "tensor_ext");
   /* PCRE is always included on WIN32 */
   AC_DEFINE("ZEPHIR_USE_PHP_PCRE", 1, "Whether PHP pcre extension is present at compile time");
   if (PHP_JSON != "no") {
diff --git a/ext/kernel/array.c b/ext/kernel/array.c
index bac163a..9ac93ff 100644
--- a/ext/kernel/array.c
+++ b/ext/kernel/array.c
@@ -24,6 +24,7 @@
 #include "kernel/memory.h"
 #include "kernel/debug.h"
 #include "kernel/array.h"
+#include "kernel/buffer.h"
 #include "kernel/operators.h"
 #include "kernel/backtrace.h"
 #include "kernel/object.h"
@@ -464,6 +465,12 @@ int ZEPHIR_FASTCALL zephir_array_isset(const zval *arr, zval *index)
 		return 0;
 	}
 
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr))) {
+		return zephir_buffer_dim_isset(arr, index);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev((zval *)arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		zval container, exist;
@@ -555,6 +562,12 @@ int ZEPHIR_FASTCALL zephir_array_isset_string(const zval *arr, const char *index
 
 int ZEPHIR_FASTCALL zephir_array_isset_long(const zval *arr, zend_long index)
 {
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr))) {
+		return zephir_buffer_dim_isset_long(arr, index);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev((zval *)arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		zval container, exist, offset;
@@ -938,6 +951,12 @@ int zephir_array_fetch(zval *return_value, zval *arr, zval *index, int flags ZEP
 		arr = zephir_array_write_container(arr);
 	}
 
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr)) && (flags & PH_WRITE) != PH_WRITE) {
+		return zephir_buffer_dim_read(return_value, arr, index);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev(arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		ZEPHIR_CALL_METHOD_WITHOUT_OBSERVE(return_value, arr, "offsetget", NULL, 0, index);
@@ -1097,6 +1116,16 @@ int zephir_array_fetch_long(zval *return_value, zval *arr, zend_long index, int
 		arr = zephir_array_write_container(arr);
 	}
 
+#ifdef ZEPHIR_BUFFER_ENABLED
+	/* A <Ns>\Buffer element is a raw C scalar: one class-entry pointer compare
+	 * and a direct load, instead of an offsetGet() call. A write-context fetch
+	 * deliberately falls through to the ArrayAccess path below, so the engine
+	 * still reports the element as unmodifiable. */
+	if (UNEXPECTED(zephir_is_buffer(arr)) && (flags & PH_WRITE) != PH_WRITE) {
+		return zephir_buffer_dim_read_long(return_value, arr, index);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev(arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		zval offset;
@@ -1179,6 +1208,12 @@ int zephir_array_update_zval(zval *arr, zval *index, zval *value, int flags)
 	HashTable *ht;
 	zval *ret = NULL;
 
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr))) {
+		return zephir_buffer_dim_write(arr, index, value);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev(arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		ZEPHIR_CALL_METHOD_WITHOUT_OBSERVE(NULL, arr, "offsetset", NULL, 0, index, value);
@@ -1287,6 +1322,12 @@ int zephir_array_update_string(zval *arr, const char *index, uint32_t index_leng
 
 int zephir_array_update_long(zval *arr, zend_long index, zval *value, int flags ZEPHIR_DEBUG_PARAMS)
 {
+#ifdef ZEPHIR_BUFFER_ENABLED
+	if (UNEXPECTED(zephir_is_buffer(arr))) {
+		return zephir_buffer_dim_write_long(arr, index, value);
+	}
+#endif
+
 	if (UNEXPECTED(Z_TYPE_P(arr) == IS_OBJECT && zephir_instance_of_ev(arr, (const zend_class_entry *)zend_ce_arrayaccess))) {
 		zend_long ZEPHIR_LAST_CALL_STATUS;
 		zval offset;
diff --git a/ext/kernel/buffer.c b/ext/kernel/buffer.c
new file mode 100644
index 0000000..df5e05e
--- /dev/null
+++ b/ext/kernel/buffer.c
@@ -0,0 +1,910 @@
+/**
+ * This file is part of the Zephir.
+ *
+ * (c) Phalcon Team <team@zephir-lang.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code. If you did not receive
+ * a copy of the license it is available through the world-wide-web at the
+ * following url: https://docs.zephir-lang.com/en/latest/license
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php_ext.h"
+#include "kernel/buffer.h"
+
+#ifndef ZEPHIR_BUFFER_ENABLED
+
+/* The project did not opt in: the class is compiled out and MINIT
+ * registration is a no-op. */
+void zephir_buffer_module_init(void) {}
+
+#else
+
+#ifndef ZEPHIR_BUFFER_NAMESPACE
+#error "ZEPHIR_BUFFER_NAMESPACE must be defined together with ZEPHIR_BUFFER_ENABLED"
+#endif
+
+#include <Zend/zend_exceptions.h>
+#include <Zend/zend_interfaces.h>
+#include <ext/spl/spl_array.h>
+#include <ext/spl/spl_exceptions.h>
+
+/* Unconditional on purpose. ext/json cannot be disabled in PHP 8, and gating
+ * JsonSerializable on a build-time probe would mean json_encode() silently
+ * emitting `{}` and dropping every element wherever the probe happened to
+ * fail. kernel/string.c's ZEPHIR_USE_PHP_JSON gate is about an optional
+ * *optimisation*; this is about not losing data. */
+#include <ext/json/php_json.h>
+
+/* zend_object_count_elements_t returned `int` up to PHP 8.1 and `zend_result`
+ * from 8.2. The two are different types, so the handler has to be declared
+ * with whichever one this build expects. */
+#if PHP_VERSION_ID >= 80200
+# define ZEPHIR_BUFFER_COUNT_RESULT zend_result
+#else
+# define ZEPHIR_BUFFER_COUNT_RESULT int
+#endif
+
+zend_class_entry *zephir_buffer_ce;
+
+static zend_object_handlers zephir_buffer_object_handlers;
+
+/* ---------------------------------------------------------------- storage */
+
+static zend_always_inline size_t zephir_buffer_elem_size(uint8_t kind)
+{
+	return kind == ZEPHIR_BUFFER_LONG ? sizeof(zend_long) : sizeof(double);
+}
+
+static zend_always_inline int zephir_buffer_kind_is_valid(uint8_t kind)
+{
+	return kind == ZEPHIR_BUFFER_DOUBLE || kind == ZEPHIR_BUFFER_LONG;
+}
+
+/**
+ * (Re)allocates the element array, zero-filled.
+ *
+ * All-bits-zero is 0.0 for an IEEE 754 double and 0 for a zend_long, so one
+ * ecalloc covers both kinds.
+ */
+static int zephir_buffer_alloc(zephir_buffer_object *b, zend_long len, uint8_t kind)
+{
+	if (b->data.raw) {
+		efree(b->data.raw);
+		b->data.raw = NULL;
+	}
+
+	b->kind = kind;
+	b->len  = len;
+
+	if (len > 0) {
+		b->data.raw = ecalloc((size_t) len, zephir_buffer_elem_size(kind));
+	}
+
+	return SUCCESS;
+}
+
+static zend_always_inline void zephir_buffer_get(const zephir_buffer_object *b, zend_long index, zval *rv)
+{
+	if (b->kind == ZEPHIR_BUFFER_LONG) {
+		ZVAL_LONG(rv, b->data.l[index]);
+	} else {
+		ZVAL_DOUBLE(rv, b->data.d[index]);
+	}
+}
+
+/**
+ * Stores `value` at `index`, converted with the engine's own cast, so an
+ * element ends up holding exactly what `(float)` / `(int)` would have produced.
+ */
+static zend_always_inline void zephir_buffer_put(zephir_buffer_object *b, zend_long index, zval *value)
+{
+	if (b->kind == ZEPHIR_BUFFER_LONG) {
+		b->data.l[index] = zval_get_long(value);
+	} else {
+		b->data.d[index] = zval_get_double(value);
+	}
+}
+
+static zend_always_inline int zephir_buffer_in_range(const zephir_buffer_object *b, zend_long index)
+{
+	/* One compare: a negative index wraps to a huge unsigned value. */
+	return (zend_ulong) index < (zend_ulong) b->len;
+}
+
+/* ------------------------------------------------------------- diagnostics */
+
+/**
+ * php-src moved this from RuntimeException to OutOfBoundsException in 8.4
+ * (OutOfBoundsException extends RuntimeException, so catching the older one
+ * still works). Follow it, so a Buffer raises on each version whatever
+ * SplFixedArray raises there.
+ */
+static ZEND_COLD void zephir_buffer_throw_out_of_range(void)
+{
+#if PHP_VERSION_ID >= 80400
+	zend_throw_exception(spl_ce_OutOfBoundsException, "Index invalid or out of range", 0);
+#else
+	zend_throw_exception(spl_ce_RuntimeException, "Index invalid or out of range", 0);
+#endif
+}
+
+/**
+ * Converts an arbitrary offset zval to an index, following php-src's own
+ * spl_offset_convert_to_long() -- including the three regimes its failure
+ * branch went through:
+ *
+ *   8.0        no type check at all; an unusable offset became -1 and was
+ *              reported by the range check
+ *   8.1, 8.2   TypeError, "Illegal offset type"
+ *   8.3+       TypeError naming the container and the offset type
+ *
+ * On failure from 8.1 up an exception is pending, so callers must check
+ * EG(exception) before using the result. php-src reports BP_VAR_R here even
+ * from isset(), so do the same rather than varying the message by context.
+ */
+static zend_long zephir_buffer_offset_to_long(zval *offset)
+{
+	zend_ulong idx;
+
+try_again:
+	switch (Z_TYPE_P(offset)) {
+		case IS_STRING:
+			if (ZEND_HANDLE_NUMERIC(Z_STR_P(offset), idx)) {
+				return (zend_long) idx;
+			}
+			break;
+
+		case IS_DOUBLE:
+#if PHP_VERSION_ID >= 80100
+			return zend_dval_to_lval_safe(Z_DVAL_P(offset));
+#else
+			return zend_dval_to_lval(Z_DVAL_P(offset));
+#endif
+
+		case IS_LONG:
+			return Z_LVAL_P(offset);
+
+		case IS_FALSE:
+			return 0;
+
+		case IS_TRUE:
+			return 1;
+
+		case IS_REFERENCE:
+			offset = Z_REFVAL_P(offset);
+			goto try_again;
+
+		case IS_RESOURCE:
+#if PHP_VERSION_ID >= 80100
+			zend_use_resource_as_offset(offset);
+#endif
+			return Z_RES_HANDLE_P(offset);
+	}
+
+#if PHP_VERSION_ID >= 80300
+	zend_illegal_container_offset(zephir_buffer_ce->name, offset, BP_VAR_R);
+	return 0;
+#elif PHP_VERSION_ID >= 80100
+	zend_type_error("Illegal offset type");
+	return 0;
+#else
+	return -1;
+#endif
+}
+
+/**
+ * Resolves an offset to an in-range index, or returns FAILURE with an
+ * exception pending.
+ */
+static int zephir_buffer_resolve(const zephir_buffer_object *b, zval *offset, zend_long *index)
+{
+	zend_long resolved = zephir_buffer_offset_to_long(offset);
+
+	if (EG(exception)) {
+		return FAILURE;
+	}
+
+	if (!zephir_buffer_in_range(b, resolved)) {
+		zephir_buffer_throw_out_of_range();
+		return FAILURE;
+	}
+
+	*index = resolved;
+
+	return SUCCESS;
+}
+
+/* ----------------------------------------------------------------- object */
+
+static zend_object *zephir_buffer_create_object(zend_class_entry *ce)
+{
+	zephir_buffer_object *b = zend_object_alloc(sizeof(zephir_buffer_object), ce);
+
+	b->data.raw = NULL;
+	b->len      = 0;
+	b->kind     = ZEPHIR_BUFFER_DOUBLE;
+
+	zend_object_std_init(&b->std, ce);
+	object_properties_init(&b->std, ce);
+	b->std.handlers = &zephir_buffer_object_handlers;
+
+	return &b->std;
+}
+
+static void zephir_buffer_free_object(zend_object *object)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+
+	if (b->data.raw) {
+		efree(b->data.raw);
+		b->data.raw = NULL;
+	}
+
+	zend_object_std_dtor(&b->std);
+}
+
+static zend_object *zephir_buffer_clone_object(zend_object *object)
+{
+	zephir_buffer_object *source = zephir_buffer_fetch(object);
+	zend_object          *cloned = zephir_buffer_create_object(object->ce);
+	zephir_buffer_object *copy   = zephir_buffer_fetch(cloned);
+
+	copy->kind = source->kind;
+	copy->len  = source->len;
+
+	if (source->len > 0) {
+		size_t bytes = (size_t) source->len * zephir_buffer_elem_size(source->kind);
+
+		copy->data.raw = emalloc(bytes);
+		memcpy(copy->data.raw, source->data.raw, bytes);
+	}
+
+	zend_objects_clone_members(cloned, object);
+
+	return cloned;
+}
+
+/* Without this var_dump()/print_r() would show an object with no state at all,
+ * because the elements are not properties. */
+static HashTable *zephir_buffer_get_debug_info(zend_object *object, int *is_temp)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	HashTable            *info;
+	zend_long             i;
+
+	ALLOC_HASHTABLE(info);
+	zend_hash_init(info, (uint32_t) (b->len > 0 ? b->len : 0), NULL, ZVAL_PTR_DTOR, 0);
+
+	for (i = 0; i < b->len; ++i) {
+		zval element;
+
+		zephir_buffer_get(b, i, &element);
+		zend_hash_index_update(info, (zend_ulong) i, &element);
+	}
+
+	*is_temp = 1;
+
+	return info;
+}
+
+static ZEPHIR_BUFFER_COUNT_RESULT zephir_buffer_count_elements(zend_object *object, zend_long *count)
+{
+	*count = zephir_buffer_fetch(object)->len;
+
+	return SUCCESS;
+}
+
+/* ------------------------------------------------------------- dimensions */
+
+static int zephir_buffer_has_dimension(zend_object *object, zval *offset, int check_empty);
+
+/**
+ * `$buffer[$i]`.
+ *
+ * The value is returned in `rv`, never as a pointer into the buffer -- the
+ * elements are raw C scalars, not zvals, so there is nothing to point at.
+ *
+ * That does not stop compound assignment. The engine implements `$buffer[0]
+ * += 1` on an object as a read followed by a write, so it arrives here and
+ * then at zephir_buffer_write_dimension() and behaves normally. What cannot
+ * work is anything needing a reference to the element -- `$buffer[0]++`,
+ * `$r =& $buffer[0]`, passing it to a by-reference parameter. The engine
+ * raises its standard "Indirect modification of overloaded element" notice for
+ * those and the write has no effect, exactly as it does for any ArrayAccess
+ * object that does not hand back a reference.
+ */
+static zval *zephir_buffer_read_dimension(zend_object *object, zval *offset, int type, zval *rv)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	zend_long             index;
+
+	/* `$buffer[$i] ?? $default` must not raise for a merely absent index --
+	 * but an offset of an unusable *type* still does, as it does for
+	 * SplFixedArray. */
+	if (type == BP_VAR_IS && !zephir_buffer_has_dimension(object, offset, 0)) {
+		return &EG(uninitialized_zval);
+	}
+
+	if (!offset) {
+		zend_throw_error(NULL, "Cannot use [] for reading");
+		return NULL;
+	}
+
+	if (zephir_buffer_resolve(b, offset, &index) == FAILURE) {
+		return NULL;
+	}
+
+	zephir_buffer_get(b, index, rv);
+
+	return rv;
+}
+
+static void zephir_buffer_write_dimension(zend_object *object, zval *offset, zval *value)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	zend_long             index;
+
+	if (!offset) {
+		/* `$buffer[] = v`. A Buffer is fixed-size, so there is nothing to
+		 * append to. php-src changed SplFixedArray's report here in 8.1. */
+#if PHP_VERSION_ID >= 80100
+		zend_throw_error(NULL, "[] operator not supported for %s", ZSTR_VAL(object->ce->name));
+#else
+		zephir_buffer_throw_out_of_range();
+#endif
+		return;
+	}
+
+	if (zephir_buffer_resolve(b, offset, &index) == FAILURE) {
+		return;
+	}
+
+	zephir_buffer_put(b, index, value);
+}
+
+static int zephir_buffer_has_dimension(zend_object *object, zval *offset, int check_empty)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	zend_long             index;
+	zval                  element;
+
+	index = zephir_buffer_offset_to_long(offset);
+
+	if (EG(exception)) {
+		return 0;
+	}
+
+	if (!zephir_buffer_in_range(b, index)) {
+		return 0;
+	}
+
+	/* Every in-range element is set. A Buffer holds numbers, so unlike
+	 * SplFixedArray -- whose slots start out null, and where isset() is
+	 * therefore false on a freshly constructed one -- there is no element
+	 * value that isset() reports as absent. */
+	if (!check_empty) {
+		return 1;
+	}
+
+	zephir_buffer_get(b, index, &element);
+
+	return zend_is_true(&element);
+}
+
+/* A numeric buffer cannot hold null, so unset() writes the zero element. */
+static void zephir_buffer_unset_dimension(zend_object *object, zval *offset)
+{
+	zephir_buffer_object *b = zephir_buffer_fetch(object);
+	zend_long             index;
+
+	if (zephir_buffer_resolve(b, offset, &index) == FAILURE) {
+		return;
+	}
+
+	if (b->kind == ZEPHIR_BUFFER_LONG) {
+		b->data.l[index] = 0;
+	} else {
+		b->data.d[index] = 0.0;
+	}
+}
+
+/* -------------------------------------------------------------- C-side API */
+
+int zephir_buffer_create(zval *ret, zend_long len, uint8_t kind)
+{
+	zephir_buffer_object *b;
+
+	if (!zephir_buffer_kind_is_valid(kind) || len < 0) {
+		ZVAL_NULL(ret);
+
+		return FAILURE;
+	}
+
+	object_init_ex(ret, zephir_buffer_ce);
+	b = ZEPHIR_BUFFER_P(ret);
+
+	return zephir_buffer_alloc(b, len, kind);
+}
+
+int zephir_buffer_create_from_array(zval *ret, zval *arr, uint8_t kind)
+{
+	zephir_buffer_object *b;
+	zval                 *value;
+	zend_long             i = 0;
+
+	if (Z_TYPE_P(arr) != IS_ARRAY) {
+		ZVAL_NULL(ret);
+
+		return FAILURE;
+	}
+
+	if (zephir_buffer_create(ret, (zend_long) zend_hash_num_elements(Z_ARRVAL_P(arr)), kind) == FAILURE) {
+		return FAILURE;
+	}
+
+	b = ZEPHIR_BUFFER_P(ret);
+
+	/* Positional: the keys of the source array are discarded, the values are
+	 * taken in iteration order. */
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arr), value) {
+		zephir_buffer_put(b, i++, value);
+	} ZEND_HASH_FOREACH_END();
+
+	return SUCCESS;
+}
+
+int zephir_buffer_to_array(zval *ret, const zval *obj)
+{
+	zephir_buffer_object *b;
+	zend_long             i;
+
+	if (!zephir_is_buffer(obj)) {
+		ZVAL_NULL(ret);
+
+		return FAILURE;
+	}
+
+	b = ZEPHIR_BUFFER_P((zval *) obj);
+
+	array_init_size(ret, (uint32_t) (b->len > 0 ? b->len : 0));
+
+	for (i = 0; i < b->len; ++i) {
+		if (b->kind == ZEPHIR_BUFFER_LONG) {
+			add_next_index_long(ret, b->data.l[i]);
+		} else {
+			add_next_index_double(ret, b->data.d[i]);
+		}
+	}
+
+	return SUCCESS;
+}
+
+uint8_t zephir_buffer_kind(const zval *obj)
+{
+	return zephir_is_buffer(obj) ? ZEPHIR_BUFFER_P((zval *) obj)->kind : 0;
+}
+
+zend_long zephir_buffer_len(const zval *obj)
+{
+	return zephir_is_buffer(obj) ? ZEPHIR_BUFFER_P((zval *) obj)->len : 0;
+}
+
+double *zephir_buffer_doubles(const zval *obj)
+{
+	zephir_buffer_object *b;
+
+	if (!zephir_is_buffer(obj)) {
+		return NULL;
+	}
+
+	b = ZEPHIR_BUFFER_P((zval *) obj);
+
+	return b->kind == ZEPHIR_BUFFER_DOUBLE ? b->data.d : NULL;
+}
+
+zend_long *zephir_buffer_longs(const zval *obj)
+{
+	zephir_buffer_object *b;
+
+	if (!zephir_is_buffer(obj)) {
+		return NULL;
+	}
+
+	b = ZEPHIR_BUFFER_P((zval *) obj);
+
+	return b->kind == ZEPHIR_BUFFER_LONG ? b->data.l : NULL;
+}
+
+/* ------------------------------------------------ kernel/array.c fast paths */
+
+int zephir_buffer_dim_read_long(zval *return_value, zval *obj, zend_long index)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(obj);
+
+	if (UNEXPECTED(!zephir_buffer_in_range(b, index))) {
+		zephir_buffer_throw_out_of_range();
+		ZVAL_NULL(return_value);
+
+		return FAILURE;
+	}
+
+	zephir_buffer_get(b, index, return_value);
+
+	return SUCCESS;
+}
+
+int zephir_buffer_dim_read(zval *return_value, zval *obj, zval *offset)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(obj);
+	zend_long             index;
+
+	if (UNEXPECTED(zephir_buffer_resolve(b, offset, &index) == FAILURE)) {
+		ZVAL_NULL(return_value);
+
+		return FAILURE;
+	}
+
+	zephir_buffer_get(b, index, return_value);
+
+	return SUCCESS;
+}
+
+int zephir_buffer_dim_write_long(zval *obj, zend_long index, zval *value)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(obj);
+
+	if (UNEXPECTED(!zephir_buffer_in_range(b, index))) {
+		zephir_buffer_throw_out_of_range();
+
+		return FAILURE;
+	}
+
+	zephir_buffer_put(b, index, value);
+
+	return SUCCESS;
+}
+
+int zephir_buffer_dim_write(zval *obj, zval *offset, zval *value)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(obj);
+	zend_long             index;
+
+	if (UNEXPECTED(zephir_buffer_resolve(b, offset, &index) == FAILURE)) {
+		return FAILURE;
+	}
+
+	zephir_buffer_put(b, index, value);
+
+	return SUCCESS;
+}
+
+int zephir_buffer_dim_isset_long(const zval *obj, zend_long index)
+{
+	return zephir_buffer_in_range(ZEPHIR_BUFFER_P((zval *) obj), index);
+}
+
+int zephir_buffer_dim_isset(const zval *obj, zval *offset)
+{
+	return zephir_buffer_has_dimension(Z_OBJ_P((zval *) obj), offset, 0);
+}
+
+/* ---------------------------------------------------------------- methods */
+
+PHP_METHOD(ZephirBuffer, __construct)
+{
+	zephir_buffer_object *b    = ZEPHIR_BUFFER_P(getThis());
+	zend_long             size;
+	zend_long             type = ZEPHIR_BUFFER_DOUBLE;
+
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		Z_PARAM_LONG(size)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_LONG(type)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (size < 0) {
+		zend_argument_value_error(1, "must be greater than or equal to 0");
+		RETURN_THROWS();
+	}
+
+	if (!zephir_buffer_kind_is_valid((uint8_t) type)) {
+		zend_argument_value_error(2, "must be Buffer::TYPE_DOUBLE or Buffer::TYPE_LONG");
+		RETURN_THROWS();
+	}
+
+	zephir_buffer_alloc(b, size, (uint8_t) type);
+}
+
+PHP_METHOD(ZephirBuffer, fromArray)
+{
+	zval      *values;
+	zend_long  type = ZEPHIR_BUFFER_DOUBLE;
+
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		Z_PARAM_ARRAY(values)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_LONG(type)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (!zephir_buffer_kind_is_valid((uint8_t) type)) {
+		zend_argument_value_error(2, "must be Buffer::TYPE_DOUBLE or Buffer::TYPE_LONG");
+		RETURN_THROWS();
+	}
+
+	zephir_buffer_create_from_array(return_value, values, (uint8_t) type);
+}
+
+PHP_METHOD(ZephirBuffer, toArray)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zephir_buffer_to_array(return_value, getThis());
+}
+
+PHP_METHOD(ZephirBuffer, type)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	RETURN_LONG(ZEPHIR_BUFFER_P(getThis())->kind);
+}
+
+PHP_METHOD(ZephirBuffer, count)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	RETURN_LONG(ZEPHIR_BUFFER_P(getThis())->len);
+}
+
+PHP_METHOD(ZephirBuffer, fill)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(getThis());
+	zval                 *value;
+	zend_long             i;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(value)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (b->kind == ZEPHIR_BUFFER_LONG) {
+		zend_long converted = zval_get_long(value);
+
+		for (i = 0; i < b->len; ++i) {
+			b->data.l[i] = converted;
+		}
+	} else {
+		double converted = zval_get_double(value);
+
+		for (i = 0; i < b->len; ++i) {
+			b->data.d[i] = converted;
+		}
+	}
+}
+
+PHP_METHOD(ZephirBuffer, offsetExists)
+{
+	zval *offset;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(offset)
+	ZEND_PARSE_PARAMETERS_END();
+
+	RETURN_BOOL(zephir_buffer_has_dimension(Z_OBJ_P(getThis()), offset, 0));
+}
+
+PHP_METHOD(ZephirBuffer, offsetGet)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(getThis());
+	zval                 *offset;
+	zend_long             index;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(offset)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (zephir_buffer_resolve(b, offset, &index) == FAILURE) {
+		RETURN_THROWS();
+	}
+
+	zephir_buffer_get(b, index, return_value);
+}
+
+PHP_METHOD(ZephirBuffer, offsetSet)
+{
+	zval *offset;
+	zval *value;
+
+	ZEND_PARSE_PARAMETERS_START(2, 2)
+		Z_PARAM_ZVAL(offset)
+		Z_PARAM_ZVAL(value)
+	ZEND_PARSE_PARAMETERS_END();
+
+	zephir_buffer_write_dimension(Z_OBJ_P(getThis()), offset, value);
+}
+
+PHP_METHOD(ZephirBuffer, offsetUnset)
+{
+	zval *offset;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(offset)
+	ZEND_PARSE_PARAMETERS_END();
+
+	zephir_buffer_unset_dimension(Z_OBJ_P(getThis()), offset);
+}
+
+/**
+ * foreach materialises the elements. A Buffer exists so that hot loops happen
+ * in C over the raw pointer; iterating one element at a time through the VM is
+ * the slow path by definition, so it is not worth a lazy iterator.
+ */
+PHP_METHOD(ZephirBuffer, getIterator)
+{
+	zval elements;
+
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zephir_buffer_to_array(&elements, getThis());
+
+	object_init_ex(return_value, spl_ce_ArrayIterator);
+	zend_call_method_with_1_params(
+		Z_OBJ_P(return_value), spl_ce_ArrayIterator, NULL, "__construct", NULL, &elements);
+
+	zval_ptr_dtor(&elements);
+}
+
+/* Without this json_encode() would serialise an object with no properties as
+ * `{}` and drop every element. */
+PHP_METHOD(ZephirBuffer, jsonSerialize)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zephir_buffer_to_array(return_value, getThis());
+}
+
+PHP_METHOD(ZephirBuffer, __serialize)
+{
+	zval elements;
+
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zephir_buffer_to_array(&elements, getThis());
+
+	array_init_size(return_value, 2);
+	add_next_index_long(return_value, ZEPHIR_BUFFER_P(getThis())->kind);
+	add_next_index_zval(return_value, &elements);
+}
+
+PHP_METHOD(ZephirBuffer, __unserialize)
+{
+	zephir_buffer_object *b = ZEPHIR_BUFFER_P(getThis());
+	zval                 *payload;
+	zval                 *kind;
+	zval                 *elements;
+	zval                 *value;
+	zend_long             i = 0;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ARRAY(payload)
+	ZEND_PARSE_PARAMETERS_END();
+
+	kind     = zend_hash_index_find(Z_ARRVAL_P(payload), 0);
+	elements = zend_hash_index_find(Z_ARRVAL_P(payload), 1);
+
+	if (!kind || Z_TYPE_P(kind) != IS_LONG || !elements || Z_TYPE_P(elements) != IS_ARRAY
+		|| !zephir_buffer_kind_is_valid((uint8_t) Z_LVAL_P(kind))) {
+		zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object",
+			ZSTR_VAL(zephir_buffer_ce->name));
+		RETURN_THROWS();
+	}
+
+	zephir_buffer_alloc(b, (zend_long) zend_hash_num_elements(Z_ARRVAL_P(elements)),
+		(uint8_t) Z_LVAL_P(kind));
+
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(elements), value) {
+		zephir_buffer_put(b, i++, value);
+	} ZEND_HASH_FOREACH_END();
+}
+
+/* ------------------------------------------------------------- class init */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_zephir_buffer_construct, 0, 0, 1)
+	ZEND_ARG_TYPE_INFO(0, size, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, type, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_zephir_buffer_from_array, 0, 0, 1)
+	ZEND_ARG_TYPE_INFO(0, values, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, type, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_to_array, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_long, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_fill, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_offset_exists, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_offset_get, 0, 1, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_offset_set, 0, 2, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_offset_unset, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_zephir_buffer_get_iterator, 0, 0, Traversable, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_json_serialize, 0, 0, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_serialize, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zephir_buffer_unserialize, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, data, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+static const zend_function_entry zephir_buffer_methods[] = {
+	PHP_ME(ZephirBuffer, __construct,   arginfo_zephir_buffer_construct,      ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
+	PHP_ME(ZephirBuffer, fromArray,     arginfo_zephir_buffer_from_array,     ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+	PHP_ME(ZephirBuffer, toArray,       arginfo_zephir_buffer_to_array,       ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, type,          arginfo_zephir_buffer_long,           ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, count,         arginfo_zephir_buffer_long,           ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, fill,          arginfo_zephir_buffer_fill,           ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, offsetExists,  arginfo_zephir_buffer_offset_exists,  ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, offsetGet,     arginfo_zephir_buffer_offset_get,     ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, offsetSet,     arginfo_zephir_buffer_offset_set,     ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, offsetUnset,   arginfo_zephir_buffer_offset_unset,   ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, getIterator,   arginfo_zephir_buffer_get_iterator,   ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, jsonSerialize, arginfo_zephir_buffer_json_serialize, ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, __serialize,   arginfo_zephir_buffer_serialize,      ZEND_ACC_PUBLIC)
+	PHP_ME(ZephirBuffer, __unserialize, arginfo_zephir_buffer_unserialize,    ZEND_ACC_PUBLIC)
+	PHP_FE_END
+};
+
+void zephir_buffer_module_init(void)
+{
+	zend_class_entry ce;
+
+	INIT_NS_CLASS_ENTRY(ce, ZEPHIR_BUFFER_NAMESPACE, "Buffer", zephir_buffer_methods);
+	zephir_buffer_ce = zend_register_internal_class(&ce);
+	zephir_buffer_ce->ce_flags |= ZEND_ACC_FINAL | ZEND_ACC_NO_DYNAMIC_PROPERTIES;
+	zephir_buffer_ce->create_object = zephir_buffer_create_object;
+
+	zend_declare_class_constant_long(zephir_buffer_ce, ZEND_STRL("TYPE_DOUBLE"), ZEPHIR_BUFFER_DOUBLE);
+	zend_declare_class_constant_long(zephir_buffer_ce, ZEND_STRL("TYPE_LONG"), ZEPHIR_BUFFER_LONG);
+
+	memcpy(&zephir_buffer_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+	zephir_buffer_object_handlers.offset           = XtOffsetOf(zephir_buffer_object, std);
+	zephir_buffer_object_handlers.free_obj         = zephir_buffer_free_object;
+	zephir_buffer_object_handlers.clone_obj        = zephir_buffer_clone_object;
+	zephir_buffer_object_handlers.get_debug_info   = zephir_buffer_get_debug_info;
+	zephir_buffer_object_handlers.count_elements   = zephir_buffer_count_elements;
+	zephir_buffer_object_handlers.read_dimension   = zephir_buffer_read_dimension;
+	zephir_buffer_object_handlers.write_dimension  = zephir_buffer_write_dimension;
+	zephir_buffer_object_handlers.has_dimension    = zephir_buffer_has_dimension;
+	zephir_buffer_object_handlers.unset_dimension  = zephir_buffer_unset_dimension;
+
+	zend_class_implements(zephir_buffer_ce, 4,
+		zend_ce_arrayaccess, zend_ce_countable, zend_ce_aggregate, php_json_serializable_ce);
+}
+
+#endif /* ZEPHIR_BUFFER_ENABLED */
diff --git a/ext/kernel/buffer.h b/ext/kernel/buffer.h
new file mode 100644
index 0000000..4c4ca1c
--- /dev/null
+++ b/ext/kernel/buffer.h
@@ -0,0 +1,134 @@
+/**
+ * This file is part of the Zephir.
+ *
+ * (c) Phalcon Team <team@zephir-lang.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code. If you did not receive
+ * a copy of the license it is available through the world-wide-web at the
+ * following url: https://docs.zephir-lang.com/en/latest/license
+ */
+
+#ifndef ZEPHIR_KERNEL_BUFFER_H
+#define ZEPHIR_KERNEL_BUFFER_H
+
+#include <php.h>
+#include <Zend/zend.h>
+
+/**
+ * <Namespace>\Buffer -- a fixed-size, contiguous, C-typed numeric buffer,
+ * issue #2721.
+ *
+ * A PHP array of floats costs a zval plus a hash slot per element and can only
+ * be handed to a C numeric library by walking it into a scratch buffer and
+ * walking the result back out again. Where that pack/unpack happens once per
+ * operation it dominates the operation. This class is the place to keep the
+ * data between operations instead: the elements live in one `emalloc`'d C
+ * array, hand-written C reads and writes them through a raw pointer, and the
+ * PHP array is materialised only at the boundary, by toArray().
+ *
+ * It is an ordinary refcounted zend_object, so it can be held in a Zephir
+ * property, passed between methods and garbage collected like anything else.
+ *
+ * The whole class is compiled out unless the project opts in
+ * (ZEPHIR_BUFFER_ENABLED is defined in php_<project>.h by the compiler when
+ * `kernel-classes.buffer` is true in config.json).
+ */
+
+/* Element kinds. Fixed at construction; a buffer never changes kind. */
+#define ZEPHIR_BUFFER_DOUBLE 1
+#define ZEPHIR_BUFFER_LONG   2
+
+typedef struct _zephir_buffer_object {
+	/* `len` contiguous elements of the kind named by `kind`, or NULL when
+	 * len == 0. Never a zval: this is the whole point of the class. */
+	union {
+		double    *d;
+		zend_long *l;
+		void      *raw;
+	} data;
+
+	zend_long len;
+	uint8_t   kind;
+
+	/* MUST stay last: handlers.offset is XtOffsetOf(..., std). */
+	zend_object std;
+} zephir_buffer_object;
+
+#ifdef ZEPHIR_BUFFER_ENABLED
+extern zend_class_entry *zephir_buffer_ce;
+#endif
+
+/* Registered in every extension's MINIT (no-op when compiled out). */
+void zephir_buffer_module_init(void);
+
+#ifdef ZEPHIR_BUFFER_ENABLED
+
+static inline zephir_buffer_object *zephir_buffer_fetch(zend_object *obj)
+{
+	return (zephir_buffer_object *) ((char *) obj - XtOffsetOf(zephir_buffer_object, std));
+}
+
+#define ZEPHIR_BUFFER_P(zv) zephir_buffer_fetch(Z_OBJ_P(zv))
+
+/* True when `zv` is a Buffer object. The check is a class-entry pointer
+ * compare, so it is cheap enough for the kernel array fast paths. */
+static inline int zephir_is_buffer(const zval *zv)
+{
+	return Z_TYPE_P(zv) == IS_OBJECT && Z_OBJCE_P((zval *) zv) == zephir_buffer_ce;
+}
+
+/**
+ * Creates a zero-filled buffer of `len` elements into `ret`.
+ * Returns FAILURE (and throws) for a negative length or an unknown kind.
+ */
+int zephir_buffer_create(zval *ret, zend_long len, uint8_t kind);
+
+/**
+ * Creates a buffer holding the values of `arr` in iteration order. Keys are
+ * discarded -- a Buffer is positional. Each value is converted with PHP's own
+ * cast, so the result matches `(float)` / `(int)` element for element.
+ */
+int zephir_buffer_create_from_array(zval *ret, zval *arr, uint8_t kind);
+
+/** Materialises the elements as a packed PHP list into `ret`. */
+int zephir_buffer_to_array(zval *ret, const zval *obj);
+
+/** The element kind, or 0 when `obj` is not a Buffer. */
+uint8_t zephir_buffer_kind(const zval *obj);
+
+/** The element count, or 0 when `obj` is not a Buffer. */
+zend_long zephir_buffer_len(const zval *obj);
+
+/**
+ * The raw element pointers. Each returns NULL unless `obj` is a Buffer of
+ * that kind -- asking for the wrong one is a NULL, never a silently
+ * reinterpreted buffer. NULL is also returned for an empty buffer.
+ *
+ * This is the extension author's entry point: pass the result straight to
+ * cblas_daxpy(), a hand-written loop, or anything else expecting a contiguous
+ * array. The pointer stays valid until the buffer is destroyed; buffers are
+ * fixed-size, so it is never reallocated.
+ */
+double    *zephir_buffer_doubles(const zval *obj);
+zend_long *zephir_buffer_longs(const zval *obj);
+
+/**
+ * Fast paths for kernel/array.c.
+ *
+ * `buf[i]` in Zephir source compiles to a zephir_array_* call, which would
+ * otherwise see an ordinary ArrayAccess object and dispatch a full
+ * offsetGet()/offsetSet() method call per element. These do the same work
+ * without leaving C, and raise the same diagnostics when the offset is
+ * unusable.
+ */
+int zephir_buffer_dim_read_long(zval *return_value, zval *obj, zend_long index);
+int zephir_buffer_dim_read(zval *return_value, zval *obj, zval *offset);
+int zephir_buffer_dim_write_long(zval *obj, zend_long index, zval *value);
+int zephir_buffer_dim_write(zval *obj, zval *offset, zval *value);
+int zephir_buffer_dim_isset_long(const zval *obj, zend_long index);
+int zephir_buffer_dim_isset(const zval *obj, zval *offset);
+
+#endif /* ZEPHIR_BUFFER_ENABLED */
+
+#endif /* ZEPHIR_KERNEL_BUFFER_H */
diff --git a/ext/kernel/fcall.c b/ext/kernel/fcall.c
index c16a985..11c3406 100644
--- a/ext/kernel/fcall.c
+++ b/ext/kernel/fcall.c
@@ -232,6 +232,21 @@ static void resolve_callable(zval* retval, zephir_call_type type, zend_class_ent
  * scope assignments are unchanged, only the redundant resolution is skipped.
  * See the FastCall investigation: https://github.com/zephir-lang/zephir/issues/1510
  */
+/**
+ * Resolves the handler a call will use, so the engine can skip its own lookup.
+ *
+ * `func` carries the method name as it was written at the call site, while
+ * `function_table` is keyed by the lower-cased name, so every lookup here has
+ * to fold the case the way PHP folds it: `zend_std_get_method()` lower-cases
+ * for the table and keeps the original only for the `__call()` trampoline, and
+ * `zend_is_callable_check_method()` uses this very function.
+ *
+ * At most one of the lookups below runs per call, and none of them runs once a
+ * handler has been cached, so the fold costs one `zend_string_tolower()` per
+ * cache miss.
+ *
+ * @see https://github.com/zephir-lang/zephir/issues/2715
+ */
 static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, zend_class_entry* ce, zval *this_ptr, zval *func, zend_class_entry* called_scope, zend_function* cached_handler)
 {
 	zend_class_entry* calling_scope;
@@ -251,11 +266,11 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 	switch (type) {
 		case zephir_fcall_parent:
 			if (ce && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->parent->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->parent->function_table, Z_STR_P(func));
 				fcic->calling_scope = ce->parent;
 			} else if (EXPECTED(calling_scope && calling_scope->parent)) {
 				if (Z_TYPE_P(func) == IS_STRING) {
-					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&calling_scope->parent->function_table, Z_STR_P(func));
+					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&calling_scope->parent->function_table, Z_STR_P(func));
 				}
 				fcic->calling_scope = calling_scope->parent;
 			} else {
@@ -271,10 +286,10 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 
 		case zephir_fcall_static:
 			if (ce && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->function_table, Z_STR_P(func));
 				fcic->calling_scope = ce;
 			} else if (calling_scope && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&calling_scope->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&calling_scope->function_table, Z_STR_P(func));
 				fcic->calling_scope = called_scope;
 			}
 
@@ -282,10 +297,10 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 
 		case zephir_fcall_self:
 			if (ce && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->function_table, Z_STR_P(func));
 				fcic->calling_scope = ce;
 			} else if (calling_scope && Z_TYPE_P(func) == IS_STRING) {
-				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&calling_scope->function_table, Z_STR_P(func));
+				fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&calling_scope->function_table, Z_STR_P(func));
 				// TODO: Review when error will be enabled in zend_is_callable_ex() calls
 				//fcic->object = zend_get_this_object(EG(current_execute_data));
 				//fcic->called_scope = zend_get_called_scope(EG(current_execute_data));
@@ -306,9 +321,9 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 #if PHP_VERSION_ID >= 80000
 			if (Z_TYPE_P(func) == IS_STRING) {
 				if (ce) {
-					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->function_table, Z_STR_P(func));
+					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->function_table, Z_STR_P(func));
 				} else if (calling_scope) {
-					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&calling_scope->function_table, Z_STR_P(func));
+					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&calling_scope->function_table, Z_STR_P(func));
 					fcic->calling_scope = calling_scope;
 				}
 			}
@@ -362,7 +377,7 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze
 					fcic->calling_scope = ce;
 
 #if PHP_VERSION_ID >= 80000
-					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr(&ce->function_table, Z_STR_P(func));
+					fcic->function_handler = cached_handler ? cached_handler : zend_hash_find_ptr_lc(&ce->function_table, Z_STR_P(func));
 #endif
 				} else {
 					fcic->calling_scope = this_ptr ? Z_OBJCE_P(this_ptr) : NULL;
diff --git a/ext/kernel/fcall.h b/ext/kernel/fcall.h
index 91e121b..4dfba18 100644
--- a/ext/kernel/fcall.h
+++ b/ext/kernel/fcall.h
@@ -150,37 +150,43 @@ extern zend_internal_function zephir_internal_call_frame_func;
 		ZEPHIR_LAST_CALL_STATUS = zephir_call_class_method_aparams(return_value_ptr, Z_TYPE_P(object) == IS_OBJECT ? Z_OBJCE_P(object) : NULL, zephir_fcall_method, object, method, strlen(method), cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
 	} while (0)
 
+/**
+ * The `_ZVAL` macros take the method name from a variable, and pass it on as it
+ * was spelled: `__call()` is defined to receive the name as written, and the
+ * lookup that dispatches the call folds the case itself (see populate_fcic()
+ * in kernel/fcall.c). They used to lower-case it into a copy on every call.
+ *
+ * @see https://github.com/zephir-lang/zephir/issues/2715
+ */
 #define ZEPHIR_RETURN_CALL_METHOD_ZVAL(object, method, cache, cache_slot, ...) \
 	do { \
-		char *method_name; \
-		int method_len; \
+		const char *method_name; \
+		uint32_t method_len; \
 		zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \
 		if (Z_TYPE_P(method) == IS_STRING) { \
 			method_len = Z_STRLEN_P(method); \
-			method_name = zend_str_tolower_dup(Z_STRVAL_P(method), method_len); \
+			method_name = Z_STRVAL_P(method); \
 		} else { \
 			method_len = 0; \
-			method_name = zend_str_tolower_dup("", 0); \
+			method_name = ""; \
 		} \
 		ZEPHIR_LAST_CALL_STATUS = zephir_return_call_class_method(return_value, Z_TYPE_P(object) == IS_OBJECT ? Z_OBJCE_P(object) : NULL, zephir_fcall_method, object, method_name, method_len, cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
-		efree(method_name); \
 	} while (0)
 
 #define ZEPHIR_CALL_METHOD_ZVAL(return_value_ptr, object, method, cache, cache_slot, ...) \
 	do { \
-		char *method_name; \
-		int method_len; \
+		const char *method_name; \
+		uint32_t method_len; \
 		zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \
 		if (Z_TYPE_P(method) == IS_STRING) { \
 			method_len = Z_STRLEN_P(method); \
-			method_name = zend_str_tolower_dup(Z_STRVAL_P(method), method_len); \
+			method_name = Z_STRVAL_P(method); \
 		} else { \
 			method_len = 0; \
-			method_name = zend_str_tolower_dup("", 0); \
+			method_name = ""; \
 		} \
 		ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(return_value_ptr); \
 		ZEPHIR_LAST_CALL_STATUS = zephir_call_class_method_aparams(return_value_ptr, Z_TYPE_P(object) == IS_OBJECT ? Z_OBJCE_P(object) : NULL, zephir_fcall_method, object, method_name, method_len, cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
-		efree(method_name); \
 	} while (0)
 
 #define ZEPHIR_CALL_PARENT(return_value_ptr, class_entry, this_ptr, method, cache, cache_slot, ...) \
@@ -243,35 +249,33 @@ extern zend_internal_function zephir_internal_call_frame_func;
 
 #define ZEPHIR_CALL_CE_STATIC_ZVAL(return_value_ptr, class_entry, method, cache, cache_slot, ...) \
 	do { \
-		char *method_name; \
-		int method_len; \
+		const char *method_name; \
+		uint32_t method_len; \
 		zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \
 		if (Z_TYPE(method) == IS_STRING) { \
 			method_len = Z_STRLEN(method); \
-			method_name = zend_str_tolower_dup(Z_STRVAL(method), method_len); \
+			method_name = Z_STRVAL(method); \
 		} else { \
 			method_len = 0; \
-			method_name = zend_str_tolower_dup("", 0); \
+			method_name = ""; \
 		} \
 		ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(return_value_ptr); \
 		ZEPHIR_LAST_CALL_STATUS = zephir_call_class_method_aparams(return_value_ptr, class_entry, zephir_fcall_ce, NULL, method_name, method_len, cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
-		efree(method_name); \
 	} while (0)
 
 #define ZEPHIR_RETURN_CALL_CE_STATIC_ZVAL(class_entry, method, cache, cache_slot, ...) \
 	do { \
-		char *method_name; \
-		int method_len; \
+		const char *method_name; \
+		uint32_t method_len; \
 		zval *params_[] = { ZEPHIR_FETCH_VA_ARGS __VA_ARGS__ }; \
 		if (Z_TYPE(method) == IS_STRING) { \
 			method_len = Z_STRLEN(method); \
-			method_name = zend_str_tolower_dup(Z_STRVAL(method), method_len); \
+			method_name = Z_STRVAL(method); \
 		} else { \
 			method_len = 0; \
-			method_name = zend_str_tolower_dup("", 0); \
+			method_name = ""; \
 		} \
 		ZEPHIR_LAST_CALL_STATUS = zephir_return_call_class_method(return_value, class_entry, zephir_fcall_ce, NULL, method_name, method_len, cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \
-		efree(method_name); \
 	} while (0)
 
 /** Use these functions to call functions in the PHP userland using an arbitrary zval as callable */
diff --git a/ext/kernel/main.c b/ext/kernel/main.c
index 80776c6..1744c56 100644
--- a/ext/kernel/main.c
+++ b/ext/kernel/main.c
@@ -26,6 +26,7 @@
 #include "kernel/fcall.h"
 #include "kernel/object.h"
 #include "kernel/exception.h"
+#include "kernel/buffer.h"
 #include "kernel/generator.h"
 
 
@@ -1184,6 +1185,7 @@ void zephir_module_init()
 	i_static = zend_new_interned_string(zend_string_init(ZEND_STRL("static"), 1));
 	i_self   = zend_new_interned_string(zend_string_init(ZEND_STRL("self"), 1));
 
+	zephir_buffer_module_init();
 	zephir_generator_module_init();
 	zephir_closure_module_init();
 }
@@ -1199,3 +1201,33 @@ void zephir_module_shutdown(void)
 {
 	zephir_closure_module_shutdown();
 }
+
+ZEND_INI_MH(zephir_OnUpdateChar)
+{
+	char *p = (char *) ZEND_INI_GET_ADDR();
+
+	*p = (new_value && ZSTR_LEN(new_value)) ? ZSTR_VAL(new_value)[0] : '\0';
+
+	return SUCCESS;
+}
+
+void zephir_ini_activate_globals(const char *const *names)
+{
+	for (; *names; names++) {
+		zend_ini_entry *entry = zend_hash_str_find_ptr(EG(ini_directives), *names, strlen(*names));
+
+		/* An entry the engine refused to register (a duplicate name) leaves
+		 * its global at whatever MINIT left behind, which is the same
+		 * outcome as before this call existed. */
+		if (entry && entry->on_modify) {
+			entry->on_modify(
+				entry,
+				entry->value,
+				entry->mh_arg1,
+				entry->mh_arg2,
+				entry->mh_arg3,
+				ZEND_INI_STAGE_ACTIVATE
+			);
+		}
+	}
+}
diff --git a/ext/kernel/main.h b/ext/kernel/main.h
index 7892c3a..dcc48c5 100644
--- a/ext/kernel/main.h
+++ b/ext/kernel/main.h
@@ -19,6 +19,8 @@
 #include <Zend/zend_string.h>
 #include <Zend/zend.h>
 #include <Zend/zend_attributes.h>
+/* ZEND_INI_MH and ZEND_INI_GET_ADDR; <php.h> does not pull this in. */
+#include <Zend/zend_ini.h>
 
 extern zend_string* i_parent;
 extern zend_string* i_static;
@@ -605,6 +607,34 @@ void zephir_get_args_from(zval* return_value, uint32_t skip);
 void zephir_module_init();
 void zephir_module_shutdown(void);
 
+/**
+ * Update handler for an extension global declared as `char` or `uchar`.
+ *
+ * The engine exports no handler writing a single character: the stock set
+ * covers bool, zend_long, double, char* and zend_string* only. ext/soap's
+ * OnUpdateCacheMode is the same four lines for the same reason.
+ */
+ZEND_INI_MH(zephir_OnUpdateChar);
+
+/**
+ * Re-applies the current value of each named ini directive to the global it
+ * backs, at the start of a request.
+ *
+ * REGISTER_INI_ENTRIES() already seeds every INI-backed global at MINIT, and
+ * the engine restores anything ini_set() touched at request shutdown. What it
+ * cannot see is globals_set(), which writes the struct member directly; that
+ * value would otherwise survive into the next request. Re-running each
+ * entry's own on_modify handler resets exactly those, for every type, without
+ * the generated code having to know which type each global is.
+ *
+ * Mirrors zend_ini_refresh_caches(), which the engine runs for the same
+ * reason when a new thread starts.
+ *
+ * @param names NULL-terminated list of directive names
+ * @see https://github.com/zephir-lang/zephir/issues/2449
+ */
+void zephir_ini_activate_globals(const char *const *names);
+
 /**
  * Z_PARAM_ARRAY(dest) expands to a call to zend_parse_arg_array(_arg, &dest, ...).
  * The inline function has taken `zval **dest` since at least PHP 7.0, so the
diff --git a/ext/php_tensor_ext.h b/ext/php_tensor_ext.h
index 7c2722c..6bd45f8 100644
--- a/ext/php_tensor_ext.h
+++ b/ext/php_tensor_ext.h
@@ -19,6 +19,9 @@
 
 
 
+#define ZEPHIR_BUFFER_ENABLED 1
+#define ZEPHIR_BUFFER_NAMESPACE "Tensor"
+
 
 
 ZEND_BEGIN_MODULE_GLOBALS(tensor_ext)
diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index b398508..5680679 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -177,7 +177,7 @@ PHP_METHOD(Tensor_ColumnVector, matmul)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b);
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "ascolumnmatrix", NULL, 0);
+	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();
@@ -270,7 +270,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -501,7 +501,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -732,7 +732,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -963,7 +963,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -1195,7 +1195,7 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -1426,7 +1426,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -1657,7 +1657,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -1912,7 +1912,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -2167,7 +2167,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -2422,7 +2422,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -2677,7 +2677,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -2932,7 +2932,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
diff --git a/ext/tensor/decompositions/cholesky.zep.c b/ext/tensor/decompositions/cholesky.zep.c
index 4d64f2a..b6e4e73 100644
--- a/ext/tensor/decompositions/cholesky.zep.c
+++ b/ext/tensor/decompositions/cholesky.zep.c
@@ -71,12 +71,12 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (!(zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -87,7 +87,7 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&l);
-	ZEPHIR_CALL_METHOD(&_4, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, a, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_cholesky(&l, &_4);
 	if (Z_TYPE_P(&l) == IS_NULL) {
diff --git a/ext/tensor/decompositions/eigen.zep.c b/ext/tensor/decompositions/eigen.zep.c
index 0ef0304..f96b093 100644
--- a/ext/tensor/decompositions/eigen.zep.c
+++ b/ext/tensor/decompositions/eigen.zep.c
@@ -95,12 +95,12 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 		symmetric = 0;
 	} else {
 		}
-	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -112,12 +112,12 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	}
 	if (symmetric) {
 		ZEPHIR_INIT_VAR(&result);
-		ZEPHIR_CALL_METHOD(&_4$$4, a, "asarray", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$4, a, "asArray", NULL, 0);
 		zephir_check_call_status();
 		tensor_eig_symmetric(&result, &_4$$4);
 	} else {
 		ZEPHIR_INIT_NVAR(&result);
-		ZEPHIR_CALL_METHOD(&_5$$5, a, "asarray", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_5$$5, a, "asArray", NULL, 0);
 		zephir_check_call_status();
 		tensor_eig(&result, &_5$$5);
 	}
diff --git a/ext/tensor/decompositions/lu.zep.c b/ext/tensor/decompositions/lu.zep.c
index 85aecdf..39b2774 100644
--- a/ext/tensor/decompositions/lu.zep.c
+++ b/ext/tensor/decompositions/lu.zep.c
@@ -94,12 +94,12 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -110,7 +110,7 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_4, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, a, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_lu(&result, &_4);
 	if (Z_TYPE_P(&result) == IS_NULL) {
diff --git a/ext/tensor/decompositions/svd.zep.c b/ext/tensor/decompositions/svd.zep.c
index 324a545..34d89cf 100644
--- a/ext/tensor/decompositions/svd.zep.c
+++ b/ext/tensor/decompositions/svd.zep.c
@@ -85,7 +85,7 @@ PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_0, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_svd(&result, &_0);
 	if (Z_TYPE_P(&result) == IS_NULL) {
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index c55d70e..20355cf 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -1278,7 +1278,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &index_param);
 	ZVAL_LONG(&_0, index);
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "offsetget", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "offsetGet", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1355,12 +1355,12 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -1520,7 +1520,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			}
 			i = _2;
 			ZVAL_LONG(&_5$$3, i);
-			ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "columnasvector", &_6, 0, &_5$$3);
+			ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "columnAsVector", &_6, 0, &_5$$3);
 			zephir_check_call_status();
 			zephir_array_append(&vectors, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 553);
 		}
@@ -1913,12 +1913,12 @@ PHP_METHOD(Tensor_Matrix, inverse)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -1928,7 +1928,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&_4, this_ptr, "fullrank", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, this_ptr, "fullRank", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_4))) {
 		ZEPHIR_INIT_VAR(&_5$$4);
@@ -2030,12 +2030,12 @@ PHP_METHOD(Tensor_Matrix, det)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -2049,7 +2049,7 @@ PHP_METHOD(Tensor_Matrix, det)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_4, &ref, "a", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_5, &_4, "diagonalasvector", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_5, &_4, "diagonalAsVector", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&pi, &_5, "product", NULL, 0);
 	zephir_check_call_status();
@@ -2078,7 +2078,7 @@ PHP_METHOD(Tensor_Matrix, trace)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "diagonalasvector", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "diagonalAsVector", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_METHOD(&_0, "sum", NULL, 0);
 	zephir_check_call_status();
@@ -2121,7 +2121,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_1, &_0, "a", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_2, &_1, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_2, &_1, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_get_arrval(&_3, &_2);
 	ZEPHIR_CPY_WRT(&a, &_3);
@@ -2255,7 +2255,7 @@ PHP_METHOD(Tensor_Matrix, symmetric)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (!(zephir_is_true(&_0))) {
 		RETURN_MM_BOOL(0);
@@ -2374,7 +2374,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_matmul(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_8);
@@ -2440,12 +2440,12 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&_9, b, "ascolumnmatrix", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_9, b, "asColumnMatrix", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_8, this_ptr, "matmul", NULL, 0, &_9);
 	zephir_check_call_status();
 	ZVAL_LONG(&_10, 0);
-	ZEPHIR_RETURN_CALL_METHOD(&_8, "columnasvector", NULL, 0, &_10);
+	ZEPHIR_RETURN_CALL_METHOD(&_8, "columnAsVector", NULL, 0, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2544,7 +2544,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 	}
 	ZEPHIR_INIT_VAR(&_11);
 	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_13, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_13, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_LONG(&_14, stride);
 	tensor_convolve_2d(&_11, &_12, &_13, &_14);
@@ -2828,15 +2828,15 @@ PHP_METHOD(Tensor_Matrix, multiply)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplymatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplycolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2844,7 +2844,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2899,15 +2899,15 @@ PHP_METHOD(Tensor_Matrix, divide)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividematrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividecolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividevector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2915,7 +2915,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividescalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2971,15 +2971,15 @@ PHP_METHOD(Tensor_Matrix, add)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2987,7 +2987,7 @@ PHP_METHOD(Tensor_Matrix, add)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3043,15 +3043,15 @@ PHP_METHOD(Tensor_Matrix, subtract)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3059,7 +3059,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3115,15 +3115,15 @@ PHP_METHOD(Tensor_Matrix, pow)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3131,7 +3131,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3187,15 +3187,15 @@ PHP_METHOD(Tensor_Matrix, mod)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3203,7 +3203,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3259,15 +3259,15 @@ PHP_METHOD(Tensor_Matrix, equal)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3275,7 +3275,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3331,15 +3331,15 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3347,7 +3347,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3403,15 +3403,15 @@ PHP_METHOD(Tensor_Matrix, greater)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatermatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatercolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatervector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3419,7 +3419,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3475,15 +3475,15 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3491,7 +3491,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3547,15 +3547,15 @@ PHP_METHOD(Tensor_Matrix, less)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lesscolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3563,7 +3563,7 @@ PHP_METHOD(Tensor_Matrix, less)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3619,15 +3619,15 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_2; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalcolumnvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualColumnVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_2: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -3635,7 +3635,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -3681,7 +3681,7 @@ PHP_METHOD(Tensor_Matrix, reciprocal)
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_SELF(&_0, "ones", NULL, 0, &_1, &_2);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "dividematrix", NULL, 0, this_ptr);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "divideMatrix", NULL, 0, this_ptr);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3722,7 +3722,7 @@ PHP_METHOD(Tensor_Matrix, square)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplymatrix", NULL, 0, this_ptr);
+	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyMatrix", NULL, 0, this_ptr);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4353,7 +4353,7 @@ PHP_METHOD(Tensor_Matrix, mean)
 	ZEPHIR_CALL_METHOD(&_0, this_ptr, "sum", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "dividescalar", NULL, 0, &_1);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "divideScalar", NULL, 0, &_1);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4746,14 +4746,14 @@ PHP_METHOD(Tensor_Matrix, variance)
 		ZEPHIR_CALL_METHOD(mean, this_ptr, "mean", NULL, 0);
 		zephir_check_call_status();
 	}
-	ZEPHIR_CALL_METHOD(&_11, this_ptr, "subtractcolumnvector", NULL, 0, mean);
+	ZEPHIR_CALL_METHOD(&_11, this_ptr, "subtractColumnVector", NULL, 0, mean);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_12, &_11, "square", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_13, &_12, "sum", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_14, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_13, "dividescalar", NULL, 0, &_14);
+	ZEPHIR_RETURN_CALL_METHOD(&_13, "divideScalar", NULL, 0, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4835,14 +4835,14 @@ PHP_METHOD(Tensor_Matrix, covariance)
 		ZEPHIR_CALL_METHOD(mean, this_ptr, "mean", NULL, 0);
 		zephir_check_call_status();
 	}
-	ZEPHIR_CALL_METHOD(&b, this_ptr, "subtractcolumnvector", NULL, 0, mean);
+	ZEPHIR_CALL_METHOD(&b, this_ptr, "subtractColumnVector", NULL, 0, mean);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_9, &b, "transpose", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_8, &b, "matmul", NULL, 0, &_9);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_8, "dividescalar", NULL, 0, &_10);
+	ZEPHIR_RETURN_CALL_METHOD(&_8, "divideScalar", NULL, 0, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6181,7 +6181,7 @@ PHP_METHOD(Tensor_Matrix, augmentAbove)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_10);
-	ZEPHIR_CALL_METHOD(&_11, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_fast_array_merge(&_10, &_11, &_12);
@@ -6265,7 +6265,7 @@ PHP_METHOD(Tensor_Matrix, augmentBelow)
 	}
 	ZEPHIR_INIT_VAR(&_10);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_12, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_12, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_fast_array_merge(&_10, &_11, &_12);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_10);
@@ -6343,7 +6343,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_INIT_VAR(&_12);
@@ -6426,7 +6426,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 		return;
 	}
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_11, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&_12);
 	ZVAL_STRING(&_12, "array_merge");
@@ -6621,9 +6621,9 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -6635,7 +6635,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -6753,9 +6753,9 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -6767,7 +6767,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -6885,9 +6885,9 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -6899,7 +6899,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7017,9 +7017,9 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7031,7 +7031,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7150,9 +7150,9 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7164,7 +7164,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7283,9 +7283,9 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7297,7 +7297,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7416,9 +7416,9 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7430,7 +7430,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7548,9 +7548,9 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7562,7 +7562,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7681,9 +7681,9 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7695,7 +7695,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7814,9 +7814,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7828,7 +7828,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -7946,9 +7946,9 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -7960,7 +7960,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -8078,9 +8078,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 	if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_0, &_1))) {
 		ZEPHIR_INIT_VAR(&_2$$3);
 		object_init_ex(&_2$$3, tensor_exceptions_dimensionalitymismatch_ce);
-		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "shapeString", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$3, b, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
@@ -8092,7 +8092,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_6) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_8);
@@ -8226,7 +8226,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8346,7 +8346,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8466,7 +8466,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8586,7 +8586,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8706,7 +8706,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8826,7 +8826,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -8947,7 +8947,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9067,7 +9067,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9187,7 +9187,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9307,7 +9307,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9427,7 +9427,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9548,7 +9548,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	if (Z_TYPE_P(&_8) == IS_STRING) {
@@ -9674,7 +9674,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -9814,7 +9814,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -9954,7 +9954,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10094,7 +10094,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10234,7 +10234,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10374,7 +10374,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10514,7 +10514,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10654,7 +10654,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10794,7 +10794,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -10934,7 +10934,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -11074,7 +11074,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -11214,7 +11214,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -12482,7 +12482,7 @@ PHP_METHOD(Tensor_Matrix, getIterator)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	object_init_ex(return_value, spl_ce_ArrayIterator);
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asvectors", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asVectors", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &_0);
 	zephir_check_call_status();
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index c63a2c4..af701fb 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -80,7 +80,7 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_0, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_ref(&result, &_0);
 	if (Z_TYPE_P(&result) == IS_NULL) {
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index cf2e07f..f6f0058 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -111,7 +111,7 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_3, &_2, "a", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_4, &_3, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, &_3, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_get_arrval(&_5, &_4);
 	ZEPHIR_CPY_WRT(&b, &_5);
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index e20167e..da3b454 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -1320,7 +1320,7 @@ PHP_METHOD(Tensor_Vector, dot)
 		return;
 	}
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_9, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_9, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_dot(return_value, &_8, &_9);
 	RETURN_MM();
@@ -1406,7 +1406,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_LONG(&_11, stride);
 	tensor_convolve_1d(&_8, &_9, &_10, &_11);
@@ -1436,7 +1436,7 @@ PHP_METHOD(Tensor_Vector, matmul)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b);
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asrowmatrix", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asRowMatrix", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_METHOD(&_0, "matmul", NULL, 0, b);
 	zephir_check_call_status();
@@ -1516,7 +1516,7 @@ PHP_METHOD(Tensor_Vector, outer)
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_0, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	zephir_get_arrval(&_1, &_0);
 	ZEPHIR_CPY_WRT(&bHat, &_1);
@@ -1700,7 +1700,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 	ZEPHIR_CALL_METHOD(&_4, this_ptr, "abs", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_6, p);
-	ZEPHIR_CALL_METHOD(&_5, &_4, "powscalar", NULL, 0, &_6);
+	ZEPHIR_CALL_METHOD(&_5, &_4, "powScalar", NULL, 0, &_6);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_7, &_5, "sum", NULL, 0);
 	zephir_check_call_status();
@@ -1772,11 +1772,11 @@ PHP_METHOD(Tensor_Vector, multiply)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplymatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -1784,7 +1784,7 @@ PHP_METHOD(Tensor_Vector, multiply)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -1838,11 +1838,11 @@ PHP_METHOD(Tensor_Vector, divide)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividematrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividevector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -1850,7 +1850,7 @@ PHP_METHOD(Tensor_Vector, divide)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dividescalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "divideScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -1905,11 +1905,11 @@ PHP_METHOD(Tensor_Vector, add)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -1917,7 +1917,7 @@ PHP_METHOD(Tensor_Vector, add)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -1972,11 +1972,11 @@ PHP_METHOD(Tensor_Vector, subtract)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -1984,7 +1984,7 @@ PHP_METHOD(Tensor_Vector, subtract)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "subtractScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2039,11 +2039,11 @@ PHP_METHOD(Tensor_Vector, pow)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2051,7 +2051,7 @@ PHP_METHOD(Tensor_Vector, pow)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "powScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2106,11 +2106,11 @@ PHP_METHOD(Tensor_Vector, mod)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2118,7 +2118,7 @@ PHP_METHOD(Tensor_Vector, mod)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "modScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2173,11 +2173,11 @@ PHP_METHOD(Tensor_Vector, equal)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2185,7 +2185,7 @@ PHP_METHOD(Tensor_Vector, equal)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "equalScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2240,11 +2240,11 @@ PHP_METHOD(Tensor_Vector, notEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2252,7 +2252,7 @@ PHP_METHOD(Tensor_Vector, notEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2307,11 +2307,11 @@ PHP_METHOD(Tensor_Vector, greater)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatermatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greatervector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2319,7 +2319,7 @@ PHP_METHOD(Tensor_Vector, greater)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2374,11 +2374,11 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2386,7 +2386,7 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "greaterEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2441,11 +2441,11 @@ PHP_METHOD(Tensor_Vector, less)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2453,7 +2453,7 @@ PHP_METHOD(Tensor_Vector, less)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2508,11 +2508,11 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 		if (_1$$3 == zephir_instance_of_ev(b, tensor_vector_ce)) { goto zephir_switch_1_clause_1; }
 		goto zephir_switch_1_end;
 		zephir_switch_1_clause_0: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalmatrix", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualMatrix", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_clause_1: ;
-			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalvector", NULL, 0, b);
+			ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualVector", NULL, 0, b);
 			zephir_check_call_status();
 			RETURN_MM();
 		zephir_switch_1_end: ;
@@ -2520,7 +2520,7 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 		goto zephir_switch_0_end;
 	zephir_switch_0_clause_1: ;
 	zephir_switch_0_clause_2: ;
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessequalscalar", NULL, 0, b);
+		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "lessEqualScalar", NULL, 0, b);
 		zephir_check_call_status();
 		RETURN_MM();
 	zephir_switch_0_end: ;
@@ -2560,7 +2560,7 @@ PHP_METHOD(Tensor_Vector, reciprocal)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_STATIC(&_0, "ones", NULL, 0, &_1);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "dividevector", NULL, 0, this_ptr);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "divideVector", NULL, 0, this_ptr);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2601,7 +2601,7 @@ PHP_METHOD(Tensor_Vector, square)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyvector", NULL, 0, this_ptr);
+	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "multiplyVector", NULL, 0, this_ptr);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3328,7 +3328,7 @@ PHP_METHOD(Tensor_Vector, variance)
 		ZEPHIR_CALL_METHOD(mean, this_ptr, "mean", NULL, 0);
 		zephir_check_call_status();
 	}
-	ZEPHIR_CALL_METHOD(&_4, this_ptr, "subtractscalar", NULL, 0, mean);
+	ZEPHIR_CALL_METHOD(&_4, this_ptr, "subtractScalar", NULL, 0, mean);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_5, &_4, "square", NULL, 0);
 	zephir_check_call_status();
@@ -4058,7 +4058,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4180,7 +4180,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4302,7 +4302,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4424,7 +4424,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4546,7 +4546,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4668,7 +4668,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4790,7 +4790,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4912,7 +4912,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5034,7 +5034,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5156,7 +5156,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5278,7 +5278,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5400,7 +5400,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5514,7 +5514,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_multiply(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5586,7 +5586,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_divide(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5658,7 +5658,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_add(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5730,7 +5730,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_subtract(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5802,7 +5802,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_pow(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5874,7 +5874,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_mod(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -5947,7 +5947,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_equal(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -6019,7 +6019,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_not_equal(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -6091,7 +6091,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_greater(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -6163,7 +6163,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_greater_equal(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -6235,7 +6235,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_less(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
@@ -6307,7 +6307,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
 	zephir_check_call_status();
 	tensor_less_equal(&_8, &_9, &_10);
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
diff --git a/ext/tensor_ext.c b/ext/tensor_ext.c
index e04cba5..db60dd0 100644
--- a/ext/tensor_ext.c
+++ b/ext/tensor_ext.c
@@ -54,6 +54,18 @@ PHP_INI_BEGIN()
 	
 PHP_INI_END()
 
+/**
+ * Directives whose globals are put back to their php.ini value at the start
+ * of every request. globals_set() writes the struct member directly, so the
+ * engine cannot restore it the way it restores an ini_set(); without this the
+ * value would survive into the next request. Module-scoped globals are
+ * deliberately absent: they are set up once per process.
+ */
+static const char *const zephir_request_ini_entries[] = {
+	
+	NULL
+};
+
 static PHP_MINIT_FUNCTION(tensor_ext)
 {
 	REGISTER_INI_ENTRIES();
@@ -142,6 +154,7 @@ static PHP_RINIT_FUNCTION(tensor_ext)
 	tensor_ext_globals_ptr = ZEPHIR_VGLOBAL;
 
 	php_zephir_init_globals(tensor_ext_globals_ptr);
+	zephir_ini_activate_globals(zephir_request_ini_entries);
 	zephir_initialize_memory(tensor_ext_globals_ptr);
 
 	

From b10bebc01439129caf547e9ebd3a7bec534e1500 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 15:44:35 -0500
Subject: [PATCH 04/51] Save game

---
 CHANGELOG.md                              |   6 +-
 benchmarks/Buffer/TensorBufferBench.php   |  90 ++++++
 config.json                               |   6 +-
 docs/TensorBuffer.md                      |  68 +++++
 docs/index.md                             |   3 +
 ext/config.m4                             |   4 +-
 ext/config.w32                            |   4 +-
 ext/include/buffer.c                      | 115 ++++++++
 ext/include/buffer.h                      |  14 +
 ext/php_tensor_ext.h                      |   2 +-
 ext/tensor/tensorbuffer.zep.c             | 331 ++++++++++++++++++++++
 ext/tensor/tensorbuffer.zep.h             |  63 ++++
 ext/tensor_ext.c                          |   3 +
 ext/tensor_ext.h                          |   1 +
 optimizers/TensorBufferSliceOptimizer.php |  76 +++++
 optimizers/TensorBufferSortOptimizer.php  |  76 +++++
 phpstan.neon                              |   2 +
 stubs/TensorBuffer.stub                   |  74 +++++
 tensor/tensorbuffer.zep                   | 125 ++++++++
 tests/TensorBufferTest.php                | 213 ++++++++++++++
 20 files changed, 1269 insertions(+), 7 deletions(-)
 create mode 100644 benchmarks/Buffer/TensorBufferBench.php
 create mode 100644 docs/TensorBuffer.md
 create mode 100644 ext/include/buffer.c
 create mode 100644 ext/include/buffer.h
 create mode 100644 ext/tensor/tensorbuffer.zep.c
 create mode 100644 ext/tensor/tensorbuffer.zep.h
 create mode 100644 optimizers/TensorBufferSliceOptimizer.php
 create mode 100644 optimizers/TensorBufferSortOptimizer.php
 create mode 100644 stubs/TensorBuffer.stub
 create mode 100644 tensor/tensorbuffer.zep
 create mode 100644 tests/TensorBufferTest.php

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 764ede1..6ac5500 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,9 @@
 # Change Log
 
-- 3.1.1
-    - Just triggering the first Packagist release
+- 3.2.0
+    - Added the `TensorBuffer` decorator class wrapping the kernel `Buffer`
+    - Added in-place `sort()` (ascending or descending) operating on the buffer's raw pointer
+    - Added `slice()` returning a new buffer without materialising a PHP array
 
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
diff --git a/benchmarks/Buffer/TensorBufferBench.php b/benchmarks/Buffer/TensorBufferBench.php
new file mode 100644
index 0000000..be53df7
--- /dev/null
+++ b/benchmarks/Buffer/TensorBufferBench.php
@@ -0,0 +1,90 @@
+<?php
+
+namespace Tensor\Benchmarks\Buffer;
+
+use Tensor\Buffer;
+use Tensor\TensorBuffer;
+
+/**
+ * @Groups({"Buffer"})
+ * @BeforeMethods({"setUp"})
+ */
+class TensorBufferBench
+{
+    /**
+     * @var TensorBuffer
+     */
+    protected $buffer;
+
+    /**
+     * @var int
+     */
+    protected $offset;
+
+    /**
+     * @var int
+     */
+    protected $length;
+
+    public function setUp() : void
+    {
+        $a = [];
+
+        for ($i = 0; $i < 10000; ++$i) {
+            $a[] = ($i * 31) % 10000;
+        }
+
+        $this->buffer = new TensorBuffer(Buffer::fromArray($a));
+
+        $this->offset = 2500;
+        $this->length = 5000;
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function sort() : void
+    {
+        $this->buffer->sort();
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function sortNative() : void
+    {
+        $a = $this->buffer->toArray();
+
+        sort($a);
+
+        $this->buffer = new TensorBuffer(Buffer::fromArray($a));
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function slice() : void
+    {
+        $this->buffer->slice($this->offset, $this->length);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function sliceNative() : void
+    {
+        $a = $this->buffer->toArray();
+
+        $a = array_slice($a, $this->offset, $this->length);
+
+        new TensorBuffer(Buffer::fromArray($a));
+    }
+}
diff --git a/config.json b/config.json
index 2027c01..92ef75d 100644
--- a/config.json
+++ b/config.json
@@ -4,12 +4,13 @@
     "extension-name": "tensor_ext",
     "description": "Scientific computing for the PHP language.",
     "author": "The Rubix ML Community",
-    "version": "3.1.1",
+    "version": "3.2.0",
     "verbose": true,
     "extra-cflags": "-O3",
     "extra-libs": "-lopenblas -llapacke -lgfortran",
     "extra-sources": [
         "include/arithmetic.c",
+        "include/buffer.c",
         "include/comparison.c",
         "include/linear_algebra.c",
         "include/signal_processing.c",
@@ -20,6 +21,9 @@
             {
                 "include": "cblas.h",
                 "code": "openblas_set_num_threads(1)"
+            },
+            {
+                "code": "extern zend_class_entry *tensor_buffer_ce; extern zend_class_entry *zephir_buffer_ce; tensor_buffer_ce = zephir_buffer_ce;"
             }
         ]
     },
diff --git a/docs/TensorBuffer.md b/docs/TensorBuffer.md
new file mode 100644
index 0000000..7af8c82
--- /dev/null
+++ b/docs/TensorBuffer.md
@@ -0,0 +1,68 @@
+# TensorBuffer
+
+A decorator that wraps the kernel `Buffer` class and adds higher-level operations such as sorting and slicing.
+
+- **Namespace:** `Tensor\TensorBuffer`
+
+## Overview
+
+The Zephir kernel `Buffer` (`Tensor\Buffer`) is an ordinary refcounted object that stores its elements in one contiguous C array of `double` or `zend_long`. It exposes a minimal PHP API — construction, `fromArray()` / `toArray()`, `count()`, `type()`, `fill()`, and array access — but no sorting or slicing.
+
+`TensorBuffer` composes a `Buffer` and delegates to it, adding operations that cannot be expressed through the minimal API. Those operations are implemented in C over the buffer's raw element pointers (`qsort`, `memcpy`), so no intermediate PHP array is materialised.
+
+`sort()` mutates the wrapped buffer in place; `slice()` returns a **new** `TensorBuffer` wrapping a new buffer, leaving the source untouched.
+
+## Constructors
+
+### `__construct(Buffer $buffer)`
+
+Wrap an existing buffer.
+
+- **Parameters:** `$buffer` — the `Tensor\Buffer` to decorate
+
+## Methods
+
+### `asBuffer() : Buffer`
+
+Return the underlying buffer being decorated.
+
+### `count() : int`
+
+Return the number of elements in the buffer.
+
+### `type() : int`
+
+Return the element type of the buffer — `Buffer::TYPE_DOUBLE` or `Buffer::TYPE_LONG`.
+
+### `toArray() : array`
+
+Return the buffer as a PHP array.
+
+### `get(int $index) : mixed`
+
+Return the element at the given index.
+
+- **Throws:** `Tensor\Exceptions\RuntimeException` (or `OutOfBoundsException` on PHP 8.4+) if the index is out of range
+
+### `set(int $index, mixed $value) : void`
+
+Set the element at the given index, cast to the buffer's element type.
+
+- **Throws:** `Tensor\Exceptions\RuntimeException` (or `OutOfBoundsException` on PHP 8.4+) if the index is out of range
+
+### `sort(bool $ascending = true) : void`
+
+Sort the buffer **in place**.
+
+- **Parameters:** `$ascending` — sort ascending when `true`, descending when `false` (default `true`)
+
+### `slice(int $offset, int $length) : TensorBuffer`
+
+Return a new decorator wrapping a new buffer of `$length` elements copied from `buffer[$offset .. $offset + $length - 1]`. The source buffer is left unchanged.
+
+- **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$offset` or `$length` is negative, or the requested range exceeds the buffer size
+
+## Notes
+
+- `sort()` and `slice()` are implemented in C (`ext/include/buffer.c`) and route through this class's optimizer calls, operating directly on the buffer's raw pointer.
+- Both element kinds (`TYPE_DOUBLE` and `TYPE_LONG`) are supported; `slice()` preserves the source kind.
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
index bce0b0c..89d729d 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -10,6 +10,8 @@ Tensor \
 ├── Vector
 ├── ColumnVector (extends Vector)
 ├── Matrix
+├── Buffer (kernel class)
+├── TensorBuffer (decorates Buffer)
 │
 ├── ArrayLike (interface)
 ├── Arithmetic (interface)
@@ -36,6 +38,7 @@ Tensor \
 | [Vector](Vector.md) | A one dimensional (rank 1) tensor with integer and/or floating point elements. |
 | [ColumnVector](ColumnVector.md) | A vertical one dimensional tensor; extends `Vector` with matrix-facing operations. |
 | [Matrix](Matrix.md) | A two dimensional (rank 2) tensor with integer and/or floating point elements. |
+| [TensorBuffer](TensorBuffer.md) | A decorator that wraps the kernel `Buffer` class and adds sorting and slicing. |
 
 ## Interfaces
 
diff --git a/ext/config.m4 b/ext/config.m4
index b6a9085..a92b929 100644
--- a/ext/config.m4
+++ b/ext/config.m4
@@ -31,7 +31,9 @@ if test "$PHP_TENSOR_EXT" = "yes"; then
 	tensor/matrix.zep.c
 	tensor/reductions/ref.zep.c
 	tensor/reductions/rref.zep.c
-	tensor/settings.zep.c include/arithmetic.c
+	tensor/settings.zep.c
+	tensor/tensorbuffer.zep.c include/arithmetic.c
+	include/buffer.c
 	include/comparison.c
 	include/linear_algebra.c
 	include/signal_processing.c
diff --git a/ext/config.w32 b/ext/config.w32
index 2431b48..6fefafe 100644
--- a/ext/config.w32
+++ b/ext/config.w32
@@ -9,8 +9,8 @@ if (PHP_TENSOR_EXT != "no") {
     ADD_EXTENSION_DEP("tensor_ext", "json");
     AC_DEFINE("ZEPHIR_USE_PHP_JSON", 1, "Whether PHP json extension is present at compile time");
   }
-  ADD_SOURCES(configure_module_dirname + "/include", "arithmetic.c comparison.c linear_algebra.c signal_processing.c settings.c", "tensor_ext");
-  ADD_SOURCES(configure_module_dirname + "/tensor", "algebraic.zep.c arithmetic.zep.c arraylike.zep.c comparable.zep.c special.zep.c statistical.zep.c trigonometric.zep.c tensor.zep.c vector.zep.c columnvector.zep.c matrix.zep.c settings.zep.c", "tensor_ext");
+  ADD_SOURCES(configure_module_dirname + "/include", "arithmetic.c buffer.c comparison.c linear_algebra.c signal_processing.c settings.c", "tensor_ext");
+  ADD_SOURCES(configure_module_dirname + "/tensor", "algebraic.zep.c arithmetic.zep.c arraylike.zep.c comparable.zep.c special.zep.c statistical.zep.c trigonometric.zep.c tensor.zep.c vector.zep.c columnvector.zep.c matrix.zep.c settings.zep.c tensorbuffer.zep.c", "tensor_ext");
 	ADD_SOURCES(configure_module_dirname + "/tensor/exceptions", "tensorexception.zep.c invalidargumentexception.zep.c runtimeexception.zep.c dimensionalitymismatch.zep.c singularmatrix.zep.c", "tensor_ext");
 	ADD_SOURCES(configure_module_dirname + "/tensor/decompositions", "cholesky.zep.c eigen.zep.c lu.zep.c svd.zep.c", "tensor_ext");
 	ADD_SOURCES(configure_module_dirname + "/tensor/reductions", "ref.zep.c rref.zep.c", "tensor_ext");
diff --git a/ext/include/buffer.c b/ext/include/buffer.c
new file mode 100644
index 0000000..6c43af7
--- /dev/null
+++ b/ext/include/buffer.c
@@ -0,0 +1,115 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <php.h>
+#include <stdlib.h>
+#include <ext/spl/spl_exceptions.h>
+#include "kernel/main.h"
+#include "kernel/buffer.h"
+#include "kernel/exception.h"
+#include "kernel/operators.h"
+
+#ifdef ZEPHIR_BUFFER_ENABLED
+
+zend_class_entry * tensor_buffer_ce;
+
+static int tensor_double_cmp(const void * a, const void * b)
+{
+	double da = *(const double *) a;
+	double db = *(const double *) b;
+
+	return (da > db) - (da < db);
+}
+
+static int tensor_double_cmp_desc(const void * a, const void * b)
+{
+	return tensor_double_cmp(b, a);
+}
+
+static int tensor_long_cmp(const void * a, const void * b)
+{
+	zend_long la = *(const zend_long *) a;
+	zend_long lb = *(const zend_long *) b;
+
+	return (la > lb) - (la < lb);
+}
+
+static int tensor_long_cmp_desc(const void * a, const void * b)
+{
+	return tensor_long_cmp(b, a);
+}
+
+/**
+ * Sort the elements of a Buffer in place.
+ *
+ * @param return_value
+ * @param obj
+ * @param ascending
+ */
+void tensor_buffer_sort(zval * return_value, zval * obj, zval * ascending)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+	int ascending_order = zend_is_true(ascending);
+
+	if (UNEXPECTED(kind == 0 || len < 2)) {
+		RETURN_NULL();
+	}
+
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		qsort((void *) zephir_buffer_longs(obj), (size_t) len, sizeof(zend_long),
+			ascending_order ? tensor_long_cmp : tensor_long_cmp_desc);
+	} else {
+		qsort((void *) zephir_buffer_doubles(obj), (size_t) len, sizeof(double),
+			ascending_order ? tensor_double_cmp : tensor_double_cmp_desc);
+	}
+
+	RETURN_NULL();
+}
+
+/**
+ * Return a new Buffer populated with a slice of the given buffer.
+ *
+ * @param return_value
+ * @param obj
+ * @param offset
+ * @param length
+ */
+void tensor_buffer_slice(zval * return_value, zval * obj, zval * offset, zval * length)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+	zend_long offsetHat = zephir_get_intval(offset);
+	zend_long lengthHat = zephir_get_intval(length);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (UNEXPECTED(offsetHat < 0 || lengthHat < 0 || offsetHat > len - lengthHat)) {
+		zephir_throw_exception_string(spl_ce_OutOfBoundsException,
+			SL("Slice offset and length must be within the bounds of the buffer."));
+		return;
+	}
+
+	if (UNEXPECTED(zephir_buffer_create(return_value, lengthHat, kind) == FAILURE)) {
+		return;
+	}
+
+	if (lengthHat == 0) {
+		return;
+	}
+
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		memcpy(zephir_buffer_longs(return_value), zephir_buffer_longs(obj) + offsetHat,
+			(size_t) lengthHat * sizeof(zend_long));
+	} else {
+		memcpy(zephir_buffer_doubles(return_value), zephir_buffer_doubles(obj) + offsetHat,
+			(size_t) lengthHat * sizeof(double));
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/ext/include/buffer.h b/ext/include/buffer.h
new file mode 100644
index 0000000..784f50e
--- /dev/null
+++ b/ext/include/buffer.h
@@ -0,0 +1,14 @@
+#ifndef TENSOR_BUFFER_H
+#define TENSOR_BUFFER_H
+
+#include <Zend/zend.h>
+
+/* The Zephir compiler emits references to `tensor_buffer_ce` for the kernel
+ * `Tensor\Buffer` class even though the kernel registers and exports it as
+ * `zephir_buffer_ce`. Alias the two (see config.json module initializer). */
+extern zend_class_entry * tensor_buffer_ce;
+
+void tensor_buffer_sort(zval * return_value, zval * obj, zval * ascending);
+void tensor_buffer_slice(zval * return_value, zval * obj, zval * offset, zval * length);
+
+#endif
\ No newline at end of file
diff --git a/ext/php_tensor_ext.h b/ext/php_tensor_ext.h
index 6bd45f8..603d87c 100644
--- a/ext/php_tensor_ext.h
+++ b/ext/php_tensor_ext.h
@@ -11,7 +11,7 @@
 #include "kernel/globals.h"
 
 #define PHP_TENSOR_EXT_NAME        "tensor"
-#define PHP_TENSOR_EXT_VERSION     "3.1.1"
+#define PHP_TENSOR_EXT_VERSION     "3.2.0"
 #define PHP_TENSOR_EXT_EXTNAME     "tensor_ext"
 #define PHP_TENSOR_EXT_AUTHOR      "The Rubix ML Community"
 #define PHP_TENSOR_EXT_ZEPVERSION  "1.5.0-$Id$"
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
new file mode 100644
index 0000000..781a79a
--- /dev/null
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -0,0 +1,331 @@
+
+#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/object.h"
+#include "kernel/memory.h"
+#include "kernel/fcall.h"
+#include "kernel/array.h"
+#include "kernel/operators.h"
+#include "kernel/exception.h"
+#include "kernel/concat.h"
+#include "include/buffer.h"
+
+
+/**
+ * TensorBuffer
+ *
+ * A decorator that wraps the kernel Buffer class and provides additional
+ * operations such as sorting and slicing.
+ *
+ * @category    Scientific Computing
+ * @package     Rubix/Tensor
+ * @author      Andrew DalPino
+ */
+ZEPHIR_INIT_CLASS(Tensor_TensorBuffer)
+{
+	ZEPHIR_REGISTER_CLASS(Tensor, TensorBuffer, tensor, tensorbuffer, tensor_tensorbuffer_method_entry, 0);
+
+	/**
+	 * The underlying buffer being decorated.
+	 *
+	 * @var \Tensor\Buffer
+	 */
+	zend_declare_property_null(tensor_tensorbuffer_ce, SL("buffer"), ZEND_ACC_PROTECTED);
+	return SUCCESS;
+}
+
+/**
+ * @param \Tensor\Buffer buffer
+ */
+PHP_METHOD(Tensor_TensorBuffer, __construct)
+{
+	zval *buffer, buffer_sub;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&buffer_sub);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_OBJECT_OF_CLASS(buffer, tensor_buffer_ce)
+	ZEND_PARSE_PARAMETERS_END();
+	zephir_fetch_params_without_memory_grow(1, 0, &buffer);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 20, buffer);
+}
+
+/**
+ * Return the underlying buffer.
+ *
+ * @return \Tensor\Buffer
+ */
+PHP_METHOD(Tensor_TensorBuffer, asBuffer)
+{
+
+	RETURN_MEMBER(getThis(), "buffer");
+}
+
+/**
+ * Return the number of elements in the buffer.
+ *
+ * @return int
+ */
+PHP_METHOD(Tensor_TensorBuffer, count)
+{
+	zval _0;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "count", NULL, 0);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return the element type of the buffer.
+ *
+ * @return int
+ */
+PHP_METHOD(Tensor_TensorBuffer, type)
+{
+	zval _0;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "type", NULL, 0);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return the buffer as a PHP array.
+ *
+ * @return list<float>
+ */
+PHP_METHOD(Tensor_TensorBuffer, toArray)
+{
+	zval _0;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return the element at the given index.
+ *
+ * @param int index
+ * @return mixed
+ */
+PHP_METHOD(Tensor_TensorBuffer, get)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zval *index_param = NULL, _0, _1;
+	zend_long index;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_LONG(index)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &index_param);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	zephir_memory_observe(&_1);
+	zephir_array_fetch_long(&_1, &_0, index, PH_NOISY, "tensor/tensorbuffer.zep", 80);
+	RETURN_CCTOR(&_1);
+}
+
+/**
+ * Set the element at the given index.
+ *
+ * @param int index
+ * @param mixed value
+ * @return void
+ */
+PHP_METHOD(Tensor_TensorBuffer, set)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zval *index_param = NULL, *value, value_sub, _0;
+	zend_long index;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&value_sub);
+	ZVAL_UNDEF(&_0);
+	ZEND_PARSE_PARAMETERS_START(2, 2)
+		Z_PARAM_LONG(index)
+		Z_PARAM_ZVAL(value)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 2, 0, &index_param, &value);
+	ZEPHIR_INIT_VAR(&_0);
+	ZVAL_LONG(&_0, index);
+	zephir_update_property_array(this_ptr, SL("buffer"), &_0, value);
+	ZEPHIR_MM_RESTORE();
+}
+
+/**
+ * Sort the buffer in place.
+ *
+ * @param bool ascending
+ * @return void
+ */
+PHP_METHOD(Tensor_TensorBuffer, sort)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zval *ascending_param = NULL, status, _0, _1;
+	zend_bool ascending;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&status);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(0, 1)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_BOOL(ascending)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 0, 1, &ascending_param);
+	if (!ascending_param) {
+		ascending = 1;
+	} else {
+		}
+	ZEPHIR_INIT_VAR(&status);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	if (ascending) {
+		ZVAL_BOOL(&_1, 1);
+	} else {
+		ZVAL_BOOL(&_1, 0);
+	}
+	tensor_buffer_sort(&status, &_0, &_1);
+	ZEPHIR_MM_RESTORE();
+}
+
+/**
+ * Return a slice of the buffer as a new decorator.
+ *
+ * @param int offset
+ * @param int length
+ * @throws \Tensor\Exceptions\InvalidArgumentException
+ * @return self
+ */
+PHP_METHOD(Tensor_TensorBuffer, slice)
+{
+	zval _5$$3;
+	zend_bool _0, _1;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zval *offset_param = NULL, *length_param = NULL, _2, _3, b, _6, _7, _8, _4$$3;
+	zend_long offset, length, ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_5$$3);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(2, 2)
+		Z_PARAM_LONG(offset)
+		Z_PARAM_LONG(length)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 2, 0, &offset_param, &length_param);
+	_0 = offset < 0;
+	if (!(_0)) {
+		_0 = length < 0;
+	}
+	_1 = _0;
+	if (!(_1)) {
+		zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+		ZEPHIR_CALL_METHOD(&_3, &_2, "count", NULL, 0);
+		zephir_check_call_status();
+		_1 = offset > (zephir_get_numberval(&_3) - length);
+	}
+	if (UNEXPECTED(_1)) {
+		ZEPHIR_INIT_VAR(&_4$$3);
+		object_init_ex(&_4$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_5$$3);
+		ZEPHIR_CONCAT_SS(&_5$$3, "Offset and length", " must be within the bounds of the buffer.");
+		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 3, &_5$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 118);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&b);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_7, offset);
+	ZVAL_LONG(&_8, length);
+	tensor_buffer_slice(&b, &_6, &_7, &_8);
+	object_init_ex(return_value, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 35, &b);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
diff --git a/ext/tensor/tensorbuffer.zep.h b/ext/tensor/tensorbuffer.zep.h
new file mode 100644
index 0000000..acd81ac
--- /dev/null
+++ b/ext/tensor/tensorbuffer.zep.h
@@ -0,0 +1,63 @@
+
+extern zend_class_entry *tensor_tensorbuffer_ce;
+
+ZEPHIR_INIT_CLASS(Tensor_TensorBuffer);
+
+PHP_METHOD(Tensor_TensorBuffer, __construct);
+PHP_METHOD(Tensor_TensorBuffer, asBuffer);
+PHP_METHOD(Tensor_TensorBuffer, count);
+PHP_METHOD(Tensor_TensorBuffer, type);
+PHP_METHOD(Tensor_TensorBuffer, toArray);
+PHP_METHOD(Tensor_TensorBuffer, get);
+PHP_METHOD(Tensor_TensorBuffer, set);
+PHP_METHOD(Tensor_TensorBuffer, sort);
+PHP_METHOD(Tensor_TensorBuffer, slice);
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_tensorbuffer___construct, 0, 0, 1)
+	ZEND_ARG_OBJ_INFO(0, buffer, Tensor\\Buffer, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_asbuffer, 0, 0, Tensor\\Buffer, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_count, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_type, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_toarray, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_tensorbuffer_get, 0, 0, 1)
+	ZEND_ARG_TYPE_INFO(0, index, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_set, 0, 2, IS_VOID, 0)
+
+	ZEND_ARG_TYPE_INFO(0, index, IS_LONG, 0)
+	ZEND_ARG_INFO(0, value)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_sort, 0, 0, IS_VOID, 0)
+
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, ascending, _IS_BOOL, 0, "true")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_slice, 0, 2, Tensor\\TensorBuffer, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEPHIR_INIT_FUNCS(tensor_tensorbuffer_method_entry) {
+	PHP_ME(Tensor_TensorBuffer, __construct, arginfo_tensor_tensorbuffer___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
+	PHP_ME(Tensor_TensorBuffer, asBuffer, arginfo_tensor_tensorbuffer_asbuffer, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, count, arginfo_tensor_tensorbuffer_count, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, type, arginfo_tensor_tensorbuffer_type, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, toArray, arginfo_tensor_tensorbuffer_toarray, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, get, arginfo_tensor_tensorbuffer_get, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, set, arginfo_tensor_tensorbuffer_set, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, sort, arginfo_tensor_tensorbuffer_sort, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, slice, arginfo_tensor_tensorbuffer_slice, ZEND_ACC_PUBLIC)
+	PHP_FE_END
+};
diff --git a/ext/tensor_ext.c b/ext/tensor_ext.c
index db60dd0..7f100a3 100644
--- a/ext/tensor_ext.c
+++ b/ext/tensor_ext.c
@@ -47,6 +47,7 @@ zend_class_entry *tensor_matrix_ce;
 zend_class_entry *tensor_reductions_ref_ce;
 zend_class_entry *tensor_reductions_rref_ce;
 zend_class_entry *tensor_settings_ce;
+zend_class_entry *tensor_tensorbuffer_ce;
 
 ZEND_DECLARE_MODULE_GLOBALS(tensor_ext)
 
@@ -93,7 +94,9 @@ static PHP_MINIT_FUNCTION(tensor_ext)
 	ZEPHIR_INIT(Tensor_Reductions_Ref);
 	ZEPHIR_INIT(Tensor_Reductions_Rref);
 	ZEPHIR_INIT(Tensor_Settings);
+	ZEPHIR_INIT(Tensor_TensorBuffer);
 	openblas_set_num_threads(1);
+	extern zend_class_entry *tensor_buffer_ce; extern zend_class_entry *zephir_buffer_ce; tensor_buffer_ce = zephir_buffer_ce;;
 	return SUCCESS;
 }
 
diff --git a/ext/tensor_ext.h b/ext/tensor_ext.h
index 5919df2..c72baf3 100644
--- a/ext/tensor_ext.h
+++ b/ext/tensor_ext.h
@@ -27,5 +27,6 @@
 #include "tensor/reductions/ref.zep.h"
 #include "tensor/reductions/rref.zep.h"
 #include "tensor/settings.zep.h"
+#include "tensor/tensorbuffer.zep.h"
 
 #endif
\ No newline at end of file
diff --git a/optimizers/TensorBufferSliceOptimizer.php b/optimizers/TensorBufferSliceOptimizer.php
new file mode 100644
index 0000000..c379f87
--- /dev/null
+++ b/optimizers/TensorBufferSliceOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferSliceOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor buffer slice accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_slice($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferSortOptimizer.php b/optimizers/TensorBufferSortOptimizer.php
new file mode 100644
index 0000000..b374183
--- /dev/null
+++ b/optimizers/TensorBufferSortOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferSortOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor buffer sort accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_sort($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/phpstan.neon b/phpstan.neon
index 7b2d639..3e15cde 100644
--- a/phpstan.neon
+++ b/phpstan.neon
@@ -3,3 +3,5 @@ parameters:
     paths:
         - 'tests'
         - 'benchmarks'
+    stubFiles:
+        - 'stubs/TensorBuffer.stub'
diff --git a/stubs/TensorBuffer.stub b/stubs/TensorBuffer.stub
new file mode 100644
index 0000000..f05fb52
--- /dev/null
+++ b/stubs/TensorBuffer.stub
@@ -0,0 +1,74 @@
+<?php
+
+namespace Tensor {
+
+/**
+ * The PHP 8 reflection layer cannot read the default value of the kernel
+ * `Buffer::__construct` / `Buffer::fromArray` `$type` argument
+ * (`ReflectionParameter::isDefaultValueConstant()` throws "Failed to retrieve
+ * the default value"), which makes PHPStan unable to reflect the class and any
+ * class that type-hints it. Declare it statically so static analysis works.
+ */
+final class Buffer implements \ArrayAccess, \Countable, \IteratorAggregate, \JsonSerializable
+{
+    public const TYPE_DOUBLE = 1;
+    public const TYPE_LONG = 2;
+
+    public function __construct(int $size, int $type = self::TYPE_DOUBLE)
+    {
+    }
+
+    public static function fromArray(array $values, int $type = self::TYPE_DOUBLE)
+    {
+    }
+
+    public function toArray() : array
+    {
+    }
+
+    public function type() : int
+    {
+    }
+
+    public function count() : int
+    {
+    }
+
+    public function fill(mixed $value) : void
+    {
+    }
+
+    public function offsetExists(mixed $offset) : bool
+    {
+    }
+
+    public function offsetGet(mixed $offset) : mixed
+    {
+    }
+
+    public function offsetSet(mixed $offset, mixed $value) : void
+    {
+    }
+
+    public function offsetUnset(mixed $offset) : void
+    {
+    }
+
+    public function getIterator() : \Traversable
+    {
+    }
+
+    public function jsonSerialize() : mixed
+    {
+    }
+
+    public function __serialize() : array
+    {
+    }
+
+    public function __unserialize(array $data) : void
+    {
+    }
+}
+
+}
\ No newline at end of file
diff --git a/tensor/tensorbuffer.zep b/tensor/tensorbuffer.zep
new file mode 100644
index 0000000..7a7879e
--- /dev/null
+++ b/tensor/tensorbuffer.zep
@@ -0,0 +1,125 @@
+namespace Tensor;
+
+use Tensor\Exceptions\InvalidArgumentException;
+
+/**
+ * TensorBuffer
+ *
+ * A decorator that wraps the kernel Buffer class and provides additional
+ * operations such as sorting and slicing.
+ *
+ * @category    Scientific Computing
+ * @package     Rubix/Tensor
+ * @author      Andrew DalPino
+ */
+class TensorBuffer
+{
+    /**
+     * The underlying buffer being decorated.
+     *
+     * @var \Tensor\Buffer
+     */
+    protected buffer;
+
+    /**
+     * @param \Tensor\Buffer buffer
+     */
+    public function __construct(<Buffer> buffer)
+    {
+        let this->buffer = buffer;
+    }
+
+    /**
+     * Return the underlying buffer.
+     *
+     * @return \Tensor\Buffer
+     */
+    public function asBuffer() -> <Buffer>
+    {
+        return this->buffer;
+    }
+
+    /**
+     * Return the number of elements in the buffer.
+     *
+     * @return int
+     */
+    public function count() -> int
+    {
+        return this->buffer->count();
+    }
+
+    /**
+     * Return the element type of the buffer.
+     *
+     * @return int
+     */
+    public function type() -> int
+    {
+        return this->buffer->type();
+    }
+
+    /**
+     * Return the buffer as a PHP array.
+     *
+     * @return list<float>
+     */
+    public function toArray() -> array
+    {
+        return this->buffer->toArray();
+    }
+
+    /**
+     * Return the element at the given index.
+     *
+     * @param int index
+     * @return mixed
+     */
+    public function get(const int index)
+    {
+        return this->buffer[index];
+    }
+
+    /**
+     * Set the element at the given index.
+     *
+     * @param int index
+     * @param mixed value
+     * @return void
+     */
+    public function set(const int index, const var value) -> void
+    {
+        let this->buffer[index] = value;
+    }
+
+    /**
+     * Sort the buffer in place.
+     *
+     * @param bool ascending
+     * @return void
+     */
+    public function sort(const bool ascending = true) -> void
+    {
+        var status = tensor_buffer_sort(this->buffer, ascending);
+    }
+
+    /**
+     * Return a slice of the buffer as a new decorator.
+     *
+     * @param int offset
+     * @param int length
+     * @throws \Tensor\Exceptions\InvalidArgumentException
+     * @return self
+     */
+    public function slice(const int offset, const int length) -> <TensorBuffer>
+    {
+        if unlikely offset < 0 || length < 0 || offset > this->buffer->count() - length {
+            throw new InvalidArgumentException("Offset and length"
+                . " must be within the bounds of the buffer.");
+        }
+
+        var b = tensor_buffer_slice(this->buffer, offset, length);
+
+        return new TensorBuffer(<Buffer> b);
+    }
+}
\ No newline at end of file
diff --git a/tests/TensorBufferTest.php b/tests/TensorBufferTest.php
new file mode 100644
index 0000000..665b299
--- /dev/null
+++ b/tests/TensorBufferTest.php
@@ -0,0 +1,213 @@
+<?php
+
+namespace Tensor\Tests;
+
+use Tensor\Buffer;
+use Tensor\TensorBuffer;
+use Tensor\Exceptions\InvalidArgumentException;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @covers \Tensor\TensorBuffer
+ */
+class TensorBufferTest extends TestCase
+{
+    /**
+     * The maximum error tolerated due to varying numerical precision.
+     *
+     * @var float
+     */
+    protected const MAX_DELTA = 1e-8;
+
+    /**
+     * @test
+     */
+    public function build() : void
+    {
+        $buffer = Buffer::fromArray([1, 2, 3]);
+
+        $decorator = new TensorBuffer($buffer);
+
+        $this->assertInstanceOf(TensorBuffer::class, $decorator);
+        $this->assertSame($buffer, $decorator->asBuffer());
+        $this->assertSame(3, $decorator->count());
+        $this->assertSame(Buffer::TYPE_DOUBLE, $decorator->type());
+    }
+
+    /**
+     * @test
+     */
+    public function toArray() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1, 2, 3]));
+
+        $expected = [1.0, 2.0, 3.0];
+
+        $this->assertEqualsWithDelta($expected, $decorator->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function longType() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1, 2, 3], Buffer::TYPE_LONG));
+
+        $this->assertSame(Buffer::TYPE_LONG, $decorator->type());
+        $this->assertSame([1, 2, 3], $decorator->toArray());
+    }
+
+    /**
+     * @test
+     */
+    public function get() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
+
+        $this->assertSame(1.0, $decorator->get(1));
+    }
+
+    /**
+     * @test
+     */
+    public function set() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
+
+        $decorator->set(0, 4.0);
+
+        $this->assertEqualsWithDelta([4.0, 1.0, 2.0], $decorator->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function sortAscending() : void
+    {
+        $buffer = Buffer::fromArray([3.0, 1.0, 2.0]);
+
+        $decorator = new TensorBuffer($buffer);
+
+        $result = $decorator->sort();
+
+        $this->assertNull($result);
+        $this->assertSame($buffer, $decorator->asBuffer());
+        $this->assertEqualsWithDelta([1.0, 2.0, 3.0], $decorator->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function sortDescending() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
+
+        $decorator->sort(false);
+
+        $this->assertEqualsWithDelta([3.0, 2.0, 1.0], $decorator->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function sortLongBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
+
+        $decorator->sort();
+
+        $this->assertSame(Buffer::TYPE_LONG, $decorator->type());
+        $this->assertSame([1, 2, 3], $decorator->toArray());
+    }
+
+    /**
+     * @test
+     */
+    public function slice() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
+
+        $slice = $decorator->slice(1, 2);
+
+        $this->assertInstanceOf(TensorBuffer::class, $slice);
+        $this->assertNotSame($decorator->asBuffer(), $slice->asBuffer());
+        $this->assertEqualsWithDelta([2.0, 3.0], $slice->toArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta([1.0, 2.0, 3.0], $decorator->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function sliceIsACopy() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
+
+        $slice = $decorator->slice(0, 3);
+
+        $slice->set(0, 100.0);
+
+        $this->assertEqualsWithDelta([1.0, 2.0, 3.0], $decorator->toArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta([100.0, 2.0, 3.0], $slice->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function sliceZeroLength() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
+
+        $slice = $decorator->slice(2, 0);
+
+        $this->assertSame(0, $slice->count());
+    }
+
+    /**
+     * @test
+     */
+    public function slicePreservesType() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1, 2, 3], Buffer::TYPE_LONG));
+
+        $slice = $decorator->slice(1, 1);
+
+        $this->assertSame(Buffer::TYPE_LONG, $slice->type());
+        $this->assertSame([2], $slice->toArray());
+    }
+
+    /**
+     * @test
+     */
+    public function sliceOutOfRange() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->slice(2, 2);
+    }
+
+    /**
+     * @test
+     */
+    public function sliceNegativeOffset() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->slice(-1, 1);
+    }
+
+    /**
+     * @test
+     */
+    public function sliceNegativeLength() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->slice(0, -1);
+    }
+}

From e75e73654210e046a323f7fc4e812bb7b45f418e Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 17:41:08 -0500
Subject: [PATCH 05/51] Expand TensorBuffer API

---
 CHANGELOG.md                                  |   4 +
 benchmarks/Buffer/TensorBufferBench.php       | 224 ++++++++
 docs/TensorBuffer.md                          |  61 ++-
 docs/index.md                                 |   2 +-
 ext/include/buffer.c                          | 485 ++++++++++++++++++
 ext/include/buffer.h                          |  10 +
 ext/tensor/tensorbuffer.zep.c                 | 451 ++++++++++++++++
 ext/tensor/tensorbuffer.zep.h                 |  56 ++
 optimizers/TensorBufferArgmaxOptimizer.php    |  76 +++
 optimizers/TensorBufferArgminOptimizer.php    |  76 +++
 optimizers/TensorBufferConcatOptimizer.php    |  76 +++
 optimizers/TensorBufferMaxOptimizer.php       |  76 +++
 optimizers/TensorBufferMinOptimizer.php       |  76 +++
 optimizers/TensorBufferProductOptimizer.php   |  76 +++
 optimizers/TensorBufferRepeatOptimizer.php    |  76 +++
 .../TensorBufferSliceStridedOptimizer.php     |  76 +++
 optimizers/TensorBufferSplitOptimizer.php     |  76 +++
 optimizers/TensorBufferSumOptimizer.php       |  76 +++
 phpstan.neon                                  |   6 +-
 stubs/TensorBuffer.php                        | 160 ++++++
 stubs/TensorBuffer.stub                       |  74 ---
 tensor/tensorbuffer.zep                       | 152 ++++++
 tests/TensorBufferTest.php                    | 407 ++++++++++++++-
 23 files changed, 2771 insertions(+), 81 deletions(-)
 create mode 100644 optimizers/TensorBufferArgmaxOptimizer.php
 create mode 100644 optimizers/TensorBufferArgminOptimizer.php
 create mode 100644 optimizers/TensorBufferConcatOptimizer.php
 create mode 100644 optimizers/TensorBufferMaxOptimizer.php
 create mode 100644 optimizers/TensorBufferMinOptimizer.php
 create mode 100644 optimizers/TensorBufferProductOptimizer.php
 create mode 100644 optimizers/TensorBufferRepeatOptimizer.php
 create mode 100644 optimizers/TensorBufferSliceStridedOptimizer.php
 create mode 100644 optimizers/TensorBufferSplitOptimizer.php
 create mode 100644 optimizers/TensorBufferSumOptimizer.php
 create mode 100644 stubs/TensorBuffer.php
 delete mode 100644 stubs/TensorBuffer.stub

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6ac5500..0d5e538 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@
     - Added the `TensorBuffer` decorator class wrapping the kernel `Buffer`
     - Added in-place `sort()` (ascending or descending) operating on the buffer's raw pointer
     - Added `slice()` returning a new buffer without materialising a PHP array
+    - Added the `sum()`, `product()`, `min()`, `max()`, `argmin()`, and `argmax()` reductions operating on the buffer's raw pointer
+    - Added `sliceStrided()` for gathering elements at a fixed stride from a buffer
+    - Added `concat()` and `split()` for merging and partitioning buffers
+    - Added `repeat()` for tiling a buffer
 
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
diff --git a/benchmarks/Buffer/TensorBufferBench.php b/benchmarks/Buffer/TensorBufferBench.php
index be53df7..d150658 100644
--- a/benchmarks/Buffer/TensorBufferBench.php
+++ b/benchmarks/Buffer/TensorBufferBench.php
@@ -26,6 +26,26 @@ class TensorBufferBench
      */
     protected $length;
 
+    /**
+     * @var int
+     */
+    protected $stride;
+
+    /**
+     * @var int<1,max>
+     */
+    protected $chunkLength;
+
+    /**
+     * @var int
+     */
+    protected $times;
+
+    /**
+     * @var TensorBuffer
+     */
+    protected $concatOther;
+
     public function setUp() : void
     {
         $a = [];
@@ -35,9 +55,13 @@ public function setUp() : void
         }
 
         $this->buffer = new TensorBuffer(Buffer::fromArray($a));
+        $this->concatOther = new TensorBuffer(Buffer::fromArray($a));
 
         $this->offset = 2500;
         $this->length = 5000;
+        $this->stride = 2;
+        $this->chunkLength = 100;
+        $this->times = 10;
     }
 
     /**
@@ -87,4 +111,204 @@ public function sliceNative() : void
 
         new TensorBuffer(Buffer::fromArray($a));
     }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function sum() : void
+    {
+        $this->buffer->sum();
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function sumNative() : int|float
+    {
+        return array_sum($this->buffer->toArray());
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function product() : void
+    {
+        $this->buffer->product();
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function productNative() : int|float
+    {
+        return array_product($this->buffer->toArray());
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function min() : void
+    {
+        $this->buffer->min();
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function minNative() : mixed
+    {
+        return min($this->buffer->toArray());
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function max() : void
+    {
+        $this->buffer->max();
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function maxNative() : mixed
+    {
+        return max($this->buffer->toArray());
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function argmin() : void
+    {
+        $this->buffer->argmin();
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function argmax() : void
+    {
+        $this->buffer->argmax();
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function sliceStrided() : void
+    {
+        $this->buffer->sliceStrided($this->offset, $this->length, $this->stride);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function sliceStridedNative() : void
+    {
+        $a = $this->buffer->toArray();
+
+        $b = [];
+
+        for ($i = $this->offset; $i < $this->offset + $this->length * $this->stride; $i += $this->stride) {
+            $b[] = $a[$i];
+        }
+
+        new TensorBuffer(Buffer::fromArray($b));
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function concat() : void
+    {
+        $this->buffer->concat([$this->concatOther]);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function concatNative() : void
+    {
+        $a = $this->buffer->toArray();
+        $b = $this->concatOther->toArray();
+
+        new TensorBuffer(Buffer::fromArray(array_merge($a, $b)));
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function split() : void
+    {
+        $this->buffer->split($this->chunkLength);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     * @return array<int, list<mixed>>
+     */
+    public function splitNative() : array
+    {
+        return array_chunk($this->buffer->toArray(), $this->chunkLength);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function repeat() : void
+    {
+        $this->buffer->repeat($this->times);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function repeatNative() : void
+    {
+        $a = $this->buffer->toArray();
+
+        $b = [];
+
+        for ($i = 0; $i < $this->times; ++$i) {
+            $b = array_merge($b, $a);
+        }
+
+        new TensorBuffer(Buffer::fromArray($b));
+    }
 }
diff --git a/docs/TensorBuffer.md b/docs/TensorBuffer.md
index 7af8c82..690422c 100644
--- a/docs/TensorBuffer.md
+++ b/docs/TensorBuffer.md
@@ -62,7 +62,64 @@ Return a new decorator wrapping a new buffer of `$length` elements copied from `
 
 - **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$offset` or `$length` is negative, or the requested range exceeds the buffer size
 
+### `sum() : float`
+
+Return the sum of all elements in the buffer. An empty buffer sums to `0.0`.
+
+### `product() : float`
+
+Return the product of all elements in the buffer. An empty buffer products to `1.0`.
+
+### `min() : float`
+
+Return the minimum element in the buffer.
+
+- **Throws:** `InvalidArgumentException` if the buffer is empty
+
+### `max() : float`
+
+Return the maximum element in the buffer.
+
+- **Throws:** `InvalidArgumentException` if the buffer is empty
+
+### `argmin() : int`
+
+Return the index of the minimum element in the buffer. Ties resolve to the first occurrence.
+
+- **Throws:** `InvalidArgumentException` if the buffer is empty
+
+### `argmax() : int`
+
+Return the index of the maximum element in the buffer. Ties resolve to the first occurrence.
+
+- **Throws:** `InvalidArgumentException` if the buffer is empty
+
+### `sliceStrided(int $offset, int $length, int $stride) : TensorBuffer`
+
+Return a new decorator wrapping a new buffer of `$length` elements gathered at `$stride` intervals from `buffer[$offset]` — i.e. `buffer[$offset + i * $stride]` for `i` in `0..length - 1`. The source buffer is left unchanged. Supports gathering rows, columns, and diagonals from a flat matrix layout.
+
+- **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$offset` or `$length` is negative, `$stride` is less than 1, or the requested range exceeds the buffer size
+
+### `concat(TensorBuffer[] $buffers) : TensorBuffer`
+
+Return a new decorator wrapping a new buffer containing a copy of this buffer followed by the contents of each buffer in `$buffers`, in order. The source buffers are left unchanged. Passing an empty list returns a copy of this buffer.
+
+- **Throws:** `InvalidArgumentException` if an element of `$buffers` is not a `TensorBuffer` of the same element type
+
+### `split(int $chunkLength) : TensorBuffer[]`
+
+Return an array of new decorators splitting this buffer into consecutive chunks of up to `$chunkLength` elements each. The final chunk may be shorter. The source buffer is left unchanged.
+
+- **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$chunkLength` is less than 1
+
+### `repeat(int $times) : TensorBuffer`
+
+Return a new decorator wrapping a new buffer containing the elements of this buffer repeated `$times` times. The source buffer is left unchanged.
+
+- **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$times` is less than 1
+
 ## Notes
 
-- `sort()` and `slice()` are implemented in C (`ext/include/buffer.c`) and route through this class's optimizer calls, operating directly on the buffer's raw pointer.
-- Both element kinds (`TYPE_DOUBLE` and `TYPE_LONG`) are supported; `slice()` preserves the source kind.
\ No newline at end of file
+- `sort()`, `slice()`, the reductions (`sum()`, `product()`, `min()`, `max()`, `argmin()`, `argmax()`), `sliceStrided()`, `concat()`, `split()`, and `repeat()` are implemented in C (`ext/include/buffer.c`) and route through this class's optimizer calls, operating directly on the buffer's raw pointer.
+- Both element kinds (`TYPE_DOUBLE` and `TYPE_LONG`) are supported; `slice()`, `sliceStrided()`, `concat()`, `split()`, and `repeat()` preserve the source kind.
+- Reductions and order statistics are float-only: even for a `TYPE_LONG` buffer, `sum()`, `product()`, `min()`, and `max()` return `float`.
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
index 89d729d..3377001 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -38,7 +38,7 @@ Tensor \
 | [Vector](Vector.md) | A one dimensional (rank 1) tensor with integer and/or floating point elements. |
 | [ColumnVector](ColumnVector.md) | A vertical one dimensional tensor; extends `Vector` with matrix-facing operations. |
 | [Matrix](Matrix.md) | A two dimensional (rank 2) tensor with integer and/or floating point elements. |
-| [TensorBuffer](TensorBuffer.md) | A decorator that wraps the kernel `Buffer` class and adds sorting and slicing. |
+| [TensorBuffer](TensorBuffer.md) | A decorator that wraps the kernel `Buffer` class and adds sorting, slicing, reductions, and structural operations. |
 
 ## Interfaces
 
diff --git a/ext/include/buffer.c b/ext/include/buffer.c
index 6c43af7..cd2b101 100644
--- a/ext/include/buffer.c
+++ b/ext/include/buffer.c
@@ -40,6 +40,85 @@ static int tensor_long_cmp_desc(const void * a, const void * b)
 	return tensor_long_cmp(b, a);
 }
 
+static double tensor_buffer_sum_values(const uint8_t kind, const void * data, const zend_long len)
+{
+	double acc = 0.0;
+	zend_long i;
+
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		const zend_long * ptr = (const zend_long *) data;
+
+		for (i = 0; i < len; ++i) {
+			acc += (double) ptr[i];
+		}
+	} else {
+		const double * ptr = (const double *) data;
+
+		for (i = 0; i < len; ++i) {
+			acc += ptr[i];
+		}
+	}
+
+	return acc;
+}
+
+static double tensor_buffer_product_values(const uint8_t kind, const void * data, const zend_long len)
+{
+	double acc = 1.0;
+	zend_long i;
+
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		const zend_long * ptr = (const zend_long *) data;
+
+		for (i = 0; i < len; ++i) {
+			acc *= (double) ptr[i];
+		}
+	} else {
+		const double * ptr = (const double *) data;
+
+		for (i = 0; i < len; ++i) {
+			acc *= ptr[i];
+		}
+	}
+
+	return acc;
+}
+
+static void tensor_buffer_extreme(const uint8_t kind, const void * data, const zend_long len, const int find_min, double * value, zend_long * index)
+{
+	zend_long i;
+
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		const zend_long * ptr = (const zend_long *) data;
+		zend_long best = ptr[0];
+
+		for (i = 1; i < len; ++i) {
+			if (find_min ? ptr[i] < best : ptr[i] > best) {
+				best = ptr[i];
+				*index = i;
+			}
+		}
+
+		if (value != NULL) {
+			*value = (double) best;
+		}
+	} else {
+		const double * ptr = (const double *) data;
+		double best = ptr[0];
+
+		for (i = 1; i < len; ++i) {
+			if (find_min ? ptr[i] < best : ptr[i] > best) {
+				best = ptr[i];
+				*index = i;
+			}
+		}
+
+		if (value != NULL) {
+			*value = best;
+		}
+	}
+}
+
 /**
  * Sort the elements of a Buffer in place.
  *
@@ -112,4 +191,410 @@ void tensor_buffer_slice(zval * return_value, zval * obj, zval * offset, zval *
 	}
 }
 
+/**
+ * Return the sum of the elements of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_sum(zval * return_value, zval * obj)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (len == 0) {
+		RETURN_DOUBLE(0.0);
+	}
+
+	RETVAL_DOUBLE(tensor_buffer_sum_values(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len));
+}
+
+/**
+ * Return the product of the elements of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_product(zval * return_value, zval * obj)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (len == 0) {
+		RETURN_DOUBLE(1.0);
+	}
+
+	RETVAL_DOUBLE(tensor_buffer_product_values(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len));
+}
+
+/**
+ * Return the minimum element of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_min(zval * return_value, zval * obj)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (UNEXPECTED(len == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Cannot compute the minimum of an empty buffer."));
+		return;
+	}
+
+	double value = 0.0;
+	zend_long index = 0;
+
+	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len, 1, &value, &index);
+
+	RETVAL_DOUBLE(value);
+}
+
+/**
+ * Return the maximum element of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_max(zval * return_value, zval * obj)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (UNEXPECTED(len == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Cannot compute the maximum of an empty buffer."));
+		return;
+	}
+
+	double value = 0.0;
+	zend_long index = 0;
+
+	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len, 0, &value, &index);
+
+	RETVAL_DOUBLE(value);
+}
+
+/**
+ * Return the index of the minimum element of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_argmin(zval * return_value, zval * obj)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (UNEXPECTED(len == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Cannot compute the argmin of an empty buffer."));
+		return;
+	}
+
+	zend_long index = 0;
+
+	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len, 1, NULL, &index);
+
+	RETVAL_LONG(index);
+}
+
+/**
+ * Return the index of the maximum element of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_argmax(zval * return_value, zval * obj)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (UNEXPECTED(len == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Cannot compute the argmax of an empty buffer."));
+		return;
+	}
+
+	zend_long index = 0;
+
+	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len, 0, NULL, &index);
+
+	RETVAL_LONG(index);
+}
+
+/**
+ * Return a new Buffer populated with a strided slice of the given buffer.
+ *
+ * @param return_value
+ * @param obj
+ * @param offset
+ * @param length
+ * @param stride
+ */
+void tensor_buffer_slice_strided(zval * return_value, zval * obj, zval * offset, zval * length, zval * stride)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+	zend_long offsetHat = zephir_get_intval(offset);
+	zend_long lengthHat = zephir_get_intval(length);
+	zend_long strideHat = zephir_get_intval(stride);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (UNEXPECTED(offsetHat < 0 || lengthHat < 0 || strideHat < 1
+		|| (lengthHat > 0 && offsetHat + (lengthHat - 1) * strideHat > len - 1))) {
+		zephir_throw_exception_string(spl_ce_OutOfBoundsException,
+			SL("Slice offset, length, and stride must be within the bounds of the buffer."));
+		return;
+	}
+
+	if (UNEXPECTED(zephir_buffer_create(return_value, lengthHat, kind) == FAILURE)) {
+		return;
+	}
+
+	if (lengthHat == 0) {
+		return;
+	}
+
+	zend_long i;
+
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		const zend_long * src = zephir_buffer_longs(obj);
+		zend_long * dst = zephir_buffer_longs(return_value);
+
+		for (i = 0; i < lengthHat; ++i) {
+			dst[i] = src[offsetHat + i * strideHat];
+		}
+	} else {
+		const double * src = zephir_buffer_doubles(obj);
+		double * dst = zephir_buffer_doubles(return_value);
+
+		for (i = 0; i < lengthHat; ++i) {
+			dst[i] = src[offsetHat + i * strideHat];
+		}
+	}
+}
+
+/**
+ * Return a new Buffer populated with a copy of this buffer concatenated with
+ * the given buffers.
+ *
+ * @param return_value
+ * @param obj
+ * @param others
+ */
+void tensor_buffer_concat(zval * return_value, zval * obj, zval * others)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	HashTable * ht;
+
+	if (UNEXPECTED((ht = Z_ARRVAL_P(others)) == NULL)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be an array of Buffer objects."));
+		return;
+	}
+
+	zend_long total = len;
+	zval * other;
+
+	ZEND_HASH_FOREACH_VAL(ht, other) {
+		if (UNEXPECTED(!zephir_is_buffer(other) || zephir_buffer_kind(other) != kind)) {
+			zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+				SL("All buffers must be the same type as the given buffer."));
+			return;
+		}
+
+		total += zephir_buffer_len(other);
+	} ZEND_HASH_FOREACH_END();
+
+	if (UNEXPECTED(zephir_buffer_create(return_value, total, kind) == FAILURE)) {
+		return;
+	}
+
+	if (len > 0) {
+		if (kind == ZEPHIR_BUFFER_LONG) {
+			memcpy(zephir_buffer_longs(return_value), zephir_buffer_longs(obj),
+				(size_t) len * sizeof(zend_long));
+		} else {
+			memcpy(zephir_buffer_doubles(return_value), zephir_buffer_doubles(obj),
+				(size_t) len * sizeof(double));
+		}
+	}
+
+	zend_long pos = len;
+
+	ZEND_HASH_FOREACH_VAL(ht, other) {
+		zend_long other_len = zephir_buffer_len(other);
+
+		if (other_len > 0) {
+			if (kind == ZEPHIR_BUFFER_LONG) {
+				memcpy(zephir_buffer_longs(return_value) + pos, zephir_buffer_longs(other),
+					(size_t) other_len * sizeof(zend_long));
+			} else {
+				memcpy(zephir_buffer_doubles(return_value) + pos, zephir_buffer_doubles(other),
+					(size_t) other_len * sizeof(double));
+			}
+		}
+
+		pos += other_len;
+	} ZEND_HASH_FOREACH_END();
+}
+
+/**
+ * Return a new array of Buffers splitting the given buffer into chunks of
+ * the given length.
+ *
+ * @param return_value
+ * @param obj
+ * @param chunk_length
+ */
+void tensor_buffer_split(zval * return_value, zval * obj, zval * chunk_length)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+	zend_long chunkHat = zephir_get_intval(chunk_length);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (UNEXPECTED(chunkHat < 1)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Chunk length must be greater than 0."));
+		return;
+	}
+
+	zend_long chunks = len == 0 ? 0 : (len + chunkHat - 1) / chunkHat;
+	zend_long i;
+
+	array_init_size(return_value, (zend_ulong) chunks);
+
+	for (i = 0; i < chunks; ++i) {
+		zend_long start = i * chunkHat;
+		zend_long chunk_len = len - start < chunkHat ? len - start : chunkHat;
+		zval buffer;
+
+		if (UNEXPECTED(zephir_buffer_create(&buffer, chunk_len, kind) == FAILURE)) {
+			return;
+		}
+
+		if (chunk_len > 0) {
+			if (kind == ZEPHIR_BUFFER_LONG) {
+				memcpy(zephir_buffer_longs(&buffer), zephir_buffer_longs(obj) + start,
+					(size_t) chunk_len * sizeof(zend_long));
+			} else {
+				memcpy(zephir_buffer_doubles(&buffer), zephir_buffer_doubles(obj) + start,
+					(size_t) chunk_len * sizeof(double));
+			}
+		}
+
+		add_next_index_zval(return_value, &buffer);
+	}
+}
+
+/**
+ * Return a new Buffer populated with the elements of the given buffer
+ * repeated the given number of times.
+ *
+ * @param return_value
+ * @param obj
+ * @param times
+ */
+void tensor_buffer_repeat(zval * return_value, zval * obj, zval * times)
+{
+	uint8_t kind = zephir_buffer_kind(obj);
+	zend_long len = zephir_buffer_len(obj);
+	zend_long timesHat = zephir_get_intval(times);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		return;
+	}
+
+	if (UNEXPECTED(timesHat < 1)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Times must be greater than 0."));
+		return;
+	}
+
+	zend_long total = len * timesHat;
+	zend_long i;
+
+	if (UNEXPECTED(zephir_buffer_create(return_value, total, kind) == FAILURE)) {
+		return;
+	}
+
+	if (len > 0) {
+		for (i = 0; i < timesHat; ++i) {
+			if (kind == ZEPHIR_BUFFER_LONG) {
+				memcpy(zephir_buffer_longs(return_value) + i * len, zephir_buffer_longs(obj),
+					(size_t) len * sizeof(zend_long));
+			} else {
+				memcpy(zephir_buffer_doubles(return_value) + i * len, zephir_buffer_doubles(obj),
+					(size_t) len * sizeof(double));
+			}
+		}
+	}
+}
+
 #endif
\ No newline at end of file
diff --git a/ext/include/buffer.h b/ext/include/buffer.h
index 784f50e..8704ec2 100644
--- a/ext/include/buffer.h
+++ b/ext/include/buffer.h
@@ -10,5 +10,15 @@ extern zend_class_entry * tensor_buffer_ce;
 
 void tensor_buffer_sort(zval * return_value, zval * obj, zval * ascending);
 void tensor_buffer_slice(zval * return_value, zval * obj, zval * offset, zval * length);
+void tensor_buffer_sum(zval * return_value, zval * obj);
+void tensor_buffer_product(zval * return_value, zval * obj);
+void tensor_buffer_min(zval * return_value, zval * obj);
+void tensor_buffer_max(zval * return_value, zval * obj);
+void tensor_buffer_argmin(zval * return_value, zval * obj);
+void tensor_buffer_argmax(zval * return_value, zval * obj);
+void tensor_buffer_slice_strided(zval * return_value, zval * obj, zval * offset, zval * length, zval * stride);
+void tensor_buffer_concat(zval * return_value, zval * obj, zval * others);
+void tensor_buffer_split(zval * return_value, zval * obj, zval * chunk_length);
+void tensor_buffer_repeat(zval * return_value, zval * obj, zval * times);
 
 #endif
\ No newline at end of file
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 781a79a..2b1c8c8 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -19,6 +19,7 @@
 #include "kernel/operators.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
+#include "kernel/string.h"
 #include "include/buffer.h"
 
 
@@ -329,3 +330,453 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 	RETURN_MM();
 }
 
+/**
+ * Return the sum of the elements in the buffer.
+ *
+ * @return float
+ */
+PHP_METHOD(Tensor_TensorBuffer, sum)
+{
+	zval _0;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	tensor_buffer_sum(return_value, &_0);
+	return;
+}
+
+/**
+ * Return the product of the elements in the buffer.
+ *
+ * @return float
+ */
+PHP_METHOD(Tensor_TensorBuffer, product)
+{
+	zval _0;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	tensor_buffer_product(return_value, &_0);
+	return;
+}
+
+/**
+ * Return the minimum element in the buffer.
+ *
+ * @return float
+ */
+PHP_METHOD(Tensor_TensorBuffer, min)
+{
+	zval _0;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	tensor_buffer_min(return_value, &_0);
+	return;
+}
+
+/**
+ * Return the maximum element in the buffer.
+ *
+ * @return float
+ */
+PHP_METHOD(Tensor_TensorBuffer, max)
+{
+	zval _0;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	tensor_buffer_max(return_value, &_0);
+	return;
+}
+
+/**
+ * Return the index of the minimum element in the buffer.
+ *
+ * @return int
+ */
+PHP_METHOD(Tensor_TensorBuffer, argmin)
+{
+	zval _0;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	tensor_buffer_argmin(return_value, &_0);
+	return;
+}
+
+/**
+ * Return the index of the maximum element in the buffer.
+ *
+ * @return int
+ */
+PHP_METHOD(Tensor_TensorBuffer, argmax)
+{
+	zval _0;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	tensor_buffer_argmax(return_value, &_0);
+	return;
+}
+
+/**
+ * Return a slice of the buffer with a given stride as a new decorator.
+ *
+ * @param int offset
+ * @param int length
+ * @param int stride
+ * @throws \Tensor\Exceptions\InvalidArgumentException
+ * @return self
+ */
+PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
+{
+	zval _7$$3;
+	zend_bool _0, _1, _2, _3;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zval *offset_param = NULL, *length_param = NULL, *stride_param = NULL, _4, _5, b, _8, _9, _10, _11, _6$$3;
+	zend_long offset, length, stride, ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_7$$3);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(3, 3)
+		Z_PARAM_LONG(offset)
+		Z_PARAM_LONG(length)
+		Z_PARAM_LONG(stride)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 3, 0, &offset_param, &length_param, &stride_param);
+	_0 = offset < 0;
+	if (!(_0)) {
+		_0 = length < 0;
+	}
+	_1 = _0;
+	if (!(_1)) {
+		_1 = stride < 1;
+	}
+	_2 = _1;
+	if (!(_2)) {
+		_3 = length > 0;
+		if (_3) {
+			zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_5, &_4, "count", NULL, 0);
+			zephir_check_call_status();
+			_3 = offset > ((zephir_get_numberval(&_5) - (((length - 1)) * stride)) - 1);
+		}
+		_2 = _3;
+	}
+	if (UNEXPECTED(_2)) {
+		ZEPHIR_INIT_VAR(&_6$$3);
+		object_init_ex(&_6$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_7$$3);
+		ZEPHIR_CONCAT_SS(&_7$$3, "Offset, length, and", " stride must be within the bounds of the buffer.");
+		ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 3, &_7$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_6$$3, "tensor/tensorbuffer.zep", 200);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&b);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_9, offset);
+	ZVAL_LONG(&_10, length);
+	ZVAL_LONG(&_11, stride);
+	tensor_buffer_slice_strided(&b, &_8, &_9, &_10, &_11);
+	object_init_ex(return_value, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 35, &b);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return a new decorator wrapping a new buffer containing the elements of
+ * this buffer concatenated with the given buffers.
+ *
+ * @param \Tensor\TensorBuffer[] buffers
+ * @return self
+ */
+PHP_METHOD(Tensor_TensorBuffer, concat)
+{
+	zend_bool _3;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *buffers_param = NULL, buffer, *_0, _2, b, _5, _1$$3, _4$$4;
+	zval buffers, unwrapped;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&buffers);
+	ZVAL_UNDEF(&unwrapped);
+	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_4$$4);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		ZEPHIR_Z_PARAM_ARRAY(buffers, buffers_param)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &buffers_param);
+	zephir_get_arrval(&buffers, buffers_param);
+	ZEPHIR_INIT_VAR(&unwrapped);
+	array_init(&unwrapped);
+	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 225);
+	if (Z_TYPE_P(&buffers) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&buffers), _0)
+		{
+			ZEPHIR_INIT_NVAR(&buffer);
+			ZVAL_COPY(&buffer, _0);
+			ZEPHIR_CALL_METHOD(&_1$$3, &buffer, "asBuffer", NULL, 0);
+			zephir_check_call_status();
+			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 222);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, &buffers, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_3 = 1;
+		while (1) {
+			if (_3) {
+				_3 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, &buffers, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_2, &buffers, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_2)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&buffer, &buffers, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_CALL_METHOD(&_4$$4, &buffer, "asBuffer", NULL, 0);
+				zephir_check_call_status();
+				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 222);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&buffer);
+	ZEPHIR_INIT_VAR(&b);
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	tensor_buffer_concat(&b, &_5, &unwrapped);
+	object_init_ex(return_value, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 35, &b);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return an array of new decorators each wrapping a chunk of this buffer
+ * of the given length.
+ *
+ * @param int chunkLength
+ * @throws \Tensor\Exceptions\InvalidArgumentException
+ * @return \Tensor\TensorBuffer[]
+ */
+PHP_METHOD(Tensor_TensorBuffer, split)
+{
+	zend_bool _12;
+	zval tensorBuffers;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zephir_fcall_cache_entry *_10 = NULL;
+	zval *chunkLength_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, buffer, buffers, _4, _5, *_6, _7, *_8, _11, _9$$4, _13$$5;
+	zend_long chunkLength, ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&buffers);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_9$$4);
+	ZVAL_UNDEF(&_13$$5);
+	ZVAL_UNDEF(&tensorBuffers);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_LONG(chunkLength)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &chunkLength_param);
+	if (UNEXPECTED(chunkLength < 1)) {
+		ZEPHIR_INIT_VAR(&_0$$3);
+		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZVAL_LONG(&_1$$3, chunkLength);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		zephir_check_call_status();
+		ZEPHIR_INIT_VAR(&_3$$3);
+		ZEPHIR_CONCAT_SSVS(&_3$$3, "Chunk length must be", " greater than 0, ", &_2$$3, " given.");
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 242);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&buffers);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_5, chunkLength);
+	tensor_buffer_split(&buffers, &_4, &_5);
+	ZEPHIR_INIT_VAR(&tensorBuffers);
+	array_init(&tensorBuffers);
+	if (Z_TYPE_P(&buffers) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_7);
+		zephir_string_to_char_array(&_7, &buffers);
+		_6 = &_7;
+	} else {
+		_6 = &buffers;
+	}
+	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 255);
+	if (Z_TYPE_P(_6) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
+		{
+			ZEPHIR_INIT_NVAR(&buffer);
+			ZVAL_COPY(&buffer, _8);
+			ZEPHIR_INIT_NVAR(&_9$$4);
+			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
+			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 35, &buffer);
+			zephir_check_call_status();
+			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 252);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_12 = 1;
+		while (1) {
+			if (_12) {
+				_12 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _6, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_11, _6, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_11)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&buffer, _6, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_13$$5);
+				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
+				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 35, &buffer);
+				zephir_check_call_status();
+				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 252);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&buffer);
+	RETURN_CTOR(&tensorBuffers);
+}
+
+/**
+ * Return a new decorator wrapping a new buffer with the elements of this
+ * buffer repeated the given number of times.
+ *
+ * @param int times
+ * @throws \Tensor\Exceptions\InvalidArgumentException
+ * @return self
+ */
+PHP_METHOD(Tensor_TensorBuffer, repeat)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zval *times_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, b, _4, _5;
+	zend_long times, ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_LONG(times)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &times_param);
+	if (UNEXPECTED(times < 1)) {
+		ZEPHIR_INIT_VAR(&_0$$3);
+		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZVAL_LONG(&_1$$3, times);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		zephir_check_call_status();
+		ZEPHIR_INIT_VAR(&_3$$3);
+		ZEPHIR_CONCAT_SSVS(&_3$$3, "Times must be", " greater than 0, ", &_2$$3, " given.");
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 270);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&b);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_5, times);
+	tensor_buffer_repeat(&b, &_4, &_5);
+	object_init_ex(return_value, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 35, &b);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
diff --git a/ext/tensor/tensorbuffer.zep.h b/ext/tensor/tensorbuffer.zep.h
index acd81ac..b4e454e 100644
--- a/ext/tensor/tensorbuffer.zep.h
+++ b/ext/tensor/tensorbuffer.zep.h
@@ -12,6 +12,16 @@ PHP_METHOD(Tensor_TensorBuffer, get);
 PHP_METHOD(Tensor_TensorBuffer, set);
 PHP_METHOD(Tensor_TensorBuffer, sort);
 PHP_METHOD(Tensor_TensorBuffer, slice);
+PHP_METHOD(Tensor_TensorBuffer, sum);
+PHP_METHOD(Tensor_TensorBuffer, product);
+PHP_METHOD(Tensor_TensorBuffer, min);
+PHP_METHOD(Tensor_TensorBuffer, max);
+PHP_METHOD(Tensor_TensorBuffer, argmin);
+PHP_METHOD(Tensor_TensorBuffer, argmax);
+PHP_METHOD(Tensor_TensorBuffer, sliceStrided);
+PHP_METHOD(Tensor_TensorBuffer, concat);
+PHP_METHOD(Tensor_TensorBuffer, split);
+PHP_METHOD(Tensor_TensorBuffer, repeat);
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_tensorbuffer___construct, 0, 0, 1)
 	ZEND_ARG_OBJ_INFO(0, buffer, Tensor\\Buffer, 0)
@@ -49,6 +59,42 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_slice, 0, 2,
 	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_sum, 0, 0, IS_DOUBLE, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_product, 0, 0, IS_DOUBLE, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_min, 0, 0, IS_DOUBLE, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_max, 0, 0, IS_DOUBLE, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_argmin, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_argmax, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_slicestrided, 0, 3, Tensor\\TensorBuffer, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, stride, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_concat, 0, 1, Tensor\\TensorBuffer, 0)
+	ZEND_ARG_ARRAY_INFO(0, buffers, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_split, 0, 1, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, chunkLength, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_repeat, 0, 1, Tensor\\TensorBuffer, 0)
+	ZEND_ARG_TYPE_INFO(0, times, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
 ZEPHIR_INIT_FUNCS(tensor_tensorbuffer_method_entry) {
 	PHP_ME(Tensor_TensorBuffer, __construct, arginfo_tensor_tensorbuffer___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 	PHP_ME(Tensor_TensorBuffer, asBuffer, arginfo_tensor_tensorbuffer_asbuffer, ZEND_ACC_PUBLIC)
@@ -59,5 +105,15 @@ ZEPHIR_INIT_FUNCS(tensor_tensorbuffer_method_entry) {
 	PHP_ME(Tensor_TensorBuffer, set, arginfo_tensor_tensorbuffer_set, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, sort, arginfo_tensor_tensorbuffer_sort, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, slice, arginfo_tensor_tensorbuffer_slice, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, sum, arginfo_tensor_tensorbuffer_sum, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, product, arginfo_tensor_tensorbuffer_product, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, min, arginfo_tensor_tensorbuffer_min, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, max, arginfo_tensor_tensorbuffer_max, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, argmin, arginfo_tensor_tensorbuffer_argmin, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, argmax, arginfo_tensor_tensorbuffer_argmax, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, sliceStrided, arginfo_tensor_tensorbuffer_slicestrided, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, concat, arginfo_tensor_tensorbuffer_concat, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, split, arginfo_tensor_tensorbuffer_split, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, repeat, arginfo_tensor_tensorbuffer_repeat, ZEND_ACC_PUBLIC)
 	PHP_FE_END
 };
diff --git a/optimizers/TensorBufferArgmaxOptimizer.php b/optimizers/TensorBufferArgmaxOptimizer.php
new file mode 100644
index 0000000..9883e2b
--- /dev/null
+++ b/optimizers/TensorBufferArgmaxOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferArgmaxOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor buffer argmax accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_argmax($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferArgminOptimizer.php b/optimizers/TensorBufferArgminOptimizer.php
new file mode 100644
index 0000000..8f7f3ae
--- /dev/null
+++ b/optimizers/TensorBufferArgminOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferArgminOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor buffer argmin accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_argmin($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferConcatOptimizer.php b/optimizers/TensorBufferConcatOptimizer.php
new file mode 100644
index 0000000..f6c5b09
--- /dev/null
+++ b/optimizers/TensorBufferConcatOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferConcatOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor buffer concat accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_concat($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferMaxOptimizer.php b/optimizers/TensorBufferMaxOptimizer.php
new file mode 100644
index 0000000..d0c3697
--- /dev/null
+++ b/optimizers/TensorBufferMaxOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferMaxOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor buffer max accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_max($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferMinOptimizer.php b/optimizers/TensorBufferMinOptimizer.php
new file mode 100644
index 0000000..e4812f5
--- /dev/null
+++ b/optimizers/TensorBufferMinOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferMinOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor buffer min accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_min($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferProductOptimizer.php b/optimizers/TensorBufferProductOptimizer.php
new file mode 100644
index 0000000..b2a160b
--- /dev/null
+++ b/optimizers/TensorBufferProductOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferProductOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor buffer product accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_product($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferRepeatOptimizer.php b/optimizers/TensorBufferRepeatOptimizer.php
new file mode 100644
index 0000000..b0c8fad
--- /dev/null
+++ b/optimizers/TensorBufferRepeatOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferRepeatOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor buffer repeat accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_repeat($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferSliceStridedOptimizer.php b/optimizers/TensorBufferSliceStridedOptimizer.php
new file mode 100644
index 0000000..ecfaf2e
--- /dev/null
+++ b/optimizers/TensorBufferSliceStridedOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferSliceStridedOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 4) {
+            throw new CompilerException(
+                'Tensor buffer slice strided accepts exactly four arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_slice_strided($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]}, {$resolvedParams[3]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferSplitOptimizer.php b/optimizers/TensorBufferSplitOptimizer.php
new file mode 100644
index 0000000..ccc87dd
--- /dev/null
+++ b/optimizers/TensorBufferSplitOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferSplitOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor buffer split accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_split($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferSumOptimizer.php b/optimizers/TensorBufferSumOptimizer.php
new file mode 100644
index 0000000..2498502
--- /dev/null
+++ b/optimizers/TensorBufferSumOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferSumOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor buffer sum accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_sum($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/phpstan.neon b/phpstan.neon
index 3e15cde..dd0029b 100644
--- a/phpstan.neon
+++ b/phpstan.neon
@@ -3,5 +3,7 @@ parameters:
     paths:
         - 'tests'
         - 'benchmarks'
-    stubFiles:
-        - 'stubs/TensorBuffer.stub'
+    scanFiles:
+        - 'stubs/TensorBuffer.php'
+    bootstrapFiles:
+        - vendor/autoload.php
diff --git a/stubs/TensorBuffer.php b/stubs/TensorBuffer.php
new file mode 100644
index 0000000..3723af7
--- /dev/null
+++ b/stubs/TensorBuffer.php
@@ -0,0 +1,160 @@
+<?php
+
+namespace Tensor {
+
+    /**
+     * Static declarations of the extension classes for PHPStan.
+     *
+     * The PHP 8 reflection layer cannot read the default value of the kernel
+     * `Buffer::__construct` / `Buffer::fromArray` `$type` argument
+     * (`ReflectionParameter::isDefaultValueConstant()` throws "Failed to retrieve
+     * the default value"), which makes PHPStan unable to reflect the class and any
+     * class that type-hints it. Declare it statically so static analysis works.
+     *
+     * These files must stay in sync with `tensor/tensorbuffer.zep` and the kernel
+     * `Buffer` class. They are registered via `scanFiles` in `phpstan.neon` and
+     * are never analysed themselves.
+     */
+    final class Buffer implements \ArrayAccess, \Countable, \IteratorAggregate, \JsonSerializable
+    {
+        public const TYPE_DOUBLE = 1;
+
+        public const TYPE_LONG = 2;
+
+        public static function fromArray(array $values, int $type = self::TYPE_DOUBLE)
+        {
+        }
+
+        public function __construct(int $size, int $type = self::TYPE_DOUBLE)
+        {
+        }
+
+        public function toArray() : array
+        {
+        }
+
+        public function type() : int
+        {
+        }
+
+        public function count() : int
+        {
+        }
+
+        public function fill(mixed $value) : void
+        {
+        }
+
+        public function offsetExists(mixed $offset) : bool
+        {
+        }
+
+        public function offsetGet(mixed $offset) : mixed
+        {
+        }
+
+        public function offsetSet(mixed $offset, mixed $value) : void
+        {
+        }
+
+        public function offsetUnset(mixed $offset) : void
+        {
+        }
+
+        public function getIterator() : \Traversable
+        {
+        }
+
+        public function jsonSerialize() : mixed
+        {
+        }
+
+        public function __serialize() : array
+        {
+        }
+
+        public function __unserialize(array $data) : void
+        {
+        }
+    }
+
+    class TensorBuffer
+    {
+        public function __construct(Buffer $buffer)
+        {
+        }
+
+        public function asBuffer() : Buffer
+        {
+        }
+
+        public function count() : int
+        {
+        }
+
+        public function type() : int
+        {
+        }
+
+        public function toArray() : array
+        {
+        }
+
+        public function get(int $index) : mixed
+        {
+        }
+
+        public function set(int $index, mixed $value) : void
+        {
+        }
+
+        public function sort(bool $ascending = true) : void
+        {
+        }
+
+        public function slice(int $offset, int $length) : TensorBuffer
+        {
+        }
+
+        public function sum() : float
+        {
+        }
+
+        public function product() : float
+        {
+        }
+
+        public function min() : float
+        {
+        }
+
+        public function max() : float
+        {
+        }
+
+        public function argmin() : int
+        {
+        }
+
+        public function argmax() : int
+        {
+        }
+
+        public function sliceStrided(int $offset, int $length, int $stride) : TensorBuffer
+        {
+        }
+
+        public function concat(array $buffers) : TensorBuffer
+        {
+        }
+
+        public function split(int $chunkLength) : array
+        {
+        }
+
+        public function repeat(int $times) : TensorBuffer
+        {
+        }
+    }
+
+}
diff --git a/stubs/TensorBuffer.stub b/stubs/TensorBuffer.stub
deleted file mode 100644
index f05fb52..0000000
--- a/stubs/TensorBuffer.stub
+++ /dev/null
@@ -1,74 +0,0 @@
-<?php
-
-namespace Tensor {
-
-/**
- * The PHP 8 reflection layer cannot read the default value of the kernel
- * `Buffer::__construct` / `Buffer::fromArray` `$type` argument
- * (`ReflectionParameter::isDefaultValueConstant()` throws "Failed to retrieve
- * the default value"), which makes PHPStan unable to reflect the class and any
- * class that type-hints it. Declare it statically so static analysis works.
- */
-final class Buffer implements \ArrayAccess, \Countable, \IteratorAggregate, \JsonSerializable
-{
-    public const TYPE_DOUBLE = 1;
-    public const TYPE_LONG = 2;
-
-    public function __construct(int $size, int $type = self::TYPE_DOUBLE)
-    {
-    }
-
-    public static function fromArray(array $values, int $type = self::TYPE_DOUBLE)
-    {
-    }
-
-    public function toArray() : array
-    {
-    }
-
-    public function type() : int
-    {
-    }
-
-    public function count() : int
-    {
-    }
-
-    public function fill(mixed $value) : void
-    {
-    }
-
-    public function offsetExists(mixed $offset) : bool
-    {
-    }
-
-    public function offsetGet(mixed $offset) : mixed
-    {
-    }
-
-    public function offsetSet(mixed $offset, mixed $value) : void
-    {
-    }
-
-    public function offsetUnset(mixed $offset) : void
-    {
-    }
-
-    public function getIterator() : \Traversable
-    {
-    }
-
-    public function jsonSerialize() : mixed
-    {
-    }
-
-    public function __serialize() : array
-    {
-    }
-
-    public function __unserialize(array $data) : void
-    {
-    }
-}
-
-}
\ No newline at end of file
diff --git a/tensor/tensorbuffer.zep b/tensor/tensorbuffer.zep
index 7a7879e..f3dc328 100644
--- a/tensor/tensorbuffer.zep
+++ b/tensor/tensorbuffer.zep
@@ -122,4 +122,156 @@ class TensorBuffer
 
         return new TensorBuffer(<Buffer> b);
     }
+
+    /**
+     * Return the sum of the elements in the buffer.
+     *
+     * @return float
+     */
+    public function sum() -> float
+    {
+        return tensor_buffer_sum(this->buffer);
+    }
+
+    /**
+     * Return the product of the elements in the buffer.
+     *
+     * @return float
+     */
+    public function product() -> float
+    {
+        return tensor_buffer_product(this->buffer);
+    }
+
+    /**
+     * Return the minimum element in the buffer.
+     *
+     * @return float
+     */
+    public function min() -> float
+    {
+        return tensor_buffer_min(this->buffer);
+    }
+
+    /**
+     * Return the maximum element in the buffer.
+     *
+     * @return float
+     */
+    public function max() -> float
+    {
+        return tensor_buffer_max(this->buffer);
+    }
+
+    /**
+     * Return the index of the minimum element in the buffer.
+     *
+     * @return int
+     */
+    public function argmin() -> int
+    {
+        return tensor_buffer_argmin(this->buffer);
+    }
+
+    /**
+     * Return the index of the maximum element in the buffer.
+     *
+     * @return int
+     */
+    public function argmax() -> int
+    {
+        return tensor_buffer_argmax(this->buffer);
+    }
+
+    /**
+     * Return a slice of the buffer with a given stride as a new decorator.
+     *
+     * @param int offset
+     * @param int length
+     * @param int stride
+     * @throws \Tensor\Exceptions\InvalidArgumentException
+     * @return self
+     */
+    public function sliceStrided(const int offset, const int length, const int stride) -> <TensorBuffer>
+    {
+        if unlikely offset < 0 || length < 0 || stride < 1
+            || (length > 0 && offset > this->buffer->count() - (length - 1) * stride - 1) {
+            throw new InvalidArgumentException("Offset, length, and"
+                . " stride must be within the bounds of the buffer.");
+        }
+
+        var b = tensor_buffer_slice_strided(this->buffer, offset, length, stride);
+
+        return new TensorBuffer(<Buffer> b);
+    }
+
+    /**
+     * Return a new decorator wrapping a new buffer containing the elements of
+     * this buffer concatenated with the given buffers.
+     *
+     * @param \Tensor\TensorBuffer[] buffers
+     * @return self
+     */
+    public function concat(const array buffers) -> <TensorBuffer>
+    {
+        var buffer;
+
+        array unwrapped = [];
+
+        for buffer in buffers {
+            let unwrapped[] = buffer->asBuffer();
+        }
+
+        var b = tensor_buffer_concat(this->buffer, unwrapped);
+
+        return new TensorBuffer(<Buffer> b);
+    }
+
+    /**
+     * Return an array of new decorators each wrapping a chunk of this buffer
+     * of the given length.
+     *
+     * @param int chunkLength
+     * @throws \Tensor\Exceptions\InvalidArgumentException
+     * @return \Tensor\TensorBuffer[]
+     */
+    public function split(const int chunkLength) -> array
+    {
+        if unlikely chunkLength < 1 {
+            throw new InvalidArgumentException("Chunk length must be"
+                . " greater than 0, " . strval(chunkLength) . " given.");
+        }
+
+        var buffer;
+
+        var buffers = tensor_buffer_split(this->buffer, chunkLength);
+
+        array tensorBuffers = [];
+
+        for buffer in buffers {
+            let tensorBuffers[] = new TensorBuffer(<Buffer> buffer);
+        }
+
+        return tensorBuffers;
+    }
+
+    /**
+     * Return a new decorator wrapping a new buffer with the elements of this
+     * buffer repeated the given number of times.
+     *
+     * @param int times
+     * @throws \Tensor\Exceptions\InvalidArgumentException
+     * @return self
+     */
+    public function repeat(const int times) -> <TensorBuffer>
+    {
+        if unlikely times < 1 {
+            throw new InvalidArgumentException("Times must be"
+                . " greater than 0, " . strval(times) . " given.");
+        }
+
+        var b = tensor_buffer_repeat(this->buffer, times);
+
+        return new TensorBuffer(<Buffer> b);
+    }
 }
\ No newline at end of file
diff --git a/tests/TensorBufferTest.php b/tests/TensorBufferTest.php
index 665b299..2a1b6c5 100644
--- a/tests/TensorBufferTest.php
+++ b/tests/TensorBufferTest.php
@@ -88,9 +88,8 @@ public function sortAscending() : void
 
         $decorator = new TensorBuffer($buffer);
 
-        $result = $decorator->sort();
+        $decorator->sort();
 
-        $this->assertNull($result);
         $this->assertSame($buffer, $decorator->asBuffer());
         $this->assertEqualsWithDelta([1.0, 2.0, 3.0], $decorator->toArray(), self::MAX_DELTA);
     }
@@ -210,4 +209,408 @@ public function sliceNegativeLength() : void
 
         $decorator->slice(0, -1);
     }
+
+    /**
+     * @test
+     */
+    public function sum() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
+
+        $this->assertEqualsWithDelta(6.0, $decorator->sum(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function sumLongBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
+
+        $this->assertEqualsWithDelta(6.0, $decorator->sum(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function sumEmptyBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
+
+        $this->assertEqualsWithDelta(0.0, $decorator->sum(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function product() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
+
+        $this->assertEqualsWithDelta(6.0, $decorator->product(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function productLongBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
+
+        $this->assertEqualsWithDelta(6.0, $decorator->product(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function productEmptyBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
+
+        $this->assertEqualsWithDelta(1.0, $decorator->product(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function min() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
+
+        $this->assertEqualsWithDelta(1.0, $decorator->min(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function minLongBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
+
+        $this->assertEqualsWithDelta(1.0, $decorator->min(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function minEmptyBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
+
+        $this->expectException(\InvalidArgumentException::class);
+
+        $decorator->min();
+    }
+
+    /**
+     * @test
+     */
+    public function max() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
+
+        $this->assertEqualsWithDelta(3.0, $decorator->max(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function maxLongBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
+
+        $this->assertEqualsWithDelta(3.0, $decorator->max(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function maxEmptyBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
+
+        $this->expectException(\InvalidArgumentException::class);
+
+        $decorator->max();
+    }
+
+    /**
+     * @test
+     */
+    public function argmin() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
+
+        $this->assertSame(1, $decorator->argmin());
+    }
+
+    /**
+     * @test
+     */
+    public function argminLongBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
+
+        $this->assertSame(1, $decorator->argmin());
+    }
+
+    /**
+     * @test
+     */
+    public function argminTie() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 1.0, 2.0]));
+
+        $this->assertSame(0, $decorator->argmin());
+    }
+
+    /**
+     * @test
+     */
+    public function argminEmptyBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
+
+        $this->expectException(\InvalidArgumentException::class);
+
+        $decorator->argmin();
+    }
+
+    /**
+     * @test
+     */
+    public function argmax() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
+
+        $this->assertSame(0, $decorator->argmax());
+    }
+
+    /**
+     * @test
+     */
+    public function argmaxLongBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
+
+        $this->assertSame(0, $decorator->argmax());
+    }
+
+    /**
+     * @test
+     */
+    public function argmaxEmptyBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
+
+        $this->expectException(\InvalidArgumentException::class);
+
+        $decorator->argmax();
+    }
+
+    /**
+     * @test
+     */
+    public function sliceStrided() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]));
+
+        $slice = $decorator->sliceStrided(1, 2, 2);
+
+        $this->assertInstanceOf(TensorBuffer::class, $slice);
+        $this->assertNotSame($decorator->asBuffer(), $slice->asBuffer());
+        $this->assertEqualsWithDelta([2.0, 4.0], $slice->toArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta([1.0, 2.0, 3.0, 4.0, 5.0], $decorator->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function sliceStridedPreservesType() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1, 2, 3, 4, 5], Buffer::TYPE_LONG));
+
+        $slice = $decorator->sliceStrided(0, 3, 2);
+
+        $this->assertSame(Buffer::TYPE_LONG, $slice->type());
+        $this->assertSame([1, 3, 5], $slice->toArray());
+    }
+
+    /**
+     * @test
+     */
+    public function sliceStridedZeroLength() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]));
+
+        $slice = $decorator->sliceStrided(4, 0, 2);
+
+        $this->assertSame(0, $slice->count());
+    }
+
+    /**
+     * @test
+     */
+    public function sliceStridedOutOfRange() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->sliceStrided(4, 2, 2);
+    }
+
+    /**
+     * @test
+     */
+    public function sliceStridedInvalidStride() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->sliceStrided(0, 2, 0);
+    }
+
+    /**
+     * @test
+     */
+    public function concat() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0]));
+        $other = new TensorBuffer(Buffer::fromArray([3.0, 4.0]));
+
+        $concat = $decorator->concat([$other]);
+
+        $this->assertInstanceOf(TensorBuffer::class, $concat);
+        $this->assertEqualsWithDelta([1.0, 2.0, 3.0, 4.0], $concat->toArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta([1.0, 2.0], $decorator->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function concatMany() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0]));
+
+        $concat = $decorator->concat([
+            new TensorBuffer(Buffer::fromArray([2.0])),
+            new TensorBuffer(Buffer::fromArray([3.0])),
+        ]);
+
+        $this->assertEqualsWithDelta([1.0, 2.0, 3.0], $concat->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function concatPreservesType() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1, 2], Buffer::TYPE_LONG));
+        $other = new TensorBuffer(Buffer::fromArray([3, 4], Buffer::TYPE_LONG));
+
+        $concat = $decorator->concat([$other]);
+
+        $this->assertSame(Buffer::TYPE_LONG, $concat->type());
+        $this->assertSame([1, 2, 3, 4], $concat->toArray());
+    }
+
+    /**
+     * @test
+     */
+    public function concatEmptyList() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0]));
+
+        $concat = $decorator->concat([]);
+
+        $this->assertEqualsWithDelta([1.0, 2.0], $concat->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function split() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]));
+
+        $chunks = $decorator->split(2);
+
+        $this->assertCount(3, $chunks);
+
+        foreach ($chunks as $chunk) {
+            $this->assertInstanceOf(TensorBuffer::class, $chunk);
+        }
+
+        $this->assertEqualsWithDelta([1.0, 2.0], $chunks[0]->toArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta([3.0, 4.0], $chunks[1]->toArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta([5.0], $chunks[2]->toArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta([1.0, 2.0, 3.0, 4.0, 5.0], $decorator->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function splitPreservesType() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1, 2, 3], Buffer::TYPE_LONG));
+
+        $chunks = $decorator->split(2);
+
+        $this->assertSame(Buffer::TYPE_LONG, $chunks[0]->type());
+        $this->assertSame([1, 2], $chunks[0]->toArray());
+        $this->assertSame([3], $chunks[1]->toArray());
+    }
+
+    /**
+     * @test
+     */
+    public function splitInvalidChunkLength() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->split(0);
+    }
+
+    /**
+     * @test
+     */
+    public function repeat() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0]));
+
+        $repeated = $decorator->repeat(3);
+
+        $this->assertInstanceOf(TensorBuffer::class, $repeated);
+        $this->assertEqualsWithDelta([1.0, 2.0, 1.0, 2.0, 1.0, 2.0], $repeated->toArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta([1.0, 2.0], $decorator->toArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function repeatPreservesType() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1, 2], Buffer::TYPE_LONG));
+
+        $repeated = $decorator->repeat(2);
+
+        $this->assertSame(Buffer::TYPE_LONG, $repeated->type());
+        $this->assertSame([1, 2, 1, 2], $repeated->toArray());
+    }
+
+    /**
+     * @test
+     */
+    public function repeatInvalidTimes() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->repeat(0);
+    }
 }

From 994264d216df75942acd42c7238d96ef6bff3b7f Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 18:28:28 -0500
Subject: [PATCH 06/51] Save game

---
 ext/include/arithmetic.c                      |  402 +++--
 ext/include/buffer.c                          |  103 ++
 ext/include/buffer.h                          |   22 +
 ext/include/comparison.c                      |  437 ++++--
 ext/include/linear_algebra.c                  |   31 +-
 ext/include/signal_processing.c               |   63 +-
 ext/tensor/columnvector.zep.c                 |  373 ++---
 ext/tensor/columnvector.zep.h                 |    6 +
 ext/tensor/decompositions/cholesky.zep.c      |    2 +-
 ext/tensor/decompositions/eigen.zep.c         |    2 +-
 ext/tensor/decompositions/lu.zep.c            |    2 +-
 ext/tensor/decompositions/svd.zep.c           |    2 +-
 ext/tensor/matrix.zep.c                       | 1383 ++++++++++-------
 ext/tensor/matrix.zep.h                       |    7 +-
 ext/tensor/reductions/ref.zep.c               |    2 +-
 ext/tensor/reductions/rref.zep.c              |    2 +-
 ext/tensor/tensorbuffer.zep.c                 |   12 +-
 ext/tensor/vector.zep.c                       |  882 ++++++-----
 ext/tensor/vector.zep.h                       |    8 +-
 optimizers/TensorBufferFromArrayOptimizer.php |   76 +
 tensor/columnvector.zep                       |   37 +-
 tensor/matrix.zep                             |   39 +-
 tensor/vector.zep                             |  188 ++-
 23 files changed, 2483 insertions(+), 1598 deletions(-)
 create mode 100644 optimizers/TensorBufferFromArrayOptimizer.php

diff --git a/ext/include/arithmetic.c b/ext/include/arithmetic.c
index 39792dc..9aaf070 100644
--- a/ext/include/arithmetic.c
+++ b/ext/include/arithmetic.c
@@ -3,272 +3,386 @@
 #endif
 
 #include <php.h>
+#include <math.h>
+#include <ext/spl/spl_exceptions.h>
 #include "kernel/operators.h"
+#include "kernel/buffer.h"
+#include "include/buffer.h"
 
 void tensor_multiply(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double product;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
+
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	zval c;
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        product = zephir_get_doubleval(zend_hash_index_find(aa, i)) * zephir_get_doubleval(zend_hash_index_find(ab, i));
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_double(&c, product);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] * vb[i];
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_divide(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double quotient;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        quotient = zephir_get_doubleval(zend_hash_index_find(aa, i)) / zephir_get_doubleval(zend_hash_index_find(ab, i));
+	zval c;
 
-	    add_next_index_double(&c, quotient);
-    }
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] / vb[i];
+	}
+
+	zval_ptr_dtor(&c);
 }
 
 void tensor_add(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double sum;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
+
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	zval c;
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        sum = zephir_get_doubleval(zend_hash_index_find(aa, i)) + zephir_get_doubleval(zend_hash_index_find(ab, i));
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_double(&c, sum);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] + vb[i];
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_subtract(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double difference;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-	array_init_size(&c, n);
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        difference = zephir_get_doubleval(zend_hash_index_find(aa, i)) - zephir_get_doubleval(zend_hash_index_find(ab, i));
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_double(&c, difference);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] - vb[i];
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_pow(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double power;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        power = pow(zephir_get_doubleval(zend_hash_index_find(aa, i)), zephir_get_doubleval(zend_hash_index_find(ab, i)));
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_double(&c, power);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = pow(va[i], vb[i]);
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_mod(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    zval modulus;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-	array_init_size(&c, n);
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        mod_function(&modulus, zend_hash_index_find(aa, i), zend_hash_index_find(ab, i));
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_zval(&c, &modulus);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = fmod(va[i], vb[i]);
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_multiply_scalar(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double product;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
 
-    zend_array * aa = Z_ARR_P(a);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    double ab = zephir_get_doubleval(b);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	double ab = zephir_get_doubleval(b);
 
-	array_init_size(&c, n);
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        product = zephir_get_doubleval(zend_hash_index_find(aa, i)) * ab;
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_double(&c, product);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] * ab;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_divide_scalar(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double quotient;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
 
-    zend_array * aa = Z_ARR_P(a);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    double ab = zephir_get_doubleval(b);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	double ab = zephir_get_doubleval(b);
 
-	array_init_size(&c, n);
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        quotient = zephir_get_doubleval(zend_hash_index_find(aa, i)) / ab;
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_double(&c, quotient);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] / ab;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_add_scalar(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double sum;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
 
-    zend_array * aa = Z_ARR_P(a);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    double ab = zephir_get_doubleval(b);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	double ab = zephir_get_doubleval(b);
+
+	zval c;
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        sum = zephir_get_doubleval(zend_hash_index_find(aa, i)) + ab;
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_double(&c, sum);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] + ab;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_subtract_scalar(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double difference;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    zend_array * aa = Z_ARR_P(a);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    double ab = zephir_get_doubleval(b);
+	double ab = zephir_get_doubleval(b);
 
-    unsigned int n = zend_array_count(aa);
+	zval c;
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        difference = zephir_get_doubleval(zend_hash_index_find(aa, i)) - ab;
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_double(&c, difference);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] - ab;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_pow_scalar(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    double power;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    zend_array * aa = Z_ARR_P(a);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    double ab = zephir_get_doubleval(b);
+	double ab = zephir_get_doubleval(b);
 
-    unsigned int n = zend_array_count(aa);
+	zval c;
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        power = pow(zephir_get_doubleval(zend_hash_index_find(aa, i)), ab);
+	double * vc = zephir_buffer_doubles(&c);
 
-	    add_next_index_double(&c, power);
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = pow(va[i], ab);
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_mod_scalar(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-    zval modulus;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
 
-    zend_array * aa = Z_ARR_P(a);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-	array_init_size(&c, n);
+	double ab = zephir_get_doubleval(b);
 
-    for (i = 0; i < n; ++i) {
-        mod_function(&modulus, zend_hash_index_find(aa, i), b);
+	zval c;
 
-	    add_next_index_zval(&c, &modulus);
-    }
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
-}
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < na; ++i) {
+		vc[i] = fmod(va[i], ab);
+	}
+
+	zval_ptr_dtor(&c);
+}
\ No newline at end of file
diff --git a/ext/include/buffer.c b/ext/include/buffer.c
index cd2b101..0cb1395 100644
--- a/ext/include/buffer.c
+++ b/ext/include/buffer.c
@@ -9,11 +9,114 @@
 #include "kernel/buffer.h"
 #include "kernel/exception.h"
 #include "kernel/operators.h"
+#include "include/buffer.h"
 
 #ifdef ZEPHIR_BUFFER_ENABLED
 
 zend_class_entry * tensor_buffer_ce;
 
+/**
+ * Allocate a new `Tensor\TensorBuffer` wrapping a fresh zero-filled double
+ * buffer of `len` elements (see include/buffer.h).
+ */
+int tensor_tensorbuffer_create(zval * ret, zend_long len, zval * buffer)
+{
+	if (UNEXPECTED(zephir_buffer_create(buffer, len, ZEPHIR_BUFFER_DOUBLE) == FAILURE)) {
+		ZVAL_UNDEF(buffer);
+		return FAILURE;
+	}
+
+	object_init_ex(ret, tensor_tensorbuffer_ce);
+
+	/* zend_update_property() sets the engine's fake scope to the owner class
+	 * so protected property writes from C pass the PHP 8.4 access check. */
+	zend_update_property(tensor_tensorbuffer_ce, Z_OBJ_P(ret), "buffer", sizeof("buffer") - 1, buffer);
+
+	if (UNEXPECTED(EG(exception))) {
+		zval_ptr_dtor(ret);
+		ZVAL_UNDEF(ret);
+		zval_ptr_dtor(buffer);
+		ZVAL_UNDEF(buffer);
+		return FAILURE;
+	}
+
+	return SUCCESS;
+}
+
+/**
+ * Build a `Tensor\Buffer` object from a PHP array of values, casting every
+ * element to a double (see include/buffer.h).
+ */
+void tensor_buffer_from_array(zval * ret, zval * arr)
+{
+	if (UNEXPECTED(zephir_buffer_create_from_array(ret, arr, ZEPHIR_BUFFER_DOUBLE) == FAILURE)) {
+		ZVAL_NULL(ret);
+	}
+}
+
+/**
+ * Unwrap the double buffer hidden inside a `Tensor\TensorBuffer` object
+ * (see include/buffer.h).
+ */
+double * tensor_tensorbuffer_doubles(zval * obj, zend_long * len, int * success)
+{
+	zval rv;
+
+	ZVAL_UNDEF(&rv);
+
+	if (success != NULL) {
+		*success = 0;
+	}
+
+	if (len != NULL) {
+		*len = 0;
+	}
+
+	if (UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT || Z_OBJCE_P(obj) != tensor_tensorbuffer_ce)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Tensor\\TensorBuffer object."));
+		return NULL;
+	}
+
+	zval *prop = zend_read_property(tensor_tensorbuffer_ce, Z_OBJ_P(obj), "buffer", sizeof("buffer") - 1, 1, &rv);
+
+	if (prop != NULL && prop != &rv) {
+		ZVAL_COPY(&rv, prop);
+	}
+
+	if (UNEXPECTED(!zephir_is_buffer(&rv))) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument is not wrapping a Buffer object."));
+		goto cleanup;
+	}
+
+	if (UNEXPECTED(zephir_buffer_kind(&rv) != ZEPHIR_BUFFER_DOUBLE)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must wrap a buffer of type double."));
+		goto cleanup;
+	}
+
+	zend_long n = zephir_buffer_len(&rv);
+	double * ptr = zephir_buffer_doubles(&rv);
+
+	zval_ptr_dtor(&rv);
+
+	if (len != NULL) {
+		*len = n;
+	}
+
+	if (success != NULL) {
+		*success = 1;
+	}
+
+	return ptr;
+
+cleanup:
+	zval_ptr_dtor(&rv);
+
+	return NULL;
+}
+
 static int tensor_double_cmp(const void * a, const void * b)
 {
 	double da = *(const double *) a;
diff --git a/ext/include/buffer.h b/ext/include/buffer.h
index 8704ec2..799a8cf 100644
--- a/ext/include/buffer.h
+++ b/ext/include/buffer.h
@@ -8,6 +8,28 @@
  * `zephir_buffer_ce`. Alias the two (see config.json module initializer). */
 extern zend_class_entry * tensor_buffer_ce;
 
+/* The `Tensor\TensorBuffer` decorator class. */
+extern zend_class_entry * tensor_tensorbuffer_ce;
+
+/* Allocate a new `Tensor\TensorBuffer` wrapping a fresh zero-filled double
+ * buffer of `len` elements. The exposed `Buffer` is written to `buffer` so
+ * callers can fill it through a raw pointer. Returns FAILURE (and throws) on
+ * allocation failure; on SUCCESS the caller owns a reference to `buffer` and
+ * must release it with zval_ptr_dtor() when done. */
+int tensor_tensorbuffer_create(zval * ret, zend_long len, zval * buffer);
+
+/* Unwrap the double buffer hidden inside a `Tensor\TensorBuffer` object,
+ * returning a raw pointer into it. Sets `*success` to 1 on success and 0 on
+ * failure (throwing an InvalidArgumentException). An empty buffer yields
+ * success with a NULL pointer and `*len` of 0. */
+double * tensor_tensorbuffer_doubles(zval * obj, zend_long * len, int * success);
+
+/* Build an object of the kernel `Tensor\Buffer` class from a PHP array of
+ * values, casting every element to a double. Passed arrays must be 1-d and
+ * positionally indexed; keys are discarded. Returns FAILURE (NULL zval) on
+ * invalid input. Used to seed TensorBuffers from arrays in Zephir. */
+void tensor_buffer_from_array(zval * ret, zval * arr);
+
 void tensor_buffer_sort(zval * return_value, zval * obj, zval * ascending);
 void tensor_buffer_slice(zval * return_value, zval * obj, zval * offset, zval * length);
 void tensor_buffer_sum(zval * return_value, zval * obj);
diff --git a/ext/include/comparison.c b/ext/include/comparison.c
index 24796fe..fb2e9cd 100644
--- a/ext/include/comparison.c
+++ b/ext/include/comparison.c
@@ -3,286 +3,385 @@
 #endif
 
 #include <php.h>
+#include <ext/spl/spl_exceptions.h>
 #include "kernel/operators.h"
+#include "kernel/buffer.h"
+#include "include/buffer.h"
 
 void tensor_equal(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
+
+	zval c;
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) == zephir_get_doubleval(zend_hash_index_find(ab, i))) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	double * vc = zephir_buffer_doubles(&c);
 
-    RETVAL_ARR(Z_ARR(c));
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] == vb[i] ? 1.0 : 0.0;
+	}
+
+	zval_ptr_dtor(&c);
 }
 
 void tensor_not_equal(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-	array_init_size(&c, n);
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) != zephir_get_doubleval(zend_hash_index_find(ab, i))) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	double * vc = zephir_buffer_doubles(&c);
 
-    RETVAL_ARR(Z_ARR(c));
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] != vb[i] ? 1.0 : 0.0;
+	}
+
+	zval_ptr_dtor(&c);
 }
 
 void tensor_greater(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
+
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
+
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	zval c;
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-	array_init_size(&c, n);
+	double * vc = zephir_buffer_doubles(&c);
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) > zephir_get_doubleval(zend_hash_index_find(ab, i))) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] > vb[i] ? 1.0 : 0.0;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_greater_equal(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
+
+	zval c;
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) >= zephir_get_doubleval(zend_hash_index_find(ab, i))) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] >= vb[i] ? 1.0 : 0.0;
+	}
+
+	zval_ptr_dtor(&c);
 }
 
 void tensor_less(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) < zephir_get_doubleval(zend_hash_index_find(ab, i))) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] < vb[i] ? 1.0 : 0.0;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_less_equal(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-	array_init_size(&c, n);
+	zval c;
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) <= zephir_get_doubleval(zend_hash_index_find(ab, i))) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] <= vb[i] ? 1.0 : 0.0;
+	}
+
+	zval_ptr_dtor(&c);
 }
 
 void tensor_equal_scalar(zval * return_value, zval * a, zval * b)
 {
-	unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
 
-    zend_array * aa = Z_ARR_P(a);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    double ab = zephir_get_doubleval(b);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	double ab = zephir_get_doubleval(b);
 
-	array_init_size(&c, n);
+	zval c;
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) == ab) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] == ab ? 1.0 : 0.0;
+	}
+
+	zval_ptr_dtor(&c);
 }
 
 void tensor_not_equal_scalar(zval * return_value, zval * a, zval * b)
 {
-	unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
 
-    zend_array * aa = Z_ARR_P(a);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    double ab = zephir_get_doubleval(b);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    unsigned int n = zend_array_count(aa);
+	double ab = zephir_get_doubleval(b);
 
-	array_init_size(&c, n);
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) != ab) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	double * vc = zephir_buffer_doubles(&c);
 
-    RETVAL_ARR(Z_ARR(c));
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] != ab ? 1.0 : 0.0;
+	}
+
+	zval_ptr_dtor(&c);
 }
 
 void tensor_greater_scalar(zval * return_value, zval * a, zval * b)
 {
-	unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
 
-    zend_array * aa = Z_ARR_P(a);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    double ab = zephir_get_doubleval(b);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
+
+	double ab = zephir_get_doubleval(b);
+
+	zval c;
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-	array_init_size(&c, n);
+	double * vc = zephir_buffer_doubles(&c);
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) > ab) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] > ab ? 1.0 : 0.0;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_greater_equal_scalar(zval * return_value, zval * a, zval * b)
 {
-	unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    zend_array * aa = Z_ARR_P(a);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    double ab = zephir_get_doubleval(b);
+	double ab = zephir_get_doubleval(b);
+
+	zval c;
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-	array_init_size(&c, n);
+	double * vc = zephir_buffer_doubles(&c);
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) >= ab) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] >= ab ? 1.0 : 0.0;
+	}
 
-    RETVAL_ARR(Z_ARR(c));
+	zval_ptr_dtor(&c);
 }
 
 void tensor_less_scalar(zval * return_value, zval * a, zval * b)
 {
-	unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    zend_array * aa = Z_ARR_P(a);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    double ab = zephir_get_doubleval(b);
+	double ab = zephir_get_doubleval(b);
 
-    unsigned int n = zend_array_count(aa);
+	zval c;
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) < ab) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	double * vc = zephir_buffer_doubles(&c);
 
-    RETVAL_ARR(Z_ARR(c));
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] < ab ? 1.0 : 0.0;
+	}
+
+	zval_ptr_dtor(&c);
 }
 
 void tensor_less_equal_scalar(zval * return_value, zval * a, zval * b)
 {
-	unsigned int i;
-	zval c;
+	zend_long i;
+	zend_long na = 0;
+	int ok_a = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    zend_array * aa = Z_ARR_P(a);
+	if (UNEXPECTED(!ok_a)) {
+		return;
+	}
 
-    double ab = zephir_get_doubleval(b);
+	double ab = zephir_get_doubleval(b);
 
-    unsigned int n = zend_array_count(aa);
+	zval c;
 
-	array_init_size(&c, n);
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        if (zephir_get_doubleval(zend_hash_index_find(aa, i)) <= ab) {
-            add_next_index_long(&c, 1);
-        } else {
-            add_next_index_long(&c, 0);
-        }
-    }
+	double * vc = zephir_buffer_doubles(&c);
 
-    RETVAL_ARR(Z_ARR(c));
-}
+	for (i = 0; i < na; ++i) {
+		vc[i] = va[i] <= ab ? 1.0 : 0.0;
+	}
+
+	zval_ptr_dtor(&c);
+}
\ No newline at end of file
diff --git a/ext/include/linear_algebra.c b/ext/include/linear_algebra.c
index a65348f..da8b21c 100644
--- a/ext/include/linear_algebra.c
+++ b/ext/include/linear_algebra.c
@@ -4,9 +4,12 @@
 
 #include <php.h>
 #include <math.h>
+#include <ext/spl/spl_exceptions.h>
 #include <cblas.h>
 #include <lapacke.h>
 #include "kernel/operators.h"
+#include "kernel/buffer.h"
+#include "include/buffer.h"
 
 /**
  * Matrix-matrix multiplication i.e. linear transformation of matrices A and B.
@@ -78,20 +81,30 @@ void tensor_matmul(zval * return_value, zval * a, zval * b)
  */
 void tensor_dot(zval * return_value, zval * a, zval * b)
 {
-    unsigned int i;
+	zend_long i;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    unsigned int n = zend_array_count(aa);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-    double sigma = 0.0;
+	if (UNEXPECTED(na != nb)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffers must be the same length."));
+		return;
+	}
 
-    for (i = 0; i < n; ++i) {
-        sigma += zephir_get_doubleval(zend_hash_index_find(aa, i)) * zephir_get_doubleval(zend_hash_index_find(ab, i));
-    }
+	double sigma = 0.0;
+
+	for (i = 0; i < na; ++i) {
+		sigma += va[i] * vb[i];
+	}
 
-    RETVAL_DOUBLE(sigma);
+	RETVAL_DOUBLE(sigma);
 }
 
 /**
diff --git a/ext/include/signal_processing.c b/ext/include/signal_processing.c
index d974ff9..a7c54d6 100644
--- a/ext/include/signal_processing.c
+++ b/ext/include/signal_processing.c
@@ -3,7 +3,10 @@
 #endif
 
 #include <php.h>
+#include <ext/spl/spl_exceptions.h>
 #include "kernel/operators.h"
+#include "kernel/buffer.h"
+#include "include/buffer.h"
 
 /**
  * 1D convolution between a vector A and B (kernel) with a given stride.
@@ -15,50 +18,48 @@
  */
 void tensor_convolve_1d(zval * return_value, zval * a, zval * b, zval * stride)
 {
-    unsigned int i, j;
-    unsigned int jmin, jmax;
-    double sigma;
-    zval c;
+	zend_long i, j;
+	zend_long jmin, jmax;
+	double sigma;
+	zend_long na = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+	double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
 
-    unsigned int s = zephir_get_intval(stride);
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
 
-    unsigned int na = zend_array_count(aa);
-    unsigned int nb = zend_array_count(ab);
-    unsigned int nc = na + nb - 1;
+	zend_long s = zephir_get_intval(stride);
 
-    double * va = emalloc(na * sizeof(double));
-    double * vb = emalloc(nb * sizeof(double));
+	zend_long nc = na + nb - 1;
+	zend_long nout = (nc + s - 1) / s;
 
-    for (i = 0; i < na; ++i) {
-        va[i] = zephir_get_doubleval(zend_hash_index_find(aa, i));
-    }
+	zval c;
 
-    for (i = 0; i < nb; ++i) {
-        vb[i] = zephir_get_doubleval(zend_hash_index_find(ab, i));
-    }
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, nout, &c) == FAILURE)) {
+		return;
+	}
 
-    array_init_size(&c, (nc + s - 1) / s);
+	double * vc = zephir_buffer_doubles(&c);
 
-    for (i = 0; i < nc; i += s) {
-        jmin = i >= nb - 1 ? i - (nb - 1) : 0;
-        jmax = i < na ? i : na - 1;
+	zend_long idx = 0;
 
-        sigma = 0.0;
+	for (i = 0; i < nc; i += s) {
+		jmin = i >= nb - 1 ? i - (nb - 1) : 0;
+		jmax = i < na ? i : na - 1;
 
-        for (j = jmin; j <= jmax; ++j) {
-            sigma += va[j] * vb[i - j];
-        }
+		sigma = 0.0;
 
-        add_next_index_double(&c, sigma);
-    }
+		for (j = jmin; j <= jmax; ++j) {
+			sigma += va[j] * vb[i - j];
+		}
 
-    RETVAL_ARR(Z_ARR(c));
+		vc[idx++] = sigma;
+	}
 
-    efree(va);
-    efree(vb);
+	zval_ptr_dtor(&c);
 }
 
 /**
diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index 5680679..d0af344 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -108,6 +108,33 @@ PHP_METHOD(Tensor_ColumnVector, quick)
 	RETURN_MM();
 }
 
+/**
+ * Build a column vector from a TensorBuffer object.
+ *
+ * @param \Tensor\TensorBuffer a
+ * @return self
+ */
+PHP_METHOD(Tensor_ColumnVector, fromTensorBuffer)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *a, a_sub, _0;
+
+	ZVAL_UNDEF(&a_sub);
+	ZVAL_UNDEF(&_0);
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_OBJECT_OF_CLASS(a, tensor_tensorbuffer_ce)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &a);
+	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.
  *
@@ -151,7 +178,7 @@ PHP_METHOD(Tensor_ColumnVector, transpose)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 3, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -262,7 +289,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 103);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -279,7 +306,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 112);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 123);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -292,8 +319,8 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 101);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -303,7 +330,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 109);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 120);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -311,7 +338,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 					ZVAL_COPY(&valueB, _17$$4);
 					ZEPHIR_INIT_NVAR(&_18$$5);
 					mul_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 106);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 117);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -333,11 +360,11 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 					zephir_check_call_status();
 						ZEPHIR_INIT_NVAR(&_21$$6);
 						mul_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 106);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 117);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 109);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 120);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -360,8 +387,8 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 101);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -371,7 +398,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 109);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 120);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -379,7 +406,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 						ZVAL_COPY(&valueB, _27$$7);
 						ZEPHIR_INIT_NVAR(&_28$$8);
 						mul_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 106);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 117);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -401,11 +428,11 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 						zephir_check_call_status();
 							ZEPHIR_INIT_NVAR(&_31$$9);
 							mul_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 106);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 117);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 109);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 120);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -493,7 +520,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 138);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -510,7 +537,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 147);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 158);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -523,8 +550,8 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 136);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -534,7 +561,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 144);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 155);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -542,7 +569,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 					ZVAL_COPY(&valueB, _17$$4);
 					ZEPHIR_INIT_NVAR(&_18$$5);
 					div_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 141);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 152);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -564,11 +591,11 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 					zephir_check_call_status();
 						ZEPHIR_INIT_NVAR(&_21$$6);
 						div_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 141);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 152);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 144);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 155);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -591,8 +618,8 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 136);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -602,7 +629,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 144);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 155);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -610,7 +637,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 						ZVAL_COPY(&valueB, _27$$7);
 						ZEPHIR_INIT_NVAR(&_28$$8);
 						div_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 141);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 152);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -632,11 +659,11 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 						zephir_check_call_status();
 							ZEPHIR_INIT_NVAR(&_31$$9);
 							div_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 141);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 152);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 144);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 155);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -724,7 +751,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 173);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -741,7 +768,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 182);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 193);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -754,8 +781,8 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 171);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -765,7 +792,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 179);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 190);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -773,7 +800,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 					ZVAL_COPY(&valueB, _17$$4);
 					ZEPHIR_INIT_NVAR(&_18$$5);
 					zephir_add_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 176);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 187);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -795,11 +822,11 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 					zephir_check_call_status();
 						ZEPHIR_INIT_NVAR(&_21$$6);
 						zephir_add_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 176);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 187);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 179);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 190);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -822,8 +849,8 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 171);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -833,7 +860,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 179);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 190);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -841,7 +868,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 						ZVAL_COPY(&valueB, _27$$7);
 						ZEPHIR_INIT_NVAR(&_28$$8);
 						zephir_add_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 176);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 187);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -863,11 +890,11 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 						zephir_check_call_status();
 							ZEPHIR_INIT_NVAR(&_31$$9);
 							zephir_add_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 176);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 187);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 179);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 190);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -955,7 +982,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 208);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -972,7 +999,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 217);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 228);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -985,8 +1012,8 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 206);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -996,7 +1023,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 214);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 225);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -1004,7 +1031,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 					ZVAL_COPY(&valueB, _17$$4);
 					ZEPHIR_INIT_NVAR(&_18$$5);
 					zephir_sub_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 211);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 222);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -1026,11 +1053,11 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 					zephir_check_call_status();
 						ZEPHIR_INIT_NVAR(&_21$$6);
 						zephir_sub_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 211);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 222);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 214);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 225);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -1053,8 +1080,8 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 206);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -1064,7 +1091,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 214);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 225);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -1072,7 +1099,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 						ZVAL_COPY(&valueB, _27$$7);
 						ZEPHIR_INIT_NVAR(&_28$$8);
 						zephir_sub_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 211);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 222);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -1094,11 +1121,11 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 						zephir_check_call_status();
 							ZEPHIR_INIT_NVAR(&_31$$9);
 							zephir_sub_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 211);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 222);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 214);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 225);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -1187,7 +1214,7 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 243);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1204,7 +1231,7 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 252);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 263);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -1217,8 +1244,8 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 241);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -1228,15 +1255,15 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 249);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 260);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
 					ZEPHIR_INIT_NVAR(&valueB);
 					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_CALL_FUNCTION(&_18$$5, "pow", &_19, 16, &valueA, &valueB);
+					ZEPHIR_CALL_FUNCTION(&_18$$5, "pow", &_19, 17, &valueA, &valueB);
 					zephir_check_call_status();
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 246);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 257);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -1256,13 +1283,13 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 					}
 					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
 					zephir_check_call_status();
-						ZEPHIR_CALL_FUNCTION(&_22$$6, "pow", &_19, 16, &valueA, &valueB);
+						ZEPHIR_CALL_FUNCTION(&_22$$6, "pow", &_19, 17, &valueA, &valueB);
 						zephir_check_call_status();
-						zephir_array_append(&rowC, &_22$$6, PH_SEPARATE, "tensor/columnvector.zep", 246);
+						zephir_array_append(&rowC, &_22$$6, PH_SEPARATE, "tensor/columnvector.zep", 257);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 249);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 260);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -1285,8 +1312,8 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_25$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_25$$7, &i, PH_NOISY, "tensor/columnvector.zep", 241);
+				ZEPHIR_CALL_METHOD(&valueA, &_25$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -1296,15 +1323,15 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 				} else {
 					_26$$7 = &rowB;
 				}
-				zephir_is_iterable(_26$$7, 0, "tensor/columnvector.zep", 249);
+				zephir_is_iterable(_26$$7, 0, "tensor/columnvector.zep", 260);
 				if (Z_TYPE_P(_26$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_26$$7), _28$$7)
 					{
 						ZEPHIR_INIT_NVAR(&valueB);
 						ZVAL_COPY(&valueB, _28$$7);
-						ZEPHIR_CALL_FUNCTION(&_29$$8, "pow", &_19, 16, &valueA, &valueB);
+						ZEPHIR_CALL_FUNCTION(&_29$$8, "pow", &_19, 17, &valueA, &valueB);
 						zephir_check_call_status();
-						zephir_array_append(&rowC, &_29$$8, PH_SEPARATE, "tensor/columnvector.zep", 246);
+						zephir_array_append(&rowC, &_29$$8, PH_SEPARATE, "tensor/columnvector.zep", 257);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _26$$7, "rewind", NULL, 0);
@@ -1324,13 +1351,13 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 						}
 						ZEPHIR_CALL_METHOD(&valueB, _26$$7, "current", NULL, 0);
 						zephir_check_call_status();
-							ZEPHIR_CALL_FUNCTION(&_32$$9, "pow", &_19, 16, &valueA, &valueB);
+							ZEPHIR_CALL_FUNCTION(&_32$$9, "pow", &_19, 17, &valueA, &valueB);
 							zephir_check_call_status();
-							zephir_array_append(&rowC, &_32$$9, PH_SEPARATE, "tensor/columnvector.zep", 246);
+							zephir_array_append(&rowC, &_32$$9, PH_SEPARATE, "tensor/columnvector.zep", 257);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 249);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 260);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -1418,7 +1445,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 278);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1435,7 +1462,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 287);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 298);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -1448,8 +1475,8 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 276);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -1459,7 +1486,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 284);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 295);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -1467,7 +1494,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 					ZVAL_COPY(&valueB, _17$$4);
 					ZEPHIR_INIT_NVAR(&_18$$5);
 					mod_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 281);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 292);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -1489,11 +1516,11 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 					zephir_check_call_status();
 						ZEPHIR_INIT_NVAR(&_21$$6);
 						mod_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 281);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 292);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 284);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 295);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -1516,8 +1543,8 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 276);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -1527,7 +1554,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 284);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 295);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -1535,7 +1562,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 						ZVAL_COPY(&valueB, _27$$7);
 						ZEPHIR_INIT_NVAR(&_28$$8);
 						mod_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 281);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 292);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -1557,11 +1584,11 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 						zephir_check_call_status();
 							ZEPHIR_INIT_NVAR(&_31$$9);
 							mod_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 281);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 292);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 284);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 295);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -1649,7 +1676,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 313);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1666,7 +1693,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 322);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 333);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -1679,8 +1706,8 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 311);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -1690,7 +1717,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 319);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 330);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -1704,7 +1731,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 						ZEPHIR_INIT_NVAR(&_18$$5);
 						ZVAL_LONG(&_18$$5, 0);
 					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 316);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 327);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -1732,11 +1759,11 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 							ZEPHIR_INIT_NVAR(&_21$$6);
 							ZVAL_LONG(&_21$$6, 0);
 						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 316);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 327);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 319);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 330);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -1759,8 +1786,8 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 311);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -1770,7 +1797,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 319);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 330);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -1784,7 +1811,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 							ZEPHIR_INIT_NVAR(&_28$$8);
 							ZVAL_LONG(&_28$$8, 0);
 						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 316);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 327);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -1812,11 +1839,11 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 								ZEPHIR_INIT_NVAR(&_31$$9);
 								ZVAL_LONG(&_31$$9, 0);
 							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 316);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 327);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 319);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 330);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -1904,7 +1931,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 348);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1921,7 +1948,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 357);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 368);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -1934,8 +1961,8 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 346);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -1945,7 +1972,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 354);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 365);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -1959,7 +1986,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 						ZEPHIR_INIT_NVAR(&_18$$5);
 						ZVAL_LONG(&_18$$5, 0);
 					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 351);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 362);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -1987,11 +2014,11 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 							ZEPHIR_INIT_NVAR(&_21$$6);
 							ZVAL_LONG(&_21$$6, 0);
 						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 351);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 362);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 354);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 365);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -2014,8 +2041,8 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 346);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -2025,7 +2052,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 354);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 365);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -2039,7 +2066,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 							ZEPHIR_INIT_NVAR(&_28$$8);
 							ZVAL_LONG(&_28$$8, 0);
 						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 351);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 362);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -2067,11 +2094,11 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 								ZEPHIR_INIT_NVAR(&_31$$9);
 								ZVAL_LONG(&_31$$9, 0);
 							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 351);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 362);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 354);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 365);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -2159,7 +2186,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 383);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2176,7 +2203,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 392);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 403);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -2189,8 +2216,8 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 381);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -2200,7 +2227,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 389);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 400);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -2214,7 +2241,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 						ZEPHIR_INIT_NVAR(&_18$$5);
 						ZVAL_LONG(&_18$$5, 0);
 					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 386);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 397);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -2242,11 +2269,11 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 							ZEPHIR_INIT_NVAR(&_21$$6);
 							ZVAL_LONG(&_21$$6, 0);
 						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 386);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 397);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 389);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 400);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -2269,8 +2296,8 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 381);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -2280,7 +2307,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 389);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 400);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -2294,7 +2321,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 							ZEPHIR_INIT_NVAR(&_28$$8);
 							ZVAL_LONG(&_28$$8, 0);
 						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 386);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 397);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -2322,11 +2349,11 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 								ZEPHIR_INIT_NVAR(&_31$$9);
 								ZVAL_LONG(&_31$$9, 0);
 							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 386);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 397);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 389);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 400);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -2414,7 +2441,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 418);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2431,7 +2458,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 427);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 438);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -2444,8 +2471,8 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 416);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -2455,7 +2482,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 424);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 435);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -2469,7 +2496,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 						ZEPHIR_INIT_NVAR(&_18$$5);
 						ZVAL_LONG(&_18$$5, 0);
 					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 421);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 432);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -2497,11 +2524,11 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 							ZEPHIR_INIT_NVAR(&_21$$6);
 							ZVAL_LONG(&_21$$6, 0);
 						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 421);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 432);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 424);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 435);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -2524,8 +2551,8 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 416);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -2535,7 +2562,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 424);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 435);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -2549,7 +2576,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 							ZEPHIR_INIT_NVAR(&_28$$8);
 							ZVAL_LONG(&_28$$8, 0);
 						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 421);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 432);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -2577,11 +2604,11 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 								ZEPHIR_INIT_NVAR(&_31$$9);
 								ZVAL_LONG(&_31$$9, 0);
 							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 421);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 432);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 424);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 435);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -2669,7 +2696,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 453);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2686,7 +2713,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 462);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 473);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -2699,8 +2726,8 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 451);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -2710,7 +2737,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 459);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 470);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -2724,7 +2751,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 						ZEPHIR_INIT_NVAR(&_18$$5);
 						ZVAL_LONG(&_18$$5, 0);
 					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 456);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 467);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -2752,11 +2779,11 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 							ZEPHIR_INIT_NVAR(&_21$$6);
 							ZVAL_LONG(&_21$$6, 0);
 						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 456);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 467);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 459);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 470);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -2779,8 +2806,8 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 451);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -2790,7 +2817,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 459);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 470);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -2804,7 +2831,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 							ZEPHIR_INIT_NVAR(&_28$$8);
 							ZVAL_LONG(&_28$$8, 0);
 						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 456);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 467);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -2832,11 +2859,11 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 								ZEPHIR_INIT_NVAR(&_31$$9);
 								ZVAL_LONG(&_31$$9, 0);
 							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 456);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 467);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 459);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 470);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -2924,7 +2951,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 		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_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 488);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2941,7 +2968,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 497);
+	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 508);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -2954,8 +2981,8 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&rowB);
 			ZVAL_COPY(&rowB, _11);
 			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&valueA);
-			zephir_array_fetch(&valueA, &_14$$4, &i, PH_NOISY, "tensor/columnvector.zep", 486);
+			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
+			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
 			if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -2965,7 +2992,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 			} else {
 				_15$$4 = &rowB;
 			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 494);
+			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 505);
 			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
 				{
@@ -2979,7 +3006,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 						ZEPHIR_INIT_NVAR(&_18$$5);
 						ZVAL_LONG(&_18$$5, 0);
 					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 491);
+					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 502);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
@@ -3007,11 +3034,11 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 							ZEPHIR_INIT_NVAR(&_21$$6);
 							ZVAL_LONG(&_21$$6, 0);
 						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 491);
+						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 502);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 494);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 505);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3034,8 +3061,8 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&valueA);
-				zephir_array_fetch(&valueA, &_24$$7, &i, PH_NOISY, "tensor/columnvector.zep", 486);
+				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
+				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
 				if (Z_TYPE_P(&rowB) == IS_STRING) {
@@ -3045,7 +3072,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 				} else {
 					_25$$7 = &rowB;
 				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 494);
+				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 505);
 				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
 					{
@@ -3059,7 +3086,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 							ZEPHIR_INIT_NVAR(&_28$$8);
 							ZVAL_LONG(&_28$$8, 0);
 						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 491);
+						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 502);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
@@ -3087,11 +3114,11 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 								ZEPHIR_INIT_NVAR(&_31$$9);
 								ZVAL_LONG(&_31$$9, 0);
 							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 491);
+							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 502);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 494);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 505);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
diff --git a/ext/tensor/columnvector.zep.h b/ext/tensor/columnvector.zep.h
index 889a56c..5ed2d04 100644
--- a/ext/tensor/columnvector.zep.h
+++ b/ext/tensor/columnvector.zep.h
@@ -5,6 +5,7 @@ ZEPHIR_INIT_CLASS(Tensor_ColumnVector);
 
 PHP_METHOD(Tensor_ColumnVector, build);
 PHP_METHOD(Tensor_ColumnVector, quick);
+PHP_METHOD(Tensor_ColumnVector, fromTensorBuffer);
 PHP_METHOD(Tensor_ColumnVector, m);
 PHP_METHOD(Tensor_ColumnVector, n);
 PHP_METHOD(Tensor_ColumnVector, transpose);
@@ -30,6 +31,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_columnvector_quick, 0, 0, 0)
 ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, a, IS_ARRAY, 0, "[]")
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_columnvector_fromtensorbuffer, 0, 0, 1)
+	ZEND_ARG_OBJ_INFO(0, a, Tensor\\TensorBuffer, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_columnvector_m, 0, 0, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
@@ -94,6 +99,7 @@ ZEND_END_ARG_INFO()
 ZEPHIR_INIT_FUNCS(tensor_columnvector_method_entry) {
 	PHP_ME(Tensor_ColumnVector, build, arginfo_tensor_columnvector_build, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_ColumnVector, quick, arginfo_tensor_columnvector_quick, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	PHP_ME(Tensor_ColumnVector, fromTensorBuffer, arginfo_tensor_columnvector_fromtensorbuffer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_ColumnVector, m, arginfo_tensor_columnvector_m, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_ColumnVector, n, arginfo_tensor_columnvector_n, ZEND_ACC_PUBLIC)
 PHP_ME(Tensor_ColumnVector, transpose, arginfo_tensor_columnvector_transpose, ZEND_ACC_PUBLIC)
diff --git a/ext/tensor/decompositions/cholesky.zep.c b/ext/tensor/decompositions/cholesky.zep.c
index b6e4e73..7c052bc 100644
--- a/ext/tensor/decompositions/cholesky.zep.c
+++ b/ext/tensor/decompositions/cholesky.zep.c
@@ -97,7 +97,7 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 	object_init_ex(return_value, tensor_decompositions_cholesky_ce);
 	ZEPHIR_CALL_CE_STATIC(&_5, tensor_matrix_ce, "quick", NULL, 0, &l);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 24, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/eigen.zep.c b/ext/tensor/decompositions/eigen.zep.c
index f96b093..b6fbc33 100644
--- a/ext/tensor/decompositions/eigen.zep.c
+++ b/ext/tensor/decompositions/eigen.zep.c
@@ -138,7 +138,7 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	ZEPHIR_CALL_METHOD(&eigenvectors, &_8, "transpose", NULL, 0);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_eigen_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &eigenvalues, &eigenvectors);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 22, &eigenvalues, &eigenvectors);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/lu.zep.c b/ext/tensor/decompositions/lu.zep.c
index 39b2774..2558442 100644
--- a/ext/tensor/decompositions/lu.zep.c
+++ b/ext/tensor/decompositions/lu.zep.c
@@ -132,7 +132,7 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 	ZEPHIR_CALL_CE_STATIC(&p, tensor_matrix_ce, "quick", NULL, 0, &_9);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_lu_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 26, &l, &u, &p);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &l, &u, &p);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/svd.zep.c b/ext/tensor/decompositions/svd.zep.c
index 34d89cf..8c95622 100644
--- a/ext/tensor/decompositions/svd.zep.c
+++ b/ext/tensor/decompositions/svd.zep.c
@@ -106,7 +106,7 @@ PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 	ZEPHIR_CALL_CE_STATIC(&vT, tensor_matrix_ce, "quick", NULL, 0, &_4);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_svd_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 27, &u, &singularValues, &vT);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 24, &u, &singularValues, &vT);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 20355cf..4b52d4d 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -23,6 +23,7 @@
 #include "kernel/string.h"
 #include "kernel/math.h"
 #include "ext/spl/spl_array.h"
+#include "include/buffer.h"
 #include "include/linear_algebra.h"
 #include "include/signal_processing.h"
 #include "include/arithmetic.h"
@@ -94,7 +95,7 @@ PHP_METHOD(Tensor_Matrix, build)
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
 	ZVAL_BOOL(&_0, 1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 28, &a, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &a, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -129,7 +130,7 @@ PHP_METHOD(Tensor_Matrix, quick)
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
 	ZVAL_BOOL(&_0, 0);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 28, &a, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &a, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -321,7 +322,7 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 	zephir_fetch_params(1, 1, 0, &elements_param);
 	zephir_get_arrval(&elements, elements_param);
 	n = zephir_fast_count_int(&elements);
-	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 29, &elements);
+	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 26, &elements);
 	zephir_check_call_status();
 	ZEPHIR_CPY_WRT(&elements, &_0);
 	ZEPHIR_INIT_VAR(&a);
@@ -930,43 +931,63 @@ PHP_METHOD(Tensor_Matrix, uniform)
 }
 
 /**
- * @param array[] a
+ * @param array[]|TensorBuffer[] a
  * @param bool validate
  * @throws \Tensor\Exceptions\InvalidArgumentException
  */
 PHP_METHOD(Tensor_Matrix, __construct)
 {
-	zend_string *_5$$5;
-	zend_ulong _4$$5;
+	zval b$$11, rowB$$11;
+	zval _12$$8;
+	zend_string *_4$$3, *_20$$11;
+	zend_ulong _3$$3, _19$$11;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_9 = NULL, *_12 = NULL, *_18 = NULL;
+	zephir_fcall_cache_entry *_24 = NULL, *_32 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, m, n;
-	zend_bool validate, _20$$6;
-	zval *a_param = NULL, *validate_param = NULL, i, rowA, valueA, _0, _1, _23, _2$$5, *_3$$5, _6$$7, _7$$7, _8$$7, _10$$7, _11$$7, *_13$$6, _14$$6, *_15$$6, _19$$6, _16$$8, _17$$8, _21$$9, _22$$9;
-	zval a, b$$5, rowB$$5;
+	zend_bool validate, _8$$3, _5$$4, _9$$6, _38$$11, _34$$12, _50$$16;
+	zval *a = NULL, a_sub, *validate_param = NULL, i, rowA, valueA, _13, _14, _53, *_0$$3, _1$$3, *_2$$3, _7$$3, _6$$5, _10$$7, _11$$8, _15$$11, *_16$$11, _17$$11, *_18$$11, _37$$11, _21$$13, _22$$13, _23$$13, _25$$13, _26$$13, *_27$$12, _28$$12, *_29$$12, _33$$12, _30$$14, _31$$14, _35$$15, _36$$15, _39$$17, _40$$17, _41$$17, _42$$17, _43$$17, *_44$$16, _45$$16, *_46$$16, _49$$16, _47$$18, _48$$18, _51$$19, _52$$19;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&b$$5);
-	ZVAL_UNDEF(&rowB$$5);
+	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_23);
-	ZVAL_UNDEF(&_2$$5);
-	ZVAL_UNDEF(&_6$$7);
-	ZVAL_UNDEF(&_7$$7);
-	ZVAL_UNDEF(&_8$$7);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_53);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_7$$3);
+	ZVAL_UNDEF(&_6$$5);
 	ZVAL_UNDEF(&_10$$7);
-	ZVAL_UNDEF(&_11$$7);
-	ZVAL_UNDEF(&_14$$6);
-	ZVAL_UNDEF(&_19$$6);
-	ZVAL_UNDEF(&_16$$8);
-	ZVAL_UNDEF(&_17$$8);
-	ZVAL_UNDEF(&_21$$9);
-	ZVAL_UNDEF(&_22$$9);
+	ZVAL_UNDEF(&_11$$8);
+	ZVAL_UNDEF(&_15$$11);
+	ZVAL_UNDEF(&_17$$11);
+	ZVAL_UNDEF(&_37$$11);
+	ZVAL_UNDEF(&_21$$13);
+	ZVAL_UNDEF(&_22$$13);
+	ZVAL_UNDEF(&_23$$13);
+	ZVAL_UNDEF(&_25$$13);
+	ZVAL_UNDEF(&_26$$13);
+	ZVAL_UNDEF(&_28$$12);
+	ZVAL_UNDEF(&_33$$12);
+	ZVAL_UNDEF(&_30$$14);
+	ZVAL_UNDEF(&_31$$14);
+	ZVAL_UNDEF(&_35$$15);
+	ZVAL_UNDEF(&_36$$15);
+	ZVAL_UNDEF(&_39$$17);
+	ZVAL_UNDEF(&_40$$17);
+	ZVAL_UNDEF(&_41$$17);
+	ZVAL_UNDEF(&_42$$17);
+	ZVAL_UNDEF(&_43$$17);
+	ZVAL_UNDEF(&_45$$16);
+	ZVAL_UNDEF(&_49$$16);
+	ZVAL_UNDEF(&_47$$18);
+	ZVAL_UNDEF(&_48$$18);
+	ZVAL_UNDEF(&_51$$19);
+	ZVAL_UNDEF(&_52$$19);
+	ZVAL_UNDEF(&_12$$8);
+	ZVAL_UNDEF(&b$$11);
+	ZVAL_UNDEF(&rowB$$11);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
@@ -981,136 +1002,315 @@ PHP_METHOD(Tensor_Matrix, __construct)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 2)
-		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
+		Z_PARAM_ZVAL(a)
 		Z_PARAM_OPTIONAL
 		Z_PARAM_BOOL(validate)
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 1, &a_param, &validate_param);
-	zephir_get_arrval(&a, a_param);
+	zephir_fetch_params(1, 1, 1, &a, &validate_param);
+	ZEPHIR_SEPARATE_PARAM(a);
 	if (!validate_param) {
 		validate = 1;
 	} else {
 		}
-	m = zephir_fast_count_int(&a);
-	ZEPHIR_INIT_VAR(&_0);
-	ZEPHIR_CALL_FUNCTION(&_1, "current", NULL, 30, &a);
+	if (Z_TYPE_P(a) == IS_ARRAY) {
+		if (Z_TYPE_P(a) == IS_STRING) {
+			ZEPHIR_INIT_VAR(&_1$$3);
+			zephir_string_to_char_array(&_1$$3, a);
+			_0$$3 = &_1$$3;
+		} else {
+			_0$$3 = a;
+		}
+		zephir_is_iterable(_0$$3, 0, "tensor/matrix.zep", 391);
+		if (Z_TYPE_P(_0$$3) == IS_ARRAY) {
+			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_0$$3), _3$$3, _4$$3, _2$$3)
+			{
+				ZEPHIR_INIT_NVAR(&i);
+				if (_4$$3 != NULL) { 
+					ZVAL_STR_COPY(&i, _4$$3);
+				} else {
+					ZVAL_LONG(&i, _3$$3);
+				}
+				ZEPHIR_INIT_NVAR(&rowA);
+				ZVAL_COPY(&rowA, _2$$3);
+				_5$$4 = Z_TYPE_P(&rowA) == IS_OBJECT;
+				if (_5$$4) {
+					_5$$4 = zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce);
+				}
+				if (_5$$4) {
+					ZEPHIR_CALL_METHOD(&_6$$5, &rowA, "toArray", NULL, 0);
+					zephir_check_call_status();
+					zephir_array_update_zval(a, &i, &_6$$5, PH_COPY | PH_SEPARATE);
+				}
+			} ZEND_HASH_FOREACH_END();
+		} else {
+			ZEPHIR_CALL_METHOD(NULL, _0$$3, "rewind", NULL, 0);
+			zephir_check_call_status();
+			_8$$3 = 1;
+			while (1) {
+				if (_8$$3) {
+					_8$$3 = 0;
+				} else {
+					ZEPHIR_CALL_METHOD(NULL, _0$$3, "next", NULL, 0);
+					zephir_check_call_status();
+				}
+				ZEPHIR_CALL_METHOD(&_7$$3, _0$$3, "valid", NULL, 0);
+				zephir_check_call_status();
+				if (!zend_is_true(&_7$$3)) {
+					break;
+				}
+				ZEPHIR_CALL_METHOD(&i, _0$$3, "key", NULL, 0);
+				zephir_check_call_status();
+				ZEPHIR_CALL_METHOD(&rowA, _0$$3, "current", NULL, 0);
+				zephir_check_call_status();
+					_9$$6 = Z_TYPE_P(&rowA) == IS_OBJECT;
+					if (_9$$6) {
+						_9$$6 = zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce);
+					}
+					if (_9$$6) {
+						ZEPHIR_CALL_METHOD(&_10$$7, &rowA, "toArray", NULL, 0);
+						zephir_check_call_status();
+						zephir_array_update_zval(a, &i, &_10$$7, PH_COPY | PH_SEPARATE);
+					}
+			}
+		}
+		ZEPHIR_INIT_NVAR(&rowA);
+		ZEPHIR_INIT_NVAR(&i);
+	} else {
+		ZEPHIR_INIT_VAR(&_11$$8);
+		object_init_ex(&_11$$8, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_12$$8);
+		ZEPHIR_CONCAT_SS(&_12$$8, "Matrix requires an", " array of arrays.");
+		ZEPHIR_CALL_METHOD(NULL, &_11$$8, "__construct", NULL, 3, &_12$$8);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_11$$8, "tensor/matrix.zep", 393);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	m = zephir_fast_count_int(a);
+	ZEPHIR_INIT_VAR(&_13);
+	ZEPHIR_CALL_FUNCTION(&_14, "current", NULL, 27, a);
 	zephir_check_call_status();
-	if (!(zephir_is_true(&_1))) {
-		ZEPHIR_INIT_NVAR(&_0);
-		array_init(&_0);
+	if (!(zephir_is_true(&_14))) {
+		ZEPHIR_INIT_NVAR(&_13);
+		array_init(&_13);
 	} else {
-		ZEPHIR_CALL_FUNCTION(&_0, "current", NULL, 30, &a);
+		ZEPHIR_CALL_FUNCTION(&_13, "current", NULL, 27, a);
 		zephir_check_call_status();
 	}
-	n = zephir_fast_count_int(&_0);
+	n = zephir_fast_count_int(&_13);
 	if (validate) {
-		ZEPHIR_INIT_VAR(&b$$5);
-		array_init(&b$$5);
-		ZEPHIR_INIT_VAR(&rowB$$5);
-		array_init(&rowB$$5);
-		ZEPHIR_CALL_FUNCTION(&_2$$5, "array_values", NULL, 29, &a);
-		zephir_check_call_status();
-		ZEPHIR_CPY_WRT(&a, &_2$$5);
-		zephir_is_iterable(&a, 0, "tensor/matrix.zep", 407);
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&a), _4$$5, _5$$5, _3$$5)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_5$$5 != NULL) { 
-				ZVAL_STR_COPY(&i, _5$$5);
-			} else {
-				ZVAL_LONG(&i, _4$$5);
-			}
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3$$5);
-			if (UNEXPECTED(zephir_fast_count_int(&rowA) != n)) {
-				ZEPHIR_INIT_NVAR(&_6$$7);
-				object_init_ex(&_6$$7, tensor_exceptions_invalidargumentexception_ce);
-				ZVAL_LONG(&_7$$7, n);
-				ZEPHIR_CALL_FUNCTION(&_8$$7, "strval", &_9, 4, &_7$$7);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_10$$7);
-				ZVAL_LONG(&_10$$7, zephir_fast_count_int(&rowA));
-				ZEPHIR_INIT_NVAR(&_11$$7);
-				ZEPHIR_CONCAT_SSVSVSSVS(&_11$$7, "The number of columns", " must be equal for all rows, ", &_8$$7, " needed but ", &_10$$7, " given", " at row offset ", &i, ".");
-				ZEPHIR_CALL_METHOD(NULL, &_6$$7, "__construct", &_12, 3, &_11$$7);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_6$$7, "tensor/matrix.zep", 395);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-			ZEPHIR_INIT_NVAR(&rowB$$5);
-			array_init(&rowB$$5);
-			ZEPHIR_CPY_WRT(&rowB$$5, &rowB$$5);
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_14$$6);
-				zephir_string_to_char_array(&_14$$6, &rowA);
-				_13$$6 = &_14$$6;
-			} else {
-				_13$$6 = &rowA;
-			}
-			zephir_is_iterable(_13$$6, 0, "tensor/matrix.zep", 404);
-			if (Z_TYPE_P(_13$$6) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_13$$6), _15$$6)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _15$$6);
-					ZEPHIR_INIT_NVAR(&_16$$8);
-					ZEPHIR_CALL_FUNCTION(&_17$$8, "is_float", &_18, 2, &valueA);
+		ZEPHIR_INIT_VAR(&b$$11);
+		array_init(&b$$11);
+		ZEPHIR_INIT_VAR(&rowB$$11);
+		array_init(&rowB$$11);
+		ZEPHIR_CALL_FUNCTION(&_15$$11, "array_values", NULL, 26, a);
+		zephir_check_call_status();
+		ZEPHIR_CPY_WRT(a, &_15$$11);
+		if (Z_TYPE_P(a) == IS_STRING) {
+			ZEPHIR_INIT_VAR(&_17$$11);
+			zephir_string_to_char_array(&_17$$11, a);
+			_16$$11 = &_17$$11;
+		} else {
+			_16$$11 = a;
+		}
+		zephir_is_iterable(_16$$11, 0, "tensor/matrix.zep", 422);
+		if (Z_TYPE_P(_16$$11) == IS_ARRAY) {
+			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_16$$11), _19$$11, _20$$11, _18$$11)
+			{
+				ZEPHIR_INIT_NVAR(&i);
+				if (_20$$11 != NULL) { 
+					ZVAL_STR_COPY(&i, _20$$11);
+				} else {
+					ZVAL_LONG(&i, _19$$11);
+				}
+				ZEPHIR_INIT_NVAR(&rowA);
+				ZVAL_COPY(&rowA, _18$$11);
+				if (UNEXPECTED(zephir_fast_count_int(&rowA) != n)) {
+					ZEPHIR_INIT_NVAR(&_21$$13);
+					object_init_ex(&_21$$13, tensor_exceptions_invalidargumentexception_ce);
+					ZVAL_LONG(&_22$$13, n);
+					ZEPHIR_CALL_FUNCTION(&_23$$13, "strval", &_24, 4, &_22$$13);
 					zephir_check_call_status();
-					if (zephir_is_true(&_17$$8)) {
-						ZEPHIR_CPY_WRT(&_16$$8, &valueA);
-					} else {
-						ZEPHIR_INIT_NVAR(&_16$$8);
-						ZVAL_DOUBLE(&_16$$8, zephir_get_doubleval(&valueA));
+					ZEPHIR_INIT_NVAR(&_25$$13);
+					ZVAL_LONG(&_25$$13, zephir_fast_count_int(&rowA));
+					ZEPHIR_INIT_NVAR(&_26$$13);
+					ZEPHIR_CONCAT_SSVSVSSVS(&_26$$13, "The number of columns", " must be equal for all rows, ", &_23$$13, " needed but ", &_25$$13, " given", " at row offset ", &i, ".");
+					ZEPHIR_CALL_METHOD(NULL, &_21$$13, "__construct", NULL, 3, &_26$$13);
+					zephir_check_call_status();
+					zephir_throw_exception_debug(&_21$$13, "tensor/matrix.zep", 410);
+					ZEPHIR_MM_RESTORE();
+					return;
+				}
+				ZEPHIR_INIT_NVAR(&rowB$$11);
+				array_init(&rowB$$11);
+				ZEPHIR_CPY_WRT(&rowB$$11, &rowB$$11);
+				if (Z_TYPE_P(&rowA) == IS_STRING) {
+					ZEPHIR_INIT_NVAR(&_28$$12);
+					zephir_string_to_char_array(&_28$$12, &rowA);
+					_27$$12 = &_28$$12;
+				} else {
+					_27$$12 = &rowA;
+				}
+				zephir_is_iterable(_27$$12, 0, "tensor/matrix.zep", 419);
+				if (Z_TYPE_P(_27$$12) == IS_ARRAY) {
+					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_27$$12), _29$$12)
+					{
+						ZEPHIR_INIT_NVAR(&valueA);
+						ZVAL_COPY(&valueA, _29$$12);
+						ZEPHIR_INIT_NVAR(&_30$$14);
+						ZEPHIR_CALL_FUNCTION(&_31$$14, "is_float", &_32, 2, &valueA);
+						zephir_check_call_status();
+						if (zephir_is_true(&_31$$14)) {
+							ZEPHIR_CPY_WRT(&_30$$14, &valueA);
+						} else {
+							ZEPHIR_INIT_NVAR(&_30$$14);
+							ZVAL_DOUBLE(&_30$$14, zephir_get_doubleval(&valueA));
+						}
+						zephir_array_append(&rowB$$11, &_30$$14, PH_SEPARATE, "tensor/matrix.zep", 416);
+					} ZEND_HASH_FOREACH_END();
+				} else {
+					ZEPHIR_CALL_METHOD(NULL, _27$$12, "rewind", NULL, 0);
+					zephir_check_call_status();
+					_34$$12 = 1;
+					while (1) {
+						if (_34$$12) {
+							_34$$12 = 0;
+						} else {
+							ZEPHIR_CALL_METHOD(NULL, _27$$12, "next", NULL, 0);
+							zephir_check_call_status();
+						}
+						ZEPHIR_CALL_METHOD(&_33$$12, _27$$12, "valid", NULL, 0);
+						zephir_check_call_status();
+						if (!zend_is_true(&_33$$12)) {
+							break;
+						}
+						ZEPHIR_CALL_METHOD(&valueA, _27$$12, "current", NULL, 0);
+						zephir_check_call_status();
+							ZEPHIR_INIT_NVAR(&_35$$15);
+							ZEPHIR_CALL_FUNCTION(&_36$$15, "is_float", &_32, 2, &valueA);
+							zephir_check_call_status();
+							if (zephir_is_true(&_36$$15)) {
+								ZEPHIR_CPY_WRT(&_35$$15, &valueA);
+							} else {
+								ZEPHIR_INIT_NVAR(&_35$$15);
+								ZVAL_DOUBLE(&_35$$15, zephir_get_doubleval(&valueA));
+							}
+							zephir_array_append(&rowB$$11, &_35$$15, PH_SEPARATE, "tensor/matrix.zep", 416);
 					}
-					zephir_array_append(&rowB$$5, &_16$$8, PH_SEPARATE, "tensor/matrix.zep", 401);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _13$$6, "rewind", NULL, 0);
+				}
+				ZEPHIR_INIT_NVAR(&valueA);
+				zephir_array_append(&b$$11, &rowB$$11, PH_SEPARATE, "tensor/matrix.zep", 419);
+			} ZEND_HASH_FOREACH_END();
+		} else {
+			ZEPHIR_CALL_METHOD(NULL, _16$$11, "rewind", NULL, 0);
+			zephir_check_call_status();
+			_38$$11 = 1;
+			while (1) {
+				if (_38$$11) {
+					_38$$11 = 0;
+				} else {
+					ZEPHIR_CALL_METHOD(NULL, _16$$11, "next", NULL, 0);
+					zephir_check_call_status();
+				}
+				ZEPHIR_CALL_METHOD(&_37$$11, _16$$11, "valid", NULL, 0);
 				zephir_check_call_status();
-				_20$$6 = 1;
-				while (1) {
-					if (_20$$6) {
-						_20$$6 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _13$$6, "next", NULL, 0);
+				if (!zend_is_true(&_37$$11)) {
+					break;
+				}
+				ZEPHIR_CALL_METHOD(&i, _16$$11, "key", NULL, 0);
+				zephir_check_call_status();
+				ZEPHIR_CALL_METHOD(&rowA, _16$$11, "current", NULL, 0);
+				zephir_check_call_status();
+					if (UNEXPECTED(zephir_fast_count_int(&rowA) != n)) {
+						ZEPHIR_INIT_NVAR(&_39$$17);
+						object_init_ex(&_39$$17, tensor_exceptions_invalidargumentexception_ce);
+						ZVAL_LONG(&_40$$17, n);
+						ZEPHIR_CALL_FUNCTION(&_41$$17, "strval", &_24, 4, &_40$$17);
+						zephir_check_call_status();
+						ZEPHIR_INIT_NVAR(&_42$$17);
+						ZVAL_LONG(&_42$$17, zephir_fast_count_int(&rowA));
+						ZEPHIR_INIT_NVAR(&_43$$17);
+						ZEPHIR_CONCAT_SSVSVSSVS(&_43$$17, "The number of columns", " must be equal for all rows, ", &_41$$17, " needed but ", &_42$$17, " given", " at row offset ", &i, ".");
+						ZEPHIR_CALL_METHOD(NULL, &_39$$17, "__construct", NULL, 3, &_43$$17);
 						zephir_check_call_status();
+						zephir_throw_exception_debug(&_39$$17, "tensor/matrix.zep", 410);
+						ZEPHIR_MM_RESTORE();
+						return;
 					}
-					ZEPHIR_CALL_METHOD(&_19$$6, _13$$6, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$6)) {
-						break;
+					ZEPHIR_INIT_NVAR(&rowB$$11);
+					array_init(&rowB$$11);
+					ZEPHIR_CPY_WRT(&rowB$$11, &rowB$$11);
+					if (Z_TYPE_P(&rowA) == IS_STRING) {
+						ZEPHIR_INIT_NVAR(&_45$$16);
+						zephir_string_to_char_array(&_45$$16, &rowA);
+						_44$$16 = &_45$$16;
+					} else {
+						_44$$16 = &rowA;
 					}
-					ZEPHIR_CALL_METHOD(&valueA, _13$$6, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$9);
-						ZEPHIR_CALL_FUNCTION(&_22$$9, "is_float", &_18, 2, &valueA);
+					zephir_is_iterable(_44$$16, 0, "tensor/matrix.zep", 419);
+					if (Z_TYPE_P(_44$$16) == IS_ARRAY) {
+						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_44$$16), _46$$16)
+						{
+							ZEPHIR_INIT_NVAR(&valueA);
+							ZVAL_COPY(&valueA, _46$$16);
+							ZEPHIR_INIT_NVAR(&_47$$18);
+							ZEPHIR_CALL_FUNCTION(&_48$$18, "is_float", &_32, 2, &valueA);
+							zephir_check_call_status();
+							if (zephir_is_true(&_48$$18)) {
+								ZEPHIR_CPY_WRT(&_47$$18, &valueA);
+							} else {
+								ZEPHIR_INIT_NVAR(&_47$$18);
+								ZVAL_DOUBLE(&_47$$18, zephir_get_doubleval(&valueA));
+							}
+							zephir_array_append(&rowB$$11, &_47$$18, PH_SEPARATE, "tensor/matrix.zep", 416);
+						} ZEND_HASH_FOREACH_END();
+					} else {
+						ZEPHIR_CALL_METHOD(NULL, _44$$16, "rewind", NULL, 0);
 						zephir_check_call_status();
-						if (zephir_is_true(&_22$$9)) {
-							ZEPHIR_CPY_WRT(&_21$$9, &valueA);
-						} else {
-							ZEPHIR_INIT_NVAR(&_21$$9);
-							ZVAL_DOUBLE(&_21$$9, zephir_get_doubleval(&valueA));
+						_50$$16 = 1;
+						while (1) {
+							if (_50$$16) {
+								_50$$16 = 0;
+							} else {
+								ZEPHIR_CALL_METHOD(NULL, _44$$16, "next", NULL, 0);
+								zephir_check_call_status();
+							}
+							ZEPHIR_CALL_METHOD(&_49$$16, _44$$16, "valid", NULL, 0);
+							zephir_check_call_status();
+							if (!zend_is_true(&_49$$16)) {
+								break;
+							}
+							ZEPHIR_CALL_METHOD(&valueA, _44$$16, "current", NULL, 0);
+							zephir_check_call_status();
+								ZEPHIR_INIT_NVAR(&_51$$19);
+								ZEPHIR_CALL_FUNCTION(&_52$$19, "is_float", &_32, 2, &valueA);
+								zephir_check_call_status();
+								if (zephir_is_true(&_52$$19)) {
+									ZEPHIR_CPY_WRT(&_51$$19, &valueA);
+								} else {
+									ZEPHIR_INIT_NVAR(&_51$$19);
+									ZVAL_DOUBLE(&_51$$19, zephir_get_doubleval(&valueA));
+								}
+								zephir_array_append(&rowB$$11, &_51$$19, PH_SEPARATE, "tensor/matrix.zep", 416);
 						}
-						zephir_array_append(&rowB$$5, &_21$$9, PH_SEPARATE, "tensor/matrix.zep", 401);
-				}
+					}
+					ZEPHIR_INIT_NVAR(&valueA);
+					zephir_array_append(&b$$11, &rowB$$11, PH_SEPARATE, "tensor/matrix.zep", 419);
 			}
-			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b$$5, &rowB$$5, PH_SEPARATE, "tensor/matrix.zep", 404);
-		} ZEND_HASH_FOREACH_END();
+		}
 		ZEPHIR_INIT_NVAR(&rowA);
 		ZEPHIR_INIT_NVAR(&i);
-		ZEPHIR_CPY_WRT(&a, &b$$5);
-	}
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &a);
-	ZVAL_UNDEF(&_23);
-	ZVAL_LONG(&_23, m);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_23);
-	ZVAL_UNDEF(&_23);
-	ZVAL_LONG(&_23, n);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_23);
+		ZEPHIR_CPY_WRT(a, &b$$11);
+	}
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, a);
+	ZVAL_UNDEF(&_53);
+	ZVAL_LONG(&_53, m);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_53);
+	ZVAL_UNDEF(&_53);
+	ZVAL_LONG(&_53, n);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_53);
 	ZEPHIR_MM_RESTORE();
 }
 
@@ -1312,7 +1512,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 	zephir_fetch_params(1, 1, 0, &index_param);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_1, index);
-	ZEPHIR_CALL_FUNCTION(&_2, "array_column", NULL, 31, &_0, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "array_column", NULL, 28, &_0, &_1);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
 	zephir_check_call_status();
@@ -1366,7 +1566,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 507);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 522);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1380,7 +1580,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 	} else {
 		_5 = &_4;
 	}
-	zephir_is_iterable(_5, 0, "tensor/matrix.zep", 518);
+	zephir_is_iterable(_5, 0, "tensor/matrix.zep", 533);
 	if (Z_TYPE_P(_5) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_5), _8, _9, _7)
 		{
@@ -1393,8 +1593,8 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 			ZEPHIR_INIT_NVAR(&rowA);
 			ZVAL_COPY(&rowA, _7);
 			ZEPHIR_OBS_NVAR(&_10$$4);
-			zephir_array_fetch(&_10$$4, &rowA, &i, PH_NOISY, "tensor/matrix.zep", 515);
-			zephir_array_append(&b, &_10$$4, PH_SEPARATE, "tensor/matrix.zep", 515);
+			zephir_array_fetch(&_10$$4, &rowA, &i, PH_NOISY, "tensor/matrix.zep", 530);
+			zephir_array_append(&b, &_10$$4, PH_SEPARATE, "tensor/matrix.zep", 530);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _5, "rewind", NULL, 0);
@@ -1417,8 +1617,8 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 			ZEPHIR_CALL_METHOD(&rowA, _5, "current", NULL, 0);
 			zephir_check_call_status();
 				ZEPHIR_OBS_NVAR(&_13$$5);
-				zephir_array_fetch(&_13$$5, &rowA, &i, PH_NOISY, "tensor/matrix.zep", 515);
-				zephir_array_append(&b, &_13$$5, PH_SEPARATE, "tensor/matrix.zep", 515);
+				zephir_array_fetch(&_13$$5, &rowA, &i, PH_NOISY, "tensor/matrix.zep", 530);
+				zephir_array_append(&b, &_13$$5, PH_SEPARATE, "tensor/matrix.zep", 530);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -1439,6 +1639,91 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	RETURN_MEMBER_TYPED(getThis(), "a", IS_ARRAY);
 }
 
+/**
+ * Return each row of the matrix as a TensorBuffer.
+ *
+ * @return \Tensor\TensorBuffer[]
+ */
+PHP_METHOD(Tensor_Matrix, asRowBuffers)
+{
+	zend_bool _7;
+	zval b;
+	zval row, buffer, _0, *_1, _2, *_3, _6, _4$$3, _8$$4;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zephir_fcall_cache_entry *_5 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&row);
+	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_8$$4);
+	ZVAL_UNDEF(&b);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	if (Z_TYPE_P(&_0) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_2);
+		zephir_string_to_char_array(&_2, &_0);
+		_1 = &_2;
+	} else {
+		_1 = &_0;
+	}
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 563);
+	if (Z_TYPE_P(_1) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
+		{
+			ZEPHIR_INIT_NVAR(&row);
+			ZVAL_COPY(&row, _3);
+			ZEPHIR_INIT_NVAR(&buffer);
+			tensor_buffer_from_array(&buffer, &row);
+			ZEPHIR_INIT_NVAR(&_4$$3);
+			object_init_ex(&_4$$3, tensor_tensorbuffer_ce);
+			ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", &_5, 14, &buffer);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 560);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_7 = 1;
+		while (1) {
+			if (_7) {
+				_7 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_6)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&row, _1, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&buffer);
+				tensor_buffer_from_array(&buffer, &row);
+				ZEPHIR_INIT_NVAR(&_8$$4);
+				object_init_ex(&_8$$4, tensor_tensorbuffer_ce);
+				ZEPHIR_CALL_METHOD(NULL, &_8$$4, "__construct", &_5, 14, &buffer);
+				zephir_check_call_status();
+				zephir_array_append(&b, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 560);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&row);
+	RETURN_CTOR(&b);
+}
+
 /**
  * Return each row as a vector in an array.
  *
@@ -1471,7 +1756,7 @@ PHP_METHOD(Tensor_Matrix, asVectors)
 	ZVAL_STRING(&_1, "quick");
 	zephir_array_fast_append(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_FUNCTION("array_map", NULL, 14, &_0, &_2);
+	ZEPHIR_RETURN_CALL_FUNCTION("array_map", NULL, 15, &_0, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1522,7 +1807,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			ZVAL_LONG(&_5$$3, i);
 			ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "columnAsVector", &_6, 0, &_5$$3);
 			zephir_check_call_status();
-			zephir_array_append(&vectors, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 553);
+			zephir_array_append(&vectors, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 588);
 		}
 	}
 	RETURN_CTOR(&vectors);
@@ -1608,15 +1893,15 @@ PHP_METHOD(Tensor_Matrix, map)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 587);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 622);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
 			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_CALL_FUNCTION(&_4$$3, "array_map", &_5, 14, callback, &rowA);
+			ZEPHIR_CALL_FUNCTION(&_4$$3, "array_map", &_5, 15, callback, &rowA);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 584);
+			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 619);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -1636,9 +1921,9 @@ PHP_METHOD(Tensor_Matrix, map)
 			}
 			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_CALL_FUNCTION(&_8$$4, "array_map", &_5, 14, callback, &rowA);
+				ZEPHIR_CALL_FUNCTION(&_8$$4, "array_map", &_5, 15, callback, &rowA);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 584);
+				zephir_array_append(&b, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 619);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -1708,7 +1993,7 @@ PHP_METHOD(Tensor_Matrix, reduce)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 611);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 646);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -1721,7 +2006,7 @@ PHP_METHOD(Tensor_Matrix, reduce)
 			} else {
 				_4$$3 = &rowA;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 609);
+			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 644);
 			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
 				{
@@ -1781,7 +2066,7 @@ PHP_METHOD(Tensor_Matrix, reduce)
 				} else {
 					_13$$6 = &rowA;
 				}
-				zephir_is_iterable(_13$$6, 0, "tensor/matrix.zep", 609);
+				zephir_is_iterable(_13$$6, 0, "tensor/matrix.zep", 644);
 				if (Z_TYPE_P(_13$$6) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_13$$6), _15$$6)
 					{
@@ -1871,9 +2156,9 @@ PHP_METHOD(Tensor_Matrix, transpose)
 			i = _2;
 			zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZVAL_LONG(&_5$$3, i);
-			ZEPHIR_CALL_FUNCTION(&_6$$3, "array_column", &_7, 31, &_4$$3, &_5$$3);
+			ZEPHIR_CALL_FUNCTION(&_6$$3, "array_column", &_7, 28, &_4$$3, &_5$$3);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 626);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 661);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
@@ -1924,7 +2209,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 642);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 677);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1935,9 +2220,9 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_5$$4, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 32, &_6$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 29, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 647);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 682);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1949,9 +2234,9 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_8$$5, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_9$$5);
 		ZEPHIR_CONCAT_SS(&_9$$5, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_8$$5, "__construct", NULL, 32, &_9$$5);
+		ZEPHIR_CALL_METHOD(NULL, &_8$$5, "__construct", NULL, 29, &_9$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_8$$5, "tensor/matrix.zep", 654);
+		zephir_throw_exception_debug(&_8$$5, "tensor/matrix.zep", 689);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1992,9 +2277,9 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		object_init_ex(&_1$$3, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_2$$3);
 		ZEPHIR_CONCAT_SS(&_2$$3, "Failed to compute the pseudoinverse", " of the matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 32, &_2$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 29, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 671);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 706);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2041,7 +2326,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 687);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 722);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2056,7 +2341,7 @@ PHP_METHOD(Tensor_Matrix, det)
 	ZEPHIR_CALL_METHOD(&_6, &ref, "swaps", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_7, -1.0);
-	ZEPHIR_CALL_FUNCTION(&_8, "pow", NULL, 16, &_7, &_6);
+	ZEPHIR_CALL_FUNCTION(&_8, "pow", NULL, 17, &_7, &_6);
 	zephir_check_call_status();
 	mul_function(return_value, &pi, &_8);
 	RETURN_MM();
@@ -2127,7 +2412,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 	ZEPHIR_CPY_WRT(&a, &_3);
 	pivots = 0;
 	epsilon =  (0.00000001);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 742);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 777);
 	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _4)
 	{
 		ZEPHIR_INIT_NVAR(&rowA);
@@ -2140,7 +2425,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 		} else {
 			_5$$3 = &rowA;
 		}
-		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 740);
+		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 775);
 		if (Z_TYPE_P(_5$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$3), _7$$3)
 			{
@@ -2213,7 +2498,7 @@ PHP_METHOD(Tensor_Matrix, fullRank)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_1, this_ptr, "shape", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 19, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 30, &_1);
 	zephir_check_call_status();
 	RETURN_MM_BOOL(ZEPHIR_IS_IDENTICAL(&_0, &_2));
 }
@@ -2277,7 +2562,7 @@ PHP_METHOD(Tensor_Matrix, symmetric)
 			i = _3;
 			zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&rowA);
-			zephir_array_fetch_long(&rowA, &_5$$4, i, PH_NOISY, "tensor/matrix.zep", 771);
+			zephir_array_fetch_long(&rowA, &_5$$4, i, PH_NOISY, "tensor/matrix.zep", 806);
 			zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 			_9$$4 = (zephir_get_numberval(&_6$$4) - 1);
 			_8$$4 = (i + 1);
@@ -2294,12 +2579,12 @@ PHP_METHOD(Tensor_Matrix, symmetric)
 					}
 					j = _8$$4;
 					ZEPHIR_OBS_NVAR(&_10$$5);
-					zephir_array_fetch_long(&_10$$5, &rowA, j, PH_NOISY, "tensor/matrix.zep", 774);
+					zephir_array_fetch_long(&_10$$5, &rowA, j, PH_NOISY, "tensor/matrix.zep", 809);
 					zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 					ZEPHIR_OBS_NVAR(&_12$$5);
-					zephir_array_fetch_long(&_12$$5, &_11$$5, j, PH_NOISY, "tensor/matrix.zep", 774);
+					zephir_array_fetch_long(&_12$$5, &_11$$5, j, PH_NOISY, "tensor/matrix.zep", 809);
 					ZEPHIR_OBS_NVAR(&_13$$5);
-					zephir_array_fetch_long(&_13$$5, &_12$$5, i, PH_NOISY, "tensor/matrix.zep", 774);
+					zephir_array_fetch_long(&_13$$5, &_12$$5, i, PH_NOISY, "tensor/matrix.zep", 809);
 					if (!ZEPHIR_IS_EQUAL(&_10$$5, &_13$$5)) {
 						RETURN_MM_BOOL(0);
 					}
@@ -2368,7 +2653,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_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/matrix.zep", 795);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 830);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2436,7 +2721,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements 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", 813);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 848);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2524,7 +2809,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 3, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 831);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 866);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2538,7 +2823,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 3, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 836);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 871);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2855,7 +3140,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 975);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1010);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2926,7 +3211,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1008);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1043);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2998,7 +3283,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1042);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1077);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3070,7 +3355,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1076);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1111);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3142,7 +3427,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1110);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1145);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3214,7 +3499,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1144);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1179);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3286,7 +3571,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1178);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1213);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3358,7 +3643,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1212);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1247);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3430,7 +3715,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1246);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1281);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3502,7 +3787,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1280);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1315);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3574,7 +3859,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1314);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1349);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3646,7 +3931,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1348);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1383);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3869,7 +4154,7 @@ PHP_METHOD(Tensor_Matrix, log)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 1439);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 1474);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -3884,7 +4169,7 @@ PHP_METHOD(Tensor_Matrix, log)
 			} else {
 				_5$$4 = &rowA;
 			}
-			zephir_is_iterable(_5$$4, 0, "tensor/matrix.zep", 1436);
+			zephir_is_iterable(_5$$4, 0, "tensor/matrix.zep", 1471);
 			if (Z_TYPE_P(_5$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$4), _7$$4)
 				{
@@ -3893,7 +4178,7 @@ PHP_METHOD(Tensor_Matrix, log)
 					ZVAL_DOUBLE(&_8$$5, base);
 					ZEPHIR_CALL_FUNCTION(&_9$$5, "log", &_10, 8, &valueA, &_8$$5);
 					zephir_check_call_status();
-					zephir_array_append(&rowB, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 1433);
+					zephir_array_append(&rowB, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 1468);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _5$$4, "rewind", NULL, 0);
@@ -3916,11 +4201,11 @@ PHP_METHOD(Tensor_Matrix, log)
 						ZVAL_DOUBLE(&_13$$6, base);
 						ZEPHIR_CALL_FUNCTION(&_14$$6, "log", &_10, 8, &valueA, &_13$$6);
 						zephir_check_call_status();
-						zephir_array_append(&rowB, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 1433);
+						zephir_array_append(&rowB, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 1468);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1436);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1471);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -3949,7 +4234,7 @@ PHP_METHOD(Tensor_Matrix, log)
 				} else {
 					_17$$7 = &rowA;
 				}
-				zephir_is_iterable(_17$$7, 0, "tensor/matrix.zep", 1436);
+				zephir_is_iterable(_17$$7, 0, "tensor/matrix.zep", 1471);
 				if (Z_TYPE_P(_17$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$7), _19$$7)
 					{
@@ -3958,7 +4243,7 @@ PHP_METHOD(Tensor_Matrix, log)
 						ZVAL_DOUBLE(&_20$$8, base);
 						ZEPHIR_CALL_FUNCTION(&_21$$8, "log", &_10, 8, &valueA, &_20$$8);
 						zephir_check_call_status();
-						zephir_array_append(&rowB, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 1433);
+						zephir_array_append(&rowB, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 1468);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _17$$7, "rewind", NULL, 0);
@@ -3981,11 +4266,11 @@ PHP_METHOD(Tensor_Matrix, log)
 							ZVAL_DOUBLE(&_24$$9, base);
 							ZEPHIR_CALL_FUNCTION(&_25$$9, "log", &_10, 8, &valueA, &_24$$9);
 							zephir_check_call_status();
-							zephir_array_append(&rowB, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 1433);
+							zephir_array_append(&rowB, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 1468);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1436);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1471);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -4226,7 +4511,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_INIT_VAR(&_1);
 	ZVAL_STRING(&_1, "array_sum");
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 14, &_1, &_0);
+	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, &_1, &_0);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
 	zephir_check_call_status();
@@ -4258,7 +4543,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_INIT_VAR(&_1);
 	ZVAL_STRING(&_1, "array_product");
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 14, &_1, &_0);
+	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, &_1, &_0);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
 	zephir_check_call_status();
@@ -4290,7 +4575,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_INIT_VAR(&_1);
 	ZVAL_STRING(&_1, "min");
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 14, &_1, &_0);
+	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, &_1, &_0);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
 	zephir_check_call_status();
@@ -4322,7 +4607,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_INIT_VAR(&_1);
 	ZVAL_STRING(&_1, "max");
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 14, &_1, &_0);
+	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, &_1, &_0);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
 	zephir_check_call_status();
@@ -4403,7 +4688,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_1, 2);
-	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 21, &_0, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 18, &_0, &_1);
 	zephir_check_call_status();
 	mid = zephir_get_intval(&_2);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
@@ -4416,30 +4701,30 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_4 = &_3;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 1608);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 1643);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
 			ZVAL_COPY(&rowA, _6);
 			ZEPHIR_MAKE_REF(&rowA);
-			ZEPHIR_CALL_FUNCTION(NULL, "sort", &_7, 22, &rowA);
+			ZEPHIR_CALL_FUNCTION(NULL, "sort", &_7, 19, &rowA);
 			ZEPHIR_UNREF(&rowA);
 			zephir_check_call_status();
 			if (odd) {
 				ZEPHIR_OBS_NVAR(&median);
-				zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1600);
+				zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1635);
 			} else {
 				ZEPHIR_OBS_NVAR(&_8$$5);
-				zephir_array_fetch_long(&_8$$5, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1602);
+				zephir_array_fetch_long(&_8$$5, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1637);
 				ZEPHIR_OBS_NVAR(&_9$$5);
-				zephir_array_fetch_long(&_9$$5, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1602);
+				zephir_array_fetch_long(&_9$$5, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1637);
 				ZEPHIR_INIT_NVAR(&_10$$5);
 				zephir_add_function(&_10$$5, &_8$$5, &_9$$5);
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_10$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1605);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1640);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -4460,23 +4745,23 @@ PHP_METHOD(Tensor_Matrix, median)
 			ZEPHIR_CALL_METHOD(&rowA, _4, "current", NULL, 0);
 			zephir_check_call_status();
 				ZEPHIR_MAKE_REF(&rowA);
-				ZEPHIR_CALL_FUNCTION(NULL, "sort", &_7, 22, &rowA);
+				ZEPHIR_CALL_FUNCTION(NULL, "sort", &_7, 19, &rowA);
 				ZEPHIR_UNREF(&rowA);
 				zephir_check_call_status();
 				if (odd) {
 					ZEPHIR_OBS_NVAR(&median);
-					zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1600);
+					zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1635);
 				} else {
 					ZEPHIR_OBS_NVAR(&_13$$8);
-					zephir_array_fetch_long(&_13$$8, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1602);
+					zephir_array_fetch_long(&_13$$8, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1637);
 					ZEPHIR_OBS_NVAR(&_14$$8);
-					zephir_array_fetch_long(&_14$$8, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1602);
+					zephir_array_fetch_long(&_14$$8, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1637);
 					ZEPHIR_INIT_NVAR(&_15$$8);
 					zephir_add_function(&_15$$8, &_13$$8, &_14$$8);
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_15$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1605);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1640);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -4557,7 +4842,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1622);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1657);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4575,34 +4860,34 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 1650);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 1685);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_7), _9)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
 			ZVAL_COPY(&rowA, _9);
 			ZEPHIR_MAKE_REF(&rowA);
-			ZEPHIR_CALL_FUNCTION(NULL, "sort", &_10, 22, &rowA);
+			ZEPHIR_CALL_FUNCTION(NULL, "sort", &_10, 19, &rowA);
 			ZEPHIR_UNREF(&rowA);
 			zephir_check_call_status();
 			zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			if (ZEPHIR_LE_LONG(&_11$$4, xHat)) {
 				ZEPHIR_OBS_NVAR(&_12$$5);
 				zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-				zephir_array_fetch_long(&_12$$5, &rowA, (zephir_get_numberval(&_13$$5) - 1), PH_NOISY, "tensor/matrix.zep", 1640);
+				zephir_array_fetch_long(&_12$$5, &rowA, (zephir_get_numberval(&_13$$5) - 1), PH_NOISY, "tensor/matrix.zep", 1675);
 				ZEPHIR_INIT_NVAR(&_14$$5);
 				ZVAL_DOUBLE(&_14$$5, zephir_get_doubleval(&_12$$5));
-				zephir_array_append(&b, &_14$$5, PH_SEPARATE, "tensor/matrix.zep", 1640);
+				zephir_array_append(&b, &_14$$5, PH_SEPARATE, "tensor/matrix.zep", 1675);
 				continue;
 			}
 			ZEPHIR_OBS_NVAR(&_15$$4);
-			zephir_array_fetch_long(&_15$$4, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1645);
+			zephir_array_fetch_long(&_15$$4, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1680);
 			t =  (zephir_get_doubleval(&_15$$4));
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch_long(&_16$$4, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1647);
+			zephir_array_fetch_long(&_16$$4, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1682);
 			ZEPHIR_INIT_NVAR(&_17$$4);
 			ZVAL_DOUBLE(&_17$$4, (t + (remainder * (zephir_get_numberval(&_16$$4) - t))));
-			zephir_array_append(&b, &_17$$4, PH_SEPARATE, "tensor/matrix.zep", 1647);
+			zephir_array_append(&b, &_17$$4, PH_SEPARATE, "tensor/matrix.zep", 1682);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -4623,27 +4908,27 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			ZEPHIR_CALL_METHOD(&rowA, _7, "current", NULL, 0);
 			zephir_check_call_status();
 				ZEPHIR_MAKE_REF(&rowA);
-				ZEPHIR_CALL_FUNCTION(NULL, "sort", &_10, 22, &rowA);
+				ZEPHIR_CALL_FUNCTION(NULL, "sort", &_10, 19, &rowA);
 				ZEPHIR_UNREF(&rowA);
 				zephir_check_call_status();
 				zephir_read_property_cached(&_20$$6, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 				if (ZEPHIR_LE_LONG(&_20$$6, xHat)) {
 					ZEPHIR_OBS_NVAR(&_21$$7);
 					zephir_read_property_cached(&_22$$7, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-					zephir_array_fetch_long(&_21$$7, &rowA, (zephir_get_numberval(&_22$$7) - 1), PH_NOISY, "tensor/matrix.zep", 1640);
+					zephir_array_fetch_long(&_21$$7, &rowA, (zephir_get_numberval(&_22$$7) - 1), PH_NOISY, "tensor/matrix.zep", 1675);
 					ZEPHIR_INIT_NVAR(&_23$$7);
 					ZVAL_DOUBLE(&_23$$7, zephir_get_doubleval(&_21$$7));
-					zephir_array_append(&b, &_23$$7, PH_SEPARATE, "tensor/matrix.zep", 1640);
+					zephir_array_append(&b, &_23$$7, PH_SEPARATE, "tensor/matrix.zep", 1675);
 					continue;
 				}
 				ZEPHIR_OBS_NVAR(&_24$$6);
-				zephir_array_fetch_long(&_24$$6, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1645);
+				zephir_array_fetch_long(&_24$$6, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1680);
 				t =  (zephir_get_doubleval(&_24$$6));
 				ZEPHIR_OBS_NVAR(&_25$$6);
-				zephir_array_fetch_long(&_25$$6, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1647);
+				zephir_array_fetch_long(&_25$$6, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1682);
 				ZEPHIR_INIT_NVAR(&_26$$6);
 				ZVAL_DOUBLE(&_26$$6, (t + (remainder * (zephir_get_numberval(&_25$$6) - t))));
-				zephir_array_append(&b, &_26$$6, PH_SEPARATE, "tensor/matrix.zep", 1647);
+				zephir_array_append(&b, &_26$$6, PH_SEPARATE, "tensor/matrix.zep", 1682);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -4718,7 +5003,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1666);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1701);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -4738,7 +5023,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 3, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1672);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1707);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -4827,7 +5112,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 3, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1697);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1732);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -4919,7 +5204,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_4$$4, "Decimal precision cannot", " be less than 0, ", &_3$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_4$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$4, "tensor/matrix.zep", 1723);
+		zephir_throw_exception_debug(&_1$$4, "tensor/matrix.zep", 1758);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4935,7 +5220,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_6 = &_5;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1741);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1776);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -4950,7 +5235,7 @@ PHP_METHOD(Tensor_Matrix, round)
 			} else {
 				_9$$5 = &rowA;
 			}
-			zephir_is_iterable(_9$$5, 0, "tensor/matrix.zep", 1738);
+			zephir_is_iterable(_9$$5, 0, "tensor/matrix.zep", 1773);
 			if (Z_TYPE_P(_9$$5) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9$$5), _11$$5)
 				{
@@ -4959,7 +5244,7 @@ PHP_METHOD(Tensor_Matrix, round)
 					ZEPHIR_INIT_NVAR(&_12$$6);
 					ZVAL_LONG(&_13$$6, precision);
 					zephir_round(&_12$$6, &valueA, &_13$$6, NULL);
-					zephir_array_append(&rowB, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 1735);
+					zephir_array_append(&rowB, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 1770);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9$$5, "rewind", NULL, 0);
@@ -4982,11 +5267,11 @@ PHP_METHOD(Tensor_Matrix, round)
 						ZEPHIR_INIT_NVAR(&_16$$7);
 						ZVAL_LONG(&_17$$7, precision);
 						zephir_round(&_16$$7, &valueA, &_17$$7, NULL);
-						zephir_array_append(&rowB, &_16$$7, PH_SEPARATE, "tensor/matrix.zep", 1735);
+						zephir_array_append(&rowB, &_16$$7, PH_SEPARATE, "tensor/matrix.zep", 1770);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1738);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1773);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5015,7 +5300,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				} else {
 					_20$$8 = &rowA;
 				}
-				zephir_is_iterable(_20$$8, 0, "tensor/matrix.zep", 1738);
+				zephir_is_iterable(_20$$8, 0, "tensor/matrix.zep", 1773);
 				if (Z_TYPE_P(_20$$8) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_20$$8), _22$$8)
 					{
@@ -5024,7 +5309,7 @@ PHP_METHOD(Tensor_Matrix, round)
 						ZEPHIR_INIT_NVAR(&_23$$9);
 						ZVAL_LONG(&_24$$9, precision);
 						zephir_round(&_23$$9, &valueA, &_24$$9, NULL);
-						zephir_array_append(&rowB, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 1735);
+						zephir_array_append(&rowB, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 1770);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _20$$8, "rewind", NULL, 0);
@@ -5047,11 +5332,11 @@ PHP_METHOD(Tensor_Matrix, round)
 							ZEPHIR_INIT_NVAR(&_27$$10);
 							ZVAL_LONG(&_28$$10, precision);
 							zephir_round(&_27$$10, &valueA, &_28$$10, NULL);
-							zephir_array_append(&rowB, &_27$$10, PH_SEPARATE, "tensor/matrix.zep", 1735);
+							zephir_array_append(&rowB, &_27$$10, PH_SEPARATE, "tensor/matrix.zep", 1770);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1738);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1773);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5168,7 +5453,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1777);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1812);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5184,7 +5469,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 	} else {
 		_3 = &_2;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1807);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1842);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5199,7 +5484,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 			} else {
 				_6$$4 = &rowA;
 			}
-			zephir_is_iterable(_6$$4, 0, "tensor/matrix.zep", 1804);
+			zephir_is_iterable(_6$$4, 0, "tensor/matrix.zep", 1839);
 			if (Z_TYPE_P(_6$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6$$4), _8$$4)
 				{
@@ -5208,16 +5493,16 @@ PHP_METHOD(Tensor_Matrix, clip)
 					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 						ZEPHIR_INIT_NVAR(&_9$$6);
 						ZVAL_DOUBLE(&_9$$6, max);
-						zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/matrix.zep", 1790);
+						zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/matrix.zep", 1825);
 						continue;
 					}
 					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 						ZEPHIR_INIT_NVAR(&_10$$7);
 						ZVAL_DOUBLE(&_10$$7, min);
-						zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1796);
+						zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1831);
 						continue;
 					}
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1801);
+					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1836);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _6$$4, "rewind", NULL, 0);
@@ -5240,20 +5525,20 @@ PHP_METHOD(Tensor_Matrix, clip)
 						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 							ZEPHIR_INIT_NVAR(&_13$$9);
 							ZVAL_DOUBLE(&_13$$9, max);
-							zephir_array_append(&rowB, &_13$$9, PH_SEPARATE, "tensor/matrix.zep", 1790);
+							zephir_array_append(&rowB, &_13$$9, PH_SEPARATE, "tensor/matrix.zep", 1825);
 							continue;
 						}
 						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 							ZEPHIR_INIT_NVAR(&_14$$10);
 							ZVAL_DOUBLE(&_14$$10, min);
-							zephir_array_append(&rowB, &_14$$10, PH_SEPARATE, "tensor/matrix.zep", 1796);
+							zephir_array_append(&rowB, &_14$$10, PH_SEPARATE, "tensor/matrix.zep", 1831);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1801);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1836);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1804);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1839);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5282,7 +5567,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 				} else {
 					_17$$11 = &rowA;
 				}
-				zephir_is_iterable(_17$$11, 0, "tensor/matrix.zep", 1804);
+				zephir_is_iterable(_17$$11, 0, "tensor/matrix.zep", 1839);
 				if (Z_TYPE_P(_17$$11) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$11), _19$$11)
 					{
@@ -5291,16 +5576,16 @@ PHP_METHOD(Tensor_Matrix, clip)
 						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 							ZEPHIR_INIT_NVAR(&_20$$13);
 							ZVAL_DOUBLE(&_20$$13, max);
-							zephir_array_append(&rowB, &_20$$13, PH_SEPARATE, "tensor/matrix.zep", 1790);
+							zephir_array_append(&rowB, &_20$$13, PH_SEPARATE, "tensor/matrix.zep", 1825);
 							continue;
 						}
 						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 							ZEPHIR_INIT_NVAR(&_21$$14);
 							ZVAL_DOUBLE(&_21$$14, min);
-							zephir_array_append(&rowB, &_21$$14, PH_SEPARATE, "tensor/matrix.zep", 1796);
+							zephir_array_append(&rowB, &_21$$14, PH_SEPARATE, "tensor/matrix.zep", 1831);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1801);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1836);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _17$$11, "rewind", NULL, 0);
@@ -5323,20 +5608,20 @@ PHP_METHOD(Tensor_Matrix, clip)
 							if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 								ZEPHIR_INIT_NVAR(&_24$$16);
 								ZVAL_DOUBLE(&_24$$16, max);
-								zephir_array_append(&rowB, &_24$$16, PH_SEPARATE, "tensor/matrix.zep", 1790);
+								zephir_array_append(&rowB, &_24$$16, PH_SEPARATE, "tensor/matrix.zep", 1825);
 								continue;
 							}
 							if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 								ZEPHIR_INIT_NVAR(&_25$$17);
 								ZVAL_DOUBLE(&_25$$17, min);
-								zephir_array_append(&rowB, &_25$$17, PH_SEPARATE, "tensor/matrix.zep", 1796);
+								zephir_array_append(&rowB, &_25$$17, PH_SEPARATE, "tensor/matrix.zep", 1831);
 								continue;
 							}
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1801);
+							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1836);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1804);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1839);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5400,7 +5685,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1839);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1874);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -5415,7 +5700,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 			} else {
 				_4$$3 = &rowA;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1836);
+			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1871);
 			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
 				{
@@ -5424,10 +5709,10 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 						ZEPHIR_INIT_NVAR(&_7$$5);
 						ZVAL_DOUBLE(&_7$$5, min);
-						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1828);
+						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1863);
 						continue;
 					}
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1833);
+					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1868);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
@@ -5450,14 +5735,14 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 							ZEPHIR_INIT_NVAR(&_10$$7);
 							ZVAL_DOUBLE(&_10$$7, min);
-							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1828);
+							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1863);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1833);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1868);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1836);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1871);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -5486,7 +5771,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 				} else {
 					_13$$8 = &rowA;
 				}
-				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 1836);
+				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 1871);
 				if (Z_TYPE_P(_13$$8) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_13$$8), _15$$8)
 					{
@@ -5495,10 +5780,10 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 							ZEPHIR_INIT_NVAR(&_16$$10);
 							ZVAL_DOUBLE(&_16$$10, min);
-							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 1828);
+							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 1863);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1833);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1868);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _13$$8, "rewind", NULL, 0);
@@ -5521,14 +5806,14 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 							if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 								ZEPHIR_INIT_NVAR(&_19$$12);
 								ZVAL_DOUBLE(&_19$$12, min);
-								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 1828);
+								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 1863);
 								continue;
 							}
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1833);
+							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1868);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1836);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1871);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5592,7 +5877,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1871);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1906);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -5607,7 +5892,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 			} else {
 				_4$$3 = &rowA;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1868);
+			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1903);
 			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
 				{
@@ -5616,10 +5901,10 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 						ZEPHIR_INIT_NVAR(&_7$$5);
 						ZVAL_DOUBLE(&_7$$5, max);
-						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1860);
+						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1895);
 						continue;
 					}
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1865);
+					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1900);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
@@ -5642,14 +5927,14 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 							ZEPHIR_INIT_NVAR(&_10$$7);
 							ZVAL_DOUBLE(&_10$$7, max);
-							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1860);
+							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1895);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1865);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1900);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1868);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1903);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -5678,7 +5963,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 				} else {
 					_13$$8 = &rowA;
 				}
-				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 1868);
+				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 1903);
 				if (Z_TYPE_P(_13$$8) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_13$$8), _15$$8)
 					{
@@ -5687,10 +5972,10 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 							ZEPHIR_INIT_NVAR(&_16$$10);
 							ZVAL_DOUBLE(&_16$$10, max);
-							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 1860);
+							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 1895);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1865);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1900);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _13$$8, "rewind", NULL, 0);
@@ -5713,14 +5998,14 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 							if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 								ZEPHIR_INIT_NVAR(&_19$$12);
 								ZVAL_DOUBLE(&_19$$12, max);
-								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 1860);
+								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 1895);
 								continue;
 							}
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1865);
+							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1900);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1868);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1903);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5785,7 +6070,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1902);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1937);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -5800,7 +6085,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 			} else {
 				_4$$3 = &rowA;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1899);
+			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1934);
 			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
 				{
@@ -5809,15 +6094,15 @@ PHP_METHOD(Tensor_Matrix, sign)
 					if (ZEPHIR_GT_LONG(&valueA, 0)) {
 						ZEPHIR_INIT_NVAR(&_7$$5);
 						ZVAL_DOUBLE(&_7$$5, 1.0);
-						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1891);
+						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1926);
 					} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 						ZEPHIR_INIT_NVAR(&_8$$6);
 						ZVAL_DOUBLE(&_8$$6, -1.0);
-						zephir_array_append(&rowB, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 1893);
+						zephir_array_append(&rowB, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 1928);
 					} else {
 						ZEPHIR_INIT_NVAR(&_9$$7);
 						ZVAL_DOUBLE(&_9$$7, 0.0);
-						zephir_array_append(&rowB, &_9$$7, PH_SEPARATE, "tensor/matrix.zep", 1895);
+						zephir_array_append(&rowB, &_9$$7, PH_SEPARATE, "tensor/matrix.zep", 1930);
 					}
 				} ZEND_HASH_FOREACH_END();
 			} else {
@@ -5841,20 +6126,20 @@ PHP_METHOD(Tensor_Matrix, sign)
 						if (ZEPHIR_GT_LONG(&valueA, 0)) {
 							ZEPHIR_INIT_NVAR(&_12$$9);
 							ZVAL_DOUBLE(&_12$$9, 1.0);
-							zephir_array_append(&rowB, &_12$$9, PH_SEPARATE, "tensor/matrix.zep", 1891);
+							zephir_array_append(&rowB, &_12$$9, PH_SEPARATE, "tensor/matrix.zep", 1926);
 						} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 							ZEPHIR_INIT_NVAR(&_13$$10);
 							ZVAL_DOUBLE(&_13$$10, -1.0);
-							zephir_array_append(&rowB, &_13$$10, PH_SEPARATE, "tensor/matrix.zep", 1893);
+							zephir_array_append(&rowB, &_13$$10, PH_SEPARATE, "tensor/matrix.zep", 1928);
 						} else {
 							ZEPHIR_INIT_NVAR(&_14$$11);
 							ZVAL_DOUBLE(&_14$$11, 0.0);
-							zephir_array_append(&rowB, &_14$$11, PH_SEPARATE, "tensor/matrix.zep", 1895);
+							zephir_array_append(&rowB, &_14$$11, PH_SEPARATE, "tensor/matrix.zep", 1930);
 						}
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1899);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1934);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -5883,7 +6168,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 				} else {
 					_17$$12 = &rowA;
 				}
-				zephir_is_iterable(_17$$12, 0, "tensor/matrix.zep", 1899);
+				zephir_is_iterable(_17$$12, 0, "tensor/matrix.zep", 1934);
 				if (Z_TYPE_P(_17$$12) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$12), _19$$12)
 					{
@@ -5892,15 +6177,15 @@ PHP_METHOD(Tensor_Matrix, sign)
 						if (ZEPHIR_GT_LONG(&valueA, 0)) {
 							ZEPHIR_INIT_NVAR(&_20$$14);
 							ZVAL_DOUBLE(&_20$$14, 1.0);
-							zephir_array_append(&rowB, &_20$$14, PH_SEPARATE, "tensor/matrix.zep", 1891);
+							zephir_array_append(&rowB, &_20$$14, PH_SEPARATE, "tensor/matrix.zep", 1926);
 						} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 							ZEPHIR_INIT_NVAR(&_21$$15);
 							ZVAL_DOUBLE(&_21$$15, -1.0);
-							zephir_array_append(&rowB, &_21$$15, PH_SEPARATE, "tensor/matrix.zep", 1893);
+							zephir_array_append(&rowB, &_21$$15, PH_SEPARATE, "tensor/matrix.zep", 1928);
 						} else {
 							ZEPHIR_INIT_NVAR(&_22$$16);
 							ZVAL_DOUBLE(&_22$$16, 0.0);
-							zephir_array_append(&rowB, &_22$$16, PH_SEPARATE, "tensor/matrix.zep", 1895);
+							zephir_array_append(&rowB, &_22$$16, PH_SEPARATE, "tensor/matrix.zep", 1930);
 						}
 					} ZEND_HASH_FOREACH_END();
 				} else {
@@ -5924,20 +6209,20 @@ PHP_METHOD(Tensor_Matrix, sign)
 							if (ZEPHIR_GT_LONG(&valueA, 0)) {
 								ZEPHIR_INIT_NVAR(&_25$$18);
 								ZVAL_DOUBLE(&_25$$18, 1.0);
-								zephir_array_append(&rowB, &_25$$18, PH_SEPARATE, "tensor/matrix.zep", 1891);
+								zephir_array_append(&rowB, &_25$$18, PH_SEPARATE, "tensor/matrix.zep", 1926);
 							} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 								ZEPHIR_INIT_NVAR(&_26$$19);
 								ZVAL_DOUBLE(&_26$$19, -1.0);
-								zephir_array_append(&rowB, &_26$$19, PH_SEPARATE, "tensor/matrix.zep", 1893);
+								zephir_array_append(&rowB, &_26$$19, PH_SEPARATE, "tensor/matrix.zep", 1928);
 							} else {
 								ZEPHIR_INIT_NVAR(&_27$$20);
 								ZVAL_DOUBLE(&_27$$20, 0.0);
-								zephir_array_append(&rowB, &_27$$20, PH_SEPARATE, "tensor/matrix.zep", 1895);
+								zephir_array_append(&rowB, &_27$$20, PH_SEPARATE, "tensor/matrix.zep", 1930);
 							}
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1899);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1934);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5990,7 +6275,7 @@ PHP_METHOD(Tensor_Matrix, negate)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1927);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1962);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -6005,14 +6290,14 @@ PHP_METHOD(Tensor_Matrix, negate)
 			} else {
 				_4$$3 = &rowA;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1924);
+			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1959);
 			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
 				{
 					ZEPHIR_INIT_NVAR(&valueA);
 					ZVAL_COPY(&valueA, _6$$3);
 					zephir_negate(&valueA);
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1921);
+					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1956);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
@@ -6033,11 +6318,11 @@ PHP_METHOD(Tensor_Matrix, negate)
 					ZEPHIR_CALL_METHOD(&valueA, _4$$3, "current", NULL, 0);
 					zephir_check_call_status();
 						zephir_negate(&valueA);
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1921);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1956);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1924);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1959);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -6066,14 +6351,14 @@ PHP_METHOD(Tensor_Matrix, negate)
 				} else {
 					_11$$6 = &rowA;
 				}
-				zephir_is_iterable(_11$$6, 0, "tensor/matrix.zep", 1924);
+				zephir_is_iterable(_11$$6, 0, "tensor/matrix.zep", 1959);
 				if (Z_TYPE_P(_11$$6) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_11$$6), _13$$6)
 					{
 						ZEPHIR_INIT_NVAR(&valueA);
 						ZVAL_COPY(&valueA, _13$$6);
 						zephir_negate(&valueA);
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1921);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1956);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _11$$6, "rewind", NULL, 0);
@@ -6094,11 +6379,11 @@ PHP_METHOD(Tensor_Matrix, negate)
 						ZEPHIR_CALL_METHOD(&valueA, _11$$6, "current", NULL, 0);
 						zephir_check_call_status();
 							zephir_negate(&valueA);
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1921);
+							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1956);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1924);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1959);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6176,7 +6461,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", 1942);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1977);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6259,7 +6544,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", 1960);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1995);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6339,7 +6624,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", 1978);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2013);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6348,7 +6633,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_INIT_VAR(&_12);
 	ZVAL_STRING(&_12, "array_merge");
-	ZEPHIR_CALL_FUNCTION(&_13, "array_map", NULL, 14, &_12, &_10, &_11);
+	ZEPHIR_CALL_FUNCTION(&_13, "array_map", NULL, 15, &_12, &_10, &_11);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_13);
 	zephir_check_call_status();
@@ -6421,7 +6706,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", 1996);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2031);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6430,7 +6715,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&_12);
 	ZVAL_STRING(&_12, "array_merge");
-	ZEPHIR_CALL_FUNCTION(&_13, "array_map", NULL, 14, &_12, &_10, &_11);
+	ZEPHIR_CALL_FUNCTION(&_13, "array_map", NULL, 15, &_12, &_10, &_11);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_13);
 	zephir_check_call_status();
@@ -6491,7 +6776,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_1$$3 = &_0$$3;
 		}
-		zephir_is_iterable(_1$$3, 0, "tensor/matrix.zep", 2026);
+		zephir_is_iterable(_1$$3, 0, "tensor/matrix.zep", 2061);
 		if (Z_TYPE_P(_1$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1$$3), _3$$3)
 			{
@@ -6503,14 +6788,14 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					if (!(zephir_fast_count_int(&temp) <= n)) {
 						break;
 					}
-					zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2021);
+					zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2056);
 				}
 				ZEPHIR_INIT_NVAR(&_4$$4);
 				ZEPHIR_INIT_NVAR(&_5$$4);
 				ZVAL_STRING(&_5$$4, "array_merge");
 				ZEPHIR_CALL_USER_FUNC_ARRAY(&_4$$4, &_5$$4, &temp);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/matrix.zep", 2024);
+				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/matrix.zep", 2059);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _1$$3, "rewind", NULL, 0);
@@ -6536,14 +6821,14 @@ PHP_METHOD(Tensor_Matrix, repeat)
 						if (!(zephir_fast_count_int(&temp) <= n)) {
 							break;
 						}
-						zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2021);
+						zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2056);
 					}
 					ZEPHIR_INIT_NVAR(&_8$$6);
 					ZEPHIR_INIT_NVAR(&_9$$6);
 					ZVAL_STRING(&_9$$6, "array_merge");
 					ZEPHIR_CALL_USER_FUNC_ARRAY(&_8$$6, &_9$$6, &temp);
 					zephir_check_call_status();
-					zephir_array_append(&b, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 2024);
+					zephir_array_append(&b, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 2059);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
@@ -6554,7 +6839,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		if (!(zephir_fast_count_int(&temp) <= m)) {
 			break;
 		}
-		zephir_array_append(&temp, &b, PH_SEPARATE, "tensor/matrix.zep", 2031);
+		zephir_array_append(&temp, &b, PH_SEPARATE, "tensor/matrix.zep", 2066);
 	}
 	ZEPHIR_INIT_VAR(&_10);
 	ZEPHIR_INIT_VAR(&_11);
@@ -6629,7 +6914,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2048);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2083);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6644,7 +6929,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2059);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2094);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -6659,9 +6944,9 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2056);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2091);
 			tensor_multiply(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2056);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2091);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -6686,9 +6971,9 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2056);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2091);
 				tensor_multiply(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2056);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2091);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -6761,7 +7046,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2073);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2108);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6776,7 +7061,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2084);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2119);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -6791,9 +7076,9 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2081);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2116);
 			tensor_divide(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2081);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2116);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -6818,9 +7103,9 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2081);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2116);
 				tensor_divide(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2081);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2116);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -6893,7 +7178,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2098);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2133);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6908,7 +7193,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2109);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2144);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -6923,9 +7208,9 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2106);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2141);
 			tensor_add(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2106);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2141);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -6950,9 +7235,9 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2106);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2141);
 				tensor_add(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2106);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2141);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7025,7 +7310,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2123);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2158);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7040,7 +7325,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2134);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2169);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7055,9 +7340,9 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2131);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2166);
 			tensor_subtract(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2131);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2166);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7082,9 +7367,9 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2131);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2166);
 				tensor_subtract(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2131);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2166);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7158,7 +7443,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2149);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2184);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7173,7 +7458,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2160);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2195);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7188,9 +7473,9 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2157);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2192);
 			tensor_pow(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2157);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2192);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7215,9 +7500,9 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2157);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2192);
 				tensor_pow(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2157);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2192);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7291,7 +7576,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2175);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2210);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7306,7 +7591,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2186);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2221);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7321,9 +7606,9 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2183);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2218);
 			tensor_mod(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2183);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2218);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7348,9 +7633,9 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2183);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2218);
 				tensor_mod(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2183);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2218);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7424,7 +7709,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2201);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2236);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7439,7 +7724,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2212);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2247);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7454,9 +7739,9 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2209);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2244);
 			tensor_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2209);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2244);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7481,9 +7766,9 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2209);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2244);
 				tensor_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2209);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2244);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7556,7 +7841,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2226);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2261);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7571,7 +7856,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2237);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2272);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7586,9 +7871,9 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2234);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2269);
 			tensor_not_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2234);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2269);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7613,9 +7898,9 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2234);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2269);
 				tensor_not_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2234);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2269);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7689,7 +7974,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2252);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2287);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7704,7 +7989,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2263);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2298);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7719,9 +8004,9 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2260);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2295);
 			tensor_greater(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2260);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2295);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7746,9 +8031,9 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2260);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2295);
 				tensor_greater(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2260);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2295);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7822,7 +8107,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2278);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2313);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7837,7 +8122,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2289);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2324);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7852,9 +8137,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2286);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2321);
 			tensor_greater_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2286);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2321);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7879,9 +8164,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2286);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2321);
 				tensor_greater_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2286);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2321);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7954,7 +8239,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2303);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2338);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7969,7 +8254,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2314);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2349);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7984,9 +8269,9 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2311);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2346);
 			tensor_less(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2311);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2346);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -8011,9 +8296,9 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2311);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2346);
 				tensor_less(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2311);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2346);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -8086,7 +8371,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2328);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2363);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8101,7 +8386,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2339);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2374);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -8116,9 +8401,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2336);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2371);
 			tensor_less_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2336);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2371);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -8143,9 +8428,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2336);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2371);
 				tensor_less_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2336);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2371);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -8220,7 +8505,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2354);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2389);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8236,7 +8521,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2367);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2402);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8244,7 +8529,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_multiply(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2364);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2399);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8266,7 +8551,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_multiply(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2364);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2399);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8340,7 +8625,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2382);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2417);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8356,7 +8641,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2395);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2430);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8364,7 +8649,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_divide(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2392);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2427);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8386,7 +8671,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_divide(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2392);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2427);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8460,7 +8745,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2410);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2445);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8476,7 +8761,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2423);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2458);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8484,7 +8769,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_add(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2420);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2455);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8506,7 +8791,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_add(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2420);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2455);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8580,7 +8865,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2438);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2473);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8596,7 +8881,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2451);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2486);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8604,7 +8889,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_subtract(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2448);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2483);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8626,7 +8911,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_subtract(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2448);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2483);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8700,7 +8985,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2466);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2501);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8716,7 +9001,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2479);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2514);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8724,7 +9009,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_pow(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2476);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2511);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8746,7 +9031,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_pow(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2476);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2511);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8820,7 +9105,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2494);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2529);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8836,7 +9121,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2507);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2542);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8844,7 +9129,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_mod(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2504);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2539);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8866,7 +9151,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_mod(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2504);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2539);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8941,7 +9226,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2523);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2558);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8957,7 +9242,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2536);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2571);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8965,7 +9250,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2533);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2568);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8987,7 +9272,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2533);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2568);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9061,7 +9346,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2551);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2586);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9077,7 +9362,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2564);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2599);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9085,7 +9370,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_not_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2561);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2596);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9107,7 +9392,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_not_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2561);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2596);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9181,7 +9466,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2579);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2614);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9197,7 +9482,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2592);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2627);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9205,7 +9490,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_greater(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2589);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2624);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9227,7 +9512,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_greater(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2589);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2624);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9301,7 +9586,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2607);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2642);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9317,7 +9602,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2620);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2655);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9325,7 +9610,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_greater_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2617);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2652);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9347,7 +9632,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_greater_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2617);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2652);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9421,7 +9706,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2635);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2670);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9437,7 +9722,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2648);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2683);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9445,7 +9730,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_less(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2645);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2680);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9467,7 +9752,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_less(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2645);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2680);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9542,7 +9827,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2664);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2699);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9558,7 +9843,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2677);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2712);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9566,7 +9851,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_less_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2674);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2709);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9588,7 +9873,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_less_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2674);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2709);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9668,7 +9953,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2692);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2727);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9683,7 +9968,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2703);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2738);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -9698,9 +9983,9 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2700);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2735);
 			tensor_multiply_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2700);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2735);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9725,9 +10010,9 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2700);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2735);
 				tensor_multiply_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2700);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2735);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -9808,7 +10093,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2718);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2753);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9823,7 +10108,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2729);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2764);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -9838,9 +10123,9 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2726);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2761);
 			tensor_divide_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2726);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2761);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9865,9 +10150,9 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2726);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2761);
 				tensor_divide_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2726);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2761);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -9948,7 +10233,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2744);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2779);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9963,7 +10248,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2755);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2790);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -9978,9 +10263,9 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2752);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2787);
 			tensor_add_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2752);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2787);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10005,9 +10290,9 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2752);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2787);
 				tensor_add_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2752);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2787);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10088,7 +10373,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2770);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2805);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10103,7 +10388,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2781);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2816);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10118,9 +10403,9 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2778);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2813);
 			tensor_subtract_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2778);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2813);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10145,9 +10430,9 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2778);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2813);
 				tensor_subtract_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2778);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2813);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10228,7 +10513,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2796);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2831);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10243,7 +10528,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2807);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2842);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10258,9 +10543,9 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2804);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2839);
 			tensor_pow_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2804);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2839);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10285,9 +10570,9 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2804);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2839);
 				tensor_pow_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2804);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2839);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10368,7 +10653,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2822);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2857);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10383,7 +10668,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2833);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2868);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10398,9 +10683,9 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2830);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2865);
 			tensor_mod_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2830);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2865);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10425,9 +10710,9 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2830);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2865);
 				tensor_mod_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2830);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2865);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10508,7 +10793,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2848);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2883);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10523,7 +10808,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2859);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2894);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10538,9 +10823,9 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2856);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2891);
 			tensor_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2856);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2891);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10565,9 +10850,9 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2856);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2891);
 				tensor_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2856);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2891);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10648,7 +10933,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2874);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2909);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10663,7 +10948,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2885);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2920);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10678,9 +10963,9 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2882);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2917);
 			tensor_not_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2882);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2917);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10705,9 +10990,9 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2882);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2917);
 				tensor_not_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2882);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2917);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10788,7 +11073,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2900);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2935);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10803,7 +11088,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2911);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2946);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10818,9 +11103,9 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2908);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2943);
 			tensor_greater_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2908);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2943);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10845,9 +11130,9 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2908);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2943);
 				tensor_greater_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2908);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2943);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10928,7 +11213,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2926);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2961);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10943,7 +11228,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2937);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2972);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10958,9 +11243,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2934);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2969);
 			tensor_greater_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2934);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2969);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10985,9 +11270,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2934);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2969);
 				tensor_greater_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2934);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2969);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11068,7 +11353,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2952);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2987);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11083,7 +11368,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2963);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2998);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11098,9 +11383,9 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2960);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2995);
 			tensor_less_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2960);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2995);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11125,9 +11410,9 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2960);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2995);
 				tensor_less_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2960);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2995);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11208,7 +11493,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2978);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3013);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11223,7 +11508,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2989);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3024);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11238,9 +11523,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2986);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3021);
 			tensor_less_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2986);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3021);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11265,9 +11550,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2986);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3021);
 				tensor_less_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2986);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3021);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11324,7 +11609,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3008);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3043);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11333,7 +11618,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_multiply_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3005);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3040);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11356,7 +11641,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_multiply_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3005);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3040);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11412,7 +11697,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3027);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3062);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11421,7 +11706,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_divide_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3024);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3059);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11444,7 +11729,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_divide_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3024);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3059);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11500,7 +11785,7 @@ PHP_METHOD(Tensor_Matrix, addScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3046);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3081);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11509,7 +11794,7 @@ PHP_METHOD(Tensor_Matrix, addScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_add_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3043);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3078);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11532,7 +11817,7 @@ PHP_METHOD(Tensor_Matrix, addScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_add_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3043);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3078);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11588,7 +11873,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3065);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3100);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11597,7 +11882,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_subtract_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3062);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3097);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11620,7 +11905,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_subtract_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3062);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3097);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11676,7 +11961,7 @@ PHP_METHOD(Tensor_Matrix, powScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3084);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3119);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11685,7 +11970,7 @@ PHP_METHOD(Tensor_Matrix, powScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_pow_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3081);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3116);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11708,7 +11993,7 @@ PHP_METHOD(Tensor_Matrix, powScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_pow_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3081);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3116);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11764,7 +12049,7 @@ PHP_METHOD(Tensor_Matrix, modScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3103);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3138);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11773,7 +12058,7 @@ PHP_METHOD(Tensor_Matrix, modScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_mod_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3100);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3135);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11796,7 +12081,7 @@ PHP_METHOD(Tensor_Matrix, modScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_mod_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3100);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3135);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11852,7 +12137,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3122);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3157);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11861,7 +12146,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3119);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3154);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11884,7 +12169,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3119);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3154);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11940,7 +12225,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3141);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3176);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11949,7 +12234,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_not_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3138);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3173);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11972,7 +12257,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_not_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3138);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3173);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12028,7 +12313,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3160);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3195);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12037,7 +12322,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_greater_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3157);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3192);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12060,7 +12345,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_greater_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3157);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3192);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12117,7 +12402,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3180);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3215);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12126,7 +12411,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_greater_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3177);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3212);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12149,7 +12434,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_greater_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3177);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3212);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12205,7 +12490,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3199);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3234);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12214,7 +12499,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_less_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3196);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3231);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12237,7 +12522,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_less_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3196);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3231);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12294,7 +12579,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3219);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3254);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12303,7 +12588,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_less_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3216);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3251);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12326,7 +12611,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_less_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3216);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3251);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12367,7 +12652,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3237);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3272);
 	return;
 }
 
@@ -12410,7 +12695,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3257);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3292);
 	return;
 }
 
@@ -12460,7 +12745,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", 3276);
+	zephir_throw_exception_debug(&_1, "tensor/matrix.zep", 3311);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -12484,7 +12769,7 @@ PHP_METHOD(Tensor_Matrix, getIterator)
 	object_init_ex(return_value, spl_ce_ArrayIterator);
 	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asVectors", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 20, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index ca10e6f..3621ea3 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -25,6 +25,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector);
 PHP_METHOD(Tensor_Matrix, columnAsVector);
 PHP_METHOD(Tensor_Matrix, diagonalAsVector);
 PHP_METHOD(Tensor_Matrix, asArray);
+PHP_METHOD(Tensor_Matrix, asRowBuffers);
 PHP_METHOD(Tensor_Matrix, asVectors);
 PHP_METHOD(Tensor_Matrix, asColumnVectors);
 PHP_METHOD(Tensor_Matrix, flatten);
@@ -210,7 +211,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_uniform, 0, 2, Tens
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_matrix___construct, 0, 0, 1)
-	ZEND_ARG_ARRAY_INFO(0, a, 0)
+	ZEND_ARG_INFO(0, a)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
 ZEND_END_ARG_INFO()
 
@@ -246,6 +247,9 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asarray, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asrowbuffers, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asvectors, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
@@ -749,6 +753,7 @@ ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, columnAsVector, arginfo_tensor_matrix_columnasvector, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, diagonalAsVector, arginfo_tensor_matrix_diagonalasvector, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asArray, arginfo_tensor_matrix_asarray, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, asRowBuffers, arginfo_tensor_matrix_asrowbuffers, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asVectors, arginfo_tensor_matrix_asvectors, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asColumnVectors, arginfo_tensor_matrix_ascolumnvectors, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, flatten, arginfo_tensor_matrix_flatten, ZEND_ACC_PUBLIC)
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index af701fb..0caa2d2 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -98,7 +98,7 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	zephir_memory_observe(&swaps);
 	zephir_array_fetch_long(&swaps, &ref, 1, PH_NOISY, "tensor/reductions/ref.zep", 52);
 	object_init_ex(return_value, tensor_reductions_ref_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 33, &b, &swaps);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b, &swaps);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index f6f0058..74c2378 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -264,7 +264,7 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 	object_init_ex(return_value, tensor_reductions_rref_ce);
 	ZEPHIR_CALL_CE_STATIC(&_41, tensor_matrix_ce, "quick", NULL, 0, &b);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 34, &_41);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &_41);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 2b1c8c8..3697c39 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -325,7 +325,7 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 	ZVAL_LONG(&_8, length);
 	tensor_buffer_slice(&b, &_6, &_7, &_8);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 35, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -527,7 +527,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 	ZVAL_LONG(&_11, stride);
 	tensor_buffer_slice_strided(&b, &_8, &_9, &_10, &_11);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 35, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -608,7 +608,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
 	tensor_buffer_concat(&b, &_5, &unwrapped);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 35, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -690,7 +690,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			ZVAL_COPY(&buffer, _8);
 			ZEPHIR_INIT_NVAR(&_9$$4);
 			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
-			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 35, &buffer);
+			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 14, &buffer);
 			zephir_check_call_status();
 			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 252);
 		} ZEND_HASH_FOREACH_END();
@@ -714,7 +714,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_13$$5);
 				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
-				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 35, &buffer);
+				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 14, &buffer);
 				zephir_check_call_status();
 				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 252);
 		}
@@ -775,7 +775,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 	ZVAL_LONG(&_5, times);
 	tensor_buffer_repeat(&b, &_4, &_5);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 35, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index da3b454..649a524 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -23,6 +23,7 @@
 #include "kernel/string.h"
 #include "kernel/math.h"
 #include "ext/spl/spl_array.h"
+#include "include/buffer.h"
 #include "include/linear_algebra.h"
 #include "include/signal_processing.h"
 #include "include/arithmetic.h"
@@ -43,9 +44,9 @@ ZEPHIR_INIT_CLASS(Tensor_Vector)
 	ZEPHIR_REGISTER_CLASS(Tensor, Vector, tensor, vector, tensor_vector_method_entry, 0);
 
 	/**
-	 * A 1-d sequential array holding the elements of the vector.
+	 * A 1-d contiguous buffer holding the elements of the vector.
 	 *
-	 * @var list<float>
+	 * @var \Tensor\TensorBuffer
 	 */
 	zend_declare_property_null(tensor_vector_ce, SL("a"), ZEND_ACC_PROTECTED);
 	/**
@@ -128,6 +129,33 @@ PHP_METHOD(Tensor_Vector, quick)
 	RETURN_MM();
 }
 
+/**
+ * Build a vector from a TensorBuffer object.
+ *
+ * @param \Tensor\TensorBuffer a
+ * @return self
+ */
+PHP_METHOD(Tensor_Vector, fromTensorBuffer)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *a, a_sub, _0;
+
+	ZVAL_UNDEF(&a_sub);
+	ZVAL_UNDEF(&_0);
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_OBJECT_OF_CLASS(a, tensor_tensorbuffer_ce)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &a);
+	object_init_ex(return_value, tensor_vector_ce);
+	ZVAL_BOOL(&_0, 0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 1, a, &_0);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
 /**
  * Build a vector of zeros with n elements.
  *
@@ -240,7 +268,7 @@ PHP_METHOD(Tensor_Vector, fill)
 		ZEPHIR_CONCAT_SSVS(&_7$$3, "Value must be an", " integer or floating point number, ", &_5$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 3, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/vector.zep", 92);
+		zephir_throw_exception_debug(&_4$$3, "tensor/vector.zep", 103);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -254,7 +282,7 @@ PHP_METHOD(Tensor_Vector, fill)
 		ZEPHIR_CONCAT_SSVS(&_11$$4, "N must be", " greater than 0, ", &_10$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_8$$4, "__construct", NULL, 3, &_11$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_8$$4, "tensor/vector.zep", 97);
+		zephir_throw_exception_debug(&_8$$4, "tensor/vector.zep", 108);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -307,7 +335,7 @@ PHP_METHOD(Tensor_Vector, rand)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 114);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 125);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -324,7 +352,7 @@ PHP_METHOD(Tensor_Vector, rand)
 		zephir_check_call_status();
 		ZEPHIR_INIT_NVAR(&_7$$4);
 		ZVAL_DOUBLE(&_7$$4, zephir_safe_div_zval_long(&_5$$4, max));
-		zephir_array_append(&a, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 122);
+		zephir_array_append(&a, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 133);
 	}
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -377,7 +405,7 @@ PHP_METHOD(Tensor_Vector, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 140);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 151);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -403,11 +431,11 @@ PHP_METHOD(Tensor_Vector, gaussian)
 		ZVAL_DOUBLE(&_11$$4, phi);
 		ZEPHIR_INIT_NVAR(&_12$$4);
 		ZVAL_DOUBLE(&_12$$4, (r * sin(phi)));
-		zephir_array_append(&a, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 154);
+		zephir_array_append(&a, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 165);
 		ZVAL_DOUBLE(&_13$$4, phi);
 		ZEPHIR_INIT_NVAR(&_12$$4);
 		ZVAL_DOUBLE(&_12$$4, (r * cos(phi)));
-		zephir_array_append(&a, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 155);
+		zephir_array_append(&a, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 166);
 	}
 	if (zephir_fast_count_int(&a) > n) {
 		ZEPHIR_MAKE_REF(&a);
@@ -476,7 +504,7 @@ PHP_METHOD(Tensor_Vector, poisson)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "N 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/vector.zep", 177);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 188);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -490,7 +518,7 @@ PHP_METHOD(Tensor_Vector, poisson)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Lambda must be", " greater than or equal to 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/vector.zep", 182);
+		zephir_throw_exception_debug(&_5$$4, "tensor/vector.zep", 193);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -527,7 +555,7 @@ PHP_METHOD(Tensor_Vector, poisson)
 		}
 		ZEPHIR_INIT_NVAR(&_16$$6);
 		ZVAL_DOUBLE(&_16$$6, (k - 1.0));
-		zephir_array_append(&a, &_16$$6, PH_SEPARATE, "tensor/vector.zep", 207);
+		zephir_array_append(&a, &_16$$6, PH_SEPARATE, "tensor/vector.zep", 218);
 	}
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -575,7 +603,7 @@ PHP_METHOD(Tensor_Vector, uniform)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 224);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 235);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -594,7 +622,7 @@ PHP_METHOD(Tensor_Vector, uniform)
 		zephir_check_call_status();
 		ZEPHIR_INIT_NVAR(&_9$$4);
 		ZVAL_DOUBLE(&_9$$4, zephir_safe_div_zval_long(&_7$$4, max));
-		zephir_array_append(&a, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 232);
+		zephir_array_append(&a, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 243);
 	}
 	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -685,7 +713,7 @@ PHP_METHOD(Tensor_Vector, linspace)
 	min = zephir_get_doubleval(min_param);
 	max = zephir_get_doubleval(max_param);
 	if (UNEXPECTED(min > max)) {
-		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_invalidargumentexception_ce, "Minimum must be less than maximum.", "tensor/vector.zep", 263);
+		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_invalidargumentexception_ce, "Minimum must be less than maximum.", "tensor/vector.zep", 274);
 		return;
 	}
 	if (UNEXPECTED(n < 2)) {
@@ -698,7 +726,7 @@ PHP_METHOD(Tensor_Vector, linspace)
 		ZEPHIR_CONCAT_SSVS(&_3$$4, "Number of elements", " must be greater than 1, ", &_2$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_3$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$4, "tensor/vector.zep", 268);
+		zephir_throw_exception_debug(&_0$$4, "tensor/vector.zep", 279);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -722,11 +750,11 @@ PHP_METHOD(Tensor_Vector, linspace)
 		zephir_check_call_status();
 		ZEPHIR_INIT_NVAR(&_9$$5);
 		ZVAL_DOUBLE(&_9$$5, (zephir_get_numberval(&_7$$5) + interval));
-		zephir_array_append(&a, &_9$$5, PH_SEPARATE, "tensor/vector.zep", 278);
+		zephir_array_append(&a, &_9$$5, PH_SEPARATE, "tensor/vector.zep", 289);
 	}
 	ZEPHIR_INIT_NVAR(&_6);
 	ZVAL_DOUBLE(&_6, max);
-	zephir_array_append(&a, &_6, PH_SEPARATE, "tensor/vector.zep", 281);
+	zephir_array_append(&a, &_6, PH_SEPARATE, "tensor/vector.zep", 292);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -738,23 +766,19 @@ PHP_METHOD(Tensor_Vector, linspace)
  */
 PHP_METHOD(Tensor_Vector, __construct)
 {
+	zval _1$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_3 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zend_bool validate, _5$$3;
-	zval *a_param = NULL, *validate_param = NULL, valueA, _8, *_0$$3, _4$$3, _1$$4, _2$$4, _6$$5, _7$$5;
-	zval a, b$$3;
+	zend_bool validate;
+	zval *a = NULL, a_sub, *validate_param = NULL, buffer, _2, _3, _0$$4;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&b$$3);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&a_sub);
+	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_0$$4);
 	ZVAL_UNDEF(&_1$$4);
-	ZVAL_UNDEF(&_2$$4);
-	ZVAL_UNDEF(&_6$$5);
-	ZVAL_UNDEF(&_7$$5);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -765,75 +789,41 @@ PHP_METHOD(Tensor_Vector, __construct)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 2)
-		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
+		Z_PARAM_ZVAL(a)
 		Z_PARAM_OPTIONAL
 		Z_PARAM_BOOL(validate)
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 1, &a_param, &validate_param);
-	zephir_get_arrval(&a, a_param);
+	zephir_fetch_params(1, 1, 1, &a, &validate_param);
+	ZEPHIR_SEPARATE_PARAM(a);
 	if (!validate_param) {
 		validate = 1;
 	} else {
 		}
-	if (validate) {
-		ZEPHIR_INIT_VAR(&b$$3);
-		array_init(&b$$3);
-		zephir_is_iterable(&a, 0, "tensor/vector.zep", 301);
-		if (Z_TYPE_P(&a) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _0$$3)
-			{
-				ZEPHIR_INIT_NVAR(&valueA);
-				ZVAL_COPY(&valueA, _0$$3);
-				ZEPHIR_INIT_NVAR(&_1$$4);
-				ZEPHIR_CALL_FUNCTION(&_2$$4, "is_float", &_3, 2, &valueA);
-				zephir_check_call_status();
-				if (zephir_is_true(&_2$$4)) {
-					ZEPHIR_CPY_WRT(&_1$$4, &valueA);
-				} else {
-					ZEPHIR_INIT_NVAR(&_1$$4);
-					ZVAL_DOUBLE(&_1$$4, zephir_get_doubleval(&valueA));
-				}
-				zephir_array_append(&b$$3, &_1$$4, PH_SEPARATE, "tensor/vector.zep", 298);
-			} ZEND_HASH_FOREACH_END();
-		} else {
-			ZEPHIR_CALL_METHOD(NULL, &a, "rewind", NULL, 0);
-			zephir_check_call_status();
-			_5$$3 = 1;
-			while (1) {
-				if (_5$$3) {
-					_5$$3 = 0;
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, &a, "next", NULL, 0);
-					zephir_check_call_status();
-				}
-				ZEPHIR_CALL_METHOD(&_4$$3, &a, "valid", NULL, 0);
-				zephir_check_call_status();
-				if (!zend_is_true(&_4$$3)) {
-					break;
-				}
-				ZEPHIR_CALL_METHOD(&valueA, &a, "current", NULL, 0);
-				zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&_6$$5);
-					ZEPHIR_CALL_FUNCTION(&_7$$5, "is_float", &_3, 2, &valueA);
-					zephir_check_call_status();
-					if (zephir_is_true(&_7$$5)) {
-						ZEPHIR_CPY_WRT(&_6$$5, &valueA);
-					} else {
-						ZEPHIR_INIT_NVAR(&_6$$5);
-						ZVAL_DOUBLE(&_6$$5, zephir_get_doubleval(&valueA));
-					}
-					zephir_array_append(&b$$3, &_6$$5, PH_SEPARATE, "tensor/vector.zep", 298);
-			}
-		}
-		ZEPHIR_INIT_NVAR(&valueA);
-		ZEPHIR_CPY_WRT(&a, &b$$3);
+	if (Z_TYPE_P(a) == IS_ARRAY) {
+		ZEPHIR_INIT_VAR(&buffer);
+		tensor_buffer_from_array(&buffer, a);
+		ZEPHIR_INIT_NVAR(a);
+		object_init_ex(a, tensor_tensorbuffer_ce);
+		ZEPHIR_CALL_METHOD(NULL, a, "__construct", NULL, 14, &buffer);
+		zephir_check_call_status();
+	} else if (!(zephir_instance_of_ev(a, tensor_tensorbuffer_ce))) {
+		ZEPHIR_INIT_VAR(&_0$$4);
+		object_init_ex(&_0$$4, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_1$$4);
+		ZEPHIR_CONCAT_SS(&_1$$4, "Vector requires", " an array or TensorBuffer object.");
+		ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_1$$4);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_0$$4, "tensor/vector.zep", 311);
+		ZEPHIR_MM_RESTORE();
+		return;
 	}
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, &a);
-	ZVAL_UNDEF(&_8);
-	ZVAL_LONG(&_8, zephir_fast_count_int(&a));
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_8);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, a);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_3, &_2, "count", NULL, 0);
+	zephir_check_call_status();
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_3);
 	ZEPHIR_MM_RESTORE();
 }
 
@@ -930,8 +920,23 @@ PHP_METHOD(Tensor_Vector, n)
  */
 PHP_METHOD(Tensor_Vector, asArray)
 {
+	zval _0;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	RETURN_MEMBER_TYPED(getThis(), "a", IS_ARRAY);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	RETURN_MM();
 }
 
 /**
@@ -975,12 +980,13 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 {
 	zend_bool _6;
 	zval b, _4$$3, _7$$4;
-	zval valueA, _0, *_1, _2, *_3, _5;
+	zval valueA, aHat, _0, *_1, _2, *_3, _5;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_5);
@@ -994,17 +1000,19 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&aHat, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
+	if (Z_TYPE_P(&aHat) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
+		zephir_string_to_char_array(&_2, &aHat);
 		_1 = &_2;
 	} else {
-		_1 = &_0;
+		_1 = &aHat;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 393);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 405);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -1013,7 +1021,7 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			zephir_create_array(&_4$$3, 1, 0);
 			zephir_array_fast_append(&_4$$3, &valueA);
-			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/vector.zep", 390);
+			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/vector.zep", 402);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -1036,7 +1044,7 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 				ZEPHIR_INIT_NVAR(&_7$$4);
 				zephir_create_array(&_7$$4, 1, 0);
 				zephir_array_fast_append(&_7$$4, &valueA);
-				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 390);
+				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 402);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -1059,7 +1067,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 	zval b, rowB;
 	zend_bool _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *m_param = NULL, *n_param = NULL, _3, _1$$3, _4$$4, _5$$4, _6$$4, _7$$4, _8$$6, _9$$6;
+	zval *m_param = NULL, *n_param = NULL, _3, _1$$3, _4$$4, _5$$4, _6$$4, _7$$4, _8$$6, _9$$6, _10$$6;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS, nHat, i;
 	zval *this_ptr = getThis();
 
@@ -1071,6 +1079,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 	ZVAL_UNDEF(&_7$$4);
 	ZVAL_UNDEF(&_8$$6);
 	ZVAL_UNDEF(&_9$$6);
+	ZVAL_UNDEF(&_10$$6);
 	ZVAL_UNDEF(&b);
 	ZVAL_UNDEF(&rowB);
 	ZVAL_UNDEF(&_2$$3);
@@ -1101,7 +1110,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_SS(&_2$$3, "The number of rows", " and/or columns cannot be less than 0.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 408);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 420);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1118,7 +1127,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_VSSVS(&_7$$4, &_6$$4, " elements", " are needed but vector only has ", &_5$$4, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 415);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 427);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1138,12 +1147,13 @@ PHP_METHOD(Tensor_Vector, reshape)
 				break;
 			}
 			zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_9$$6);
-			zephir_array_fetch_long(&_9$$6, &_8$$6, i, PH_NOISY, "tensor/vector.zep", 427);
-			zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/vector.zep", 427);
+			ZVAL_LONG(&_10$$6, i);
+			ZEPHIR_CALL_METHOD(&_9$$6, &_8$$6, "get", NULL, 0, &_10$$6);
+			zephir_check_call_status();
+			zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/vector.zep", 439);
 			i++;
 		}
-		zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/vector.zep", 432);
+		zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/vector.zep", 444);
 	}
 	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &b);
 	zephir_check_call_status();
@@ -1171,7 +1181,7 @@ PHP_METHOD(Tensor_Vector, transpose)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1188,12 +1198,13 @@ PHP_METHOD(Tensor_Vector, map)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *callback, callback_sub, _0, _1;
+	zval *callback, callback_sub, _0, _1, _2;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&callback_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -1206,9 +1217,11 @@ PHP_METHOD(Tensor_Vector, map)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &callback);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_FUNCTION(&_1, "array_map", NULL, 14, callback, &_0);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, callback, &_1);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1227,12 +1240,13 @@ PHP_METHOD(Tensor_Vector, reduce)
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	double initial;
-	zval *callback, callback_sub, *initial_param = NULL, _0, _1;
+	zval *callback, callback_sub, *initial_param = NULL, _0, _1, _2;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&callback_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -1252,8 +1266,10 @@ PHP_METHOD(Tensor_Vector, reduce)
 		initial = zephir_get_doubleval(initial_param);
 	}
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZVAL_DOUBLE(&_1, initial);
-	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 15, &_0, callback, &_1);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	ZVAL_DOUBLE(&_2, initial);
+	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 16, &_1, callback, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1315,13 +1331,12 @@ PHP_METHOD(Tensor_Vector, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " elements 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/vector.zep", 487);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 499);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_9, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_9, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_dot(return_value, &_8, &_9);
 	RETURN_MM();
 }
@@ -1386,7 +1401,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Vector B cannot be", " larger than Vector A.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 505);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 517);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1400,17 +1415,16 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Stride cannot be", " less than 1, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 510);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 522);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_11, stride);
 	tensor_convolve_1d(&_8, &_9, &_10, &_11);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1479,18 +1493,19 @@ PHP_METHOD(Tensor_Vector, outer)
 	zend_string *_8$$3, *_14$$5;
 	zend_ulong _7$$3, _13$$5;
 	zend_bool _11;
-	zval bHat, c, rowC, _1;
+	zval bHat, c, rowC, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, j, valueA, valueB, _0, _2, *_3, _4, *_5, _10, *_6$$3, _9$$4, *_12$$5, _15$$6;
+	zval *b, b_sub, j, valueA, valueB, aHat, _0, _1, *_3, _4, *_5, _10, *_6$$3, _9$$4, *_12$$5, _15$$6;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&j);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_9$$4);
@@ -1498,7 +1513,7 @@ PHP_METHOD(Tensor_Vector, outer)
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&rowC);
-	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -1510,25 +1525,27 @@ PHP_METHOD(Tensor_Vector, outer)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&aHat, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&bHat);
 	array_init(&bHat);
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
 	ZEPHIR_INIT_VAR(&rowC);
 	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_0, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_1, b, "asArray", NULL, 0);
 	zephir_check_call_status();
-	zephir_get_arrval(&_1, &_0);
-	ZEPHIR_CPY_WRT(&bHat, &_1);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_2) == IS_STRING) {
+	zephir_get_arrval(&_2, &_1);
+	ZEPHIR_CPY_WRT(&bHat, &_2);
+	if (Z_TYPE_P(&aHat) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_2);
+		zephir_string_to_char_array(&_4, &aHat);
 		_3 = &_4;
 	} else {
-		_3 = &_2;
+		_3 = &aHat;
 	}
-	zephir_is_iterable(_3, 0, "tensor/vector.zep", 564);
+	zephir_is_iterable(_3, 0, "tensor/vector.zep", 578);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -1536,7 +1553,7 @@ PHP_METHOD(Tensor_Vector, outer)
 			ZVAL_COPY(&valueA, _5);
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
-			zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 561);
+			zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 575);
 			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _7$$3, _8$$3, _6$$3)
 			{
 				ZEPHIR_INIT_NVAR(&j);
@@ -1549,11 +1566,11 @@ PHP_METHOD(Tensor_Vector, outer)
 				ZVAL_COPY(&valueB, _6$$3);
 				ZEPHIR_INIT_NVAR(&_9$$4);
 				mul_function(&_9$$4, &valueA, &valueB);
-				zephir_array_append(&rowC, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 558);
+				zephir_array_append(&rowC, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 572);
 			} ZEND_HASH_FOREACH_END();
 			ZEPHIR_INIT_NVAR(&valueB);
 			ZEPHIR_INIT_NVAR(&j);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 561);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 575);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -1575,7 +1592,7 @@ PHP_METHOD(Tensor_Vector, outer)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
-				zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 561);
+				zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 575);
 				ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$5, _14$$5, _12$$5)
 				{
 					ZEPHIR_INIT_NVAR(&j);
@@ -1588,11 +1605,11 @@ PHP_METHOD(Tensor_Vector, outer)
 					ZVAL_COPY(&valueB, _12$$5);
 					ZEPHIR_INIT_NVAR(&_15$$6);
 					mul_function(&_15$$6, &valueA, &valueB);
-					zephir_array_append(&rowC, &_15$$6, PH_SEPARATE, "tensor/vector.zep", 558);
+					zephir_array_append(&rowC, &_15$$6, PH_SEPARATE, "tensor/vector.zep", 572);
 				} ZEND_HASH_FOREACH_END();
 				ZEPHIR_INIT_NVAR(&valueB);
 				ZEPHIR_INIT_NVAR(&j);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 561);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 575);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -1693,7 +1710,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "P must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 598);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 612);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1705,7 +1722,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 	ZEPHIR_CALL_METHOD(&_7, &_5, "sum", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_6, zephir_safe_div_double_double(1.0, p));
-	ZEPHIR_RETURN_CALL_FUNCTION("pow", NULL, 16, &_7, &_6);
+	ZEPHIR_RETURN_CALL_FUNCTION("pow", NULL, 17, &_7, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1795,7 +1812,7 @@ PHP_METHOD(Tensor_Vector, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 641);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 655);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1861,7 +1878,7 @@ PHP_METHOD(Tensor_Vector, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 671);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 685);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1928,7 +1945,7 @@ PHP_METHOD(Tensor_Vector, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 702);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 716);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1995,7 +2012,7 @@ PHP_METHOD(Tensor_Vector, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " vector from the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 733);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 747);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2062,7 +2079,7 @@ PHP_METHOD(Tensor_Vector, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " vector to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 764);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 778);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2129,7 +2146,7 @@ PHP_METHOD(Tensor_Vector, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " vector with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 795);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 809);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2196,7 +2213,7 @@ PHP_METHOD(Tensor_Vector, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 826);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 840);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2263,7 +2280,7 @@ PHP_METHOD(Tensor_Vector, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 857);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 871);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2330,7 +2347,7 @@ PHP_METHOD(Tensor_Vector, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 888);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 902);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2397,7 +2414,7 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 919);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 933);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2464,7 +2481,7 @@ PHP_METHOD(Tensor_Vector, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 950);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 964);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2531,7 +2548,7 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 981);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 995);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2688,12 +2705,13 @@ PHP_METHOD(Tensor_Vector, log)
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_7 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *base_param = NULL, _0$$3, valueA, _1, *_2, _3, *_4, _8, _5$$4, _6$$4, _10$$5, _11$$5;
+	zval *base_param = NULL, _0$$3, valueA, a, _1, *_2, _3, *_4, _8, _5$$4, _6$$4, _10$$5, _11$$5;
 	double base;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_8);
@@ -2726,17 +2744,19 @@ PHP_METHOD(Tensor_Vector, log)
 		zephir_check_call_status();
 		RETURN_MM();
 	}
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&a, &_1, "toArray", NULL, 0);
+	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_1) == IS_STRING) {
+	if (Z_TYPE_P(&a) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_3);
-		zephir_string_to_char_array(&_3, &_1);
+		zephir_string_to_char_array(&_3, &a);
 		_2 = &_3;
 	} else {
-		_2 = &_1;
+		_2 = &a;
 	}
-	zephir_is_iterable(_2, 0, "tensor/vector.zep", 1065);
+	zephir_is_iterable(_2, 0, "tensor/vector.zep", 1081);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -2745,7 +2765,7 @@ PHP_METHOD(Tensor_Vector, log)
 			ZVAL_DOUBLE(&_5$$4, base);
 			ZEPHIR_CALL_FUNCTION(&_6$$4, "log", &_7, 8, &valueA, &_5$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/vector.zep", 1062);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/vector.zep", 1078);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -2768,7 +2788,7 @@ PHP_METHOD(Tensor_Vector, log)
 				ZVAL_DOUBLE(&_10$$5, base);
 				ZEPHIR_CALL_FUNCTION(&_11$$5, "log", &_7, 8, &valueA, &_10$$5);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/vector.zep", 1062);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/vector.zep", 1078);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -2991,13 +3011,12 @@ PHP_METHOD(Tensor_Vector, deg2rad)
  */
 PHP_METHOD(Tensor_Vector, sum)
 {
-	zval _0, _1;
+	zval _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3006,9 +3025,9 @@ PHP_METHOD(Tensor_Vector, sum)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_FUNCTION(&_1, "array_sum", NULL, 17, &_0);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "sum", NULL, 0);
 	zephir_check_call_status();
-	RETURN_MM_DOUBLE(zephir_get_doubleval(&_1));
+	RETURN_MM();
 }
 
 /**
@@ -3018,13 +3037,12 @@ PHP_METHOD(Tensor_Vector, sum)
  */
 PHP_METHOD(Tensor_Vector, product)
 {
-	zval _0, _1;
+	zval _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3033,9 +3051,9 @@ PHP_METHOD(Tensor_Vector, product)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_FUNCTION(&_1, "array_product", NULL, 18, &_0);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "product", NULL, 0);
 	zephir_check_call_status();
-	RETURN_MM_DOUBLE(zephir_get_doubleval(&_1));
+	RETURN_MM();
 }
 
 /**
@@ -3045,13 +3063,12 @@ PHP_METHOD(Tensor_Vector, product)
  */
 PHP_METHOD(Tensor_Vector, min)
 {
-	zval _0, _1;
+	zval _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3060,9 +3077,9 @@ PHP_METHOD(Tensor_Vector, min)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_FUNCTION(&_1, "min", NULL, 19, &_0);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "min", NULL, 0);
 	zephir_check_call_status();
-	RETURN_MM_DOUBLE(zephir_get_doubleval(&_1));
+	RETURN_MM();
 }
 
 /**
@@ -3072,13 +3089,12 @@ PHP_METHOD(Tensor_Vector, min)
  */
 PHP_METHOD(Tensor_Vector, max)
 {
-	zval _0, _1;
+	zval _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3087,9 +3103,9 @@ PHP_METHOD(Tensor_Vector, max)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_FUNCTION(&_1, "max", NULL, 20, &_0);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "max", NULL, 0);
 	zephir_check_call_status();
-	RETURN_MM_DOUBLE(zephir_get_doubleval(&_1));
+	RETURN_MM();
 }
 
 /**
@@ -3127,7 +3143,7 @@ PHP_METHOD(Tensor_Vector, mean)
  */
 PHP_METHOD(Tensor_Vector, median)
 {
-	zval median, _0, _1, _2, a, _3$$4, _4$$4, _5$$4;
+	zval median, _0, _1, _2, a, _3, _4$$4, _5$$4, _6$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, mid;
 	zval *this_ptr = getThis();
@@ -3137,9 +3153,10 @@ PHP_METHOD(Tensor_Vector, median)
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&_3$$4);
+	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4$$4);
 	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_6$$4);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -3153,28 +3170,29 @@ PHP_METHOD(Tensor_Vector, median)
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_1, 2);
-	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 21, &_0, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 18, &_0, &_1);
 	zephir_check_call_status();
 	mid = zephir_get_intval(&_2);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CPY_WRT(&a, &_1);
+	ZEPHIR_CALL_METHOD(&a, &_1, "toArray", NULL, 0);
+	zephir_check_call_status();
 	ZEPHIR_MAKE_REF(&a);
-	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 22, &a);
+	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 19, &a);
 	ZEPHIR_UNREF(&a);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	if (zephir_safe_mod_zval_long(&_1, 2) == 1) {
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
 		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1224);
+		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1240);
 	} else {
-		zephir_memory_observe(&_3$$4);
-		zephir_array_fetch_long(&_3$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1226);
 		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1226);
-		ZEPHIR_INIT_VAR(&_5$$4);
-		zephir_add_function(&_5$$4, &_3$$4, &_4$$4);
+		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1242);
+		zephir_memory_observe(&_5$$4);
+		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1242);
+		ZEPHIR_INIT_VAR(&_6$$4);
+		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
 		ZEPHIR_INIT_NVAR(&median);
-		ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_5$$4, 2.0));
+		ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_6$$4, 2.0));
 	}
 	RETURN_CCTOR(&median);
 }
@@ -3191,21 +3209,22 @@ PHP_METHOD(Tensor_Vector, quantile)
 	zend_bool _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, xHat;
-	zval *q_param = NULL, a, _5, _6, _9, _10, _1$$3, _2$$3, _3$$3, _4$$3, _7$$4, _8$$4;
+	zval *q_param = NULL, a, _5, _6, _7, _10, _11, _1$$3, _2$$3, _3$$3, _4$$3, _8$$4, _9$$4;
 	double q, x, remainder, t;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_5);
 	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_7$$4);
 	ZVAL_UNDEF(&_8$$4);
+	ZVAL_UNDEF(&_9$$4);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -3236,33 +3255,34 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1243);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1259);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CPY_WRT(&a, &_5);
+	ZEPHIR_CALL_METHOD(&a, &_5, "toArray", NULL, 0);
+	zephir_check_call_status();
 	ZEPHIR_MAKE_REF(&a);
-	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 22, &a);
+	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 19, &a);
 	ZEPHIR_UNREF(&a);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-	x =  (((q * (double) ((zephir_get_numberval(&_5) - 1))) + (double) (1)));
-	xHat = (int) x;
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-	if (ZEPHIR_LE_LONG(&_6, xHat)) {
-		zephir_memory_observe(&_7$$4);
-		zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_7$$4, &a, (zephir_get_numberval(&_8$$4) - 1), PH_NOISY, "tensor/vector.zep", 1255);
-		RETURN_MM_DOUBLE(zephir_get_doubleval(&_7$$4));
+	x =  (((q * (double) ((zephir_get_numberval(&_6) - 1))) + (double) (1)));
+	xHat = (int) x;
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
+	if (ZEPHIR_LE_LONG(&_7, xHat)) {
+		zephir_memory_observe(&_8$$4);
+		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
+		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1271);
+		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
 	}
 	remainder =  ((x -  (double) xHat));
-	zephir_memory_observe(&_9);
-	zephir_array_fetch_long(&_9, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1260);
-	t =  (zephir_get_doubleval(&_9));
 	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, xHat, PH_NOISY, "tensor/vector.zep", 1262);
-	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_10) - t))));
+	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1276);
+	t =  (zephir_get_doubleval(&_10));
+	zephir_memory_observe(&_11);
+	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1278);
+	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
 }
 
 /**
@@ -3320,7 +3340,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1277);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1293);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3351,7 +3371,7 @@ PHP_METHOD(Tensor_Vector, round)
 	zend_bool _12;
 	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *precision_param = NULL, _0$$3, _1$$4, _2$$4, _3$$4, _4$$4, valueA, _5, *_6, _7, *_8, _11, _9$$5, _10$$5, _13$$6, _14$$6;
+	zval *precision_param = NULL, _0$$3, _1$$4, _2$$4, _3$$4, _4$$4, valueA, a, _5, *_6, _7, *_8, _11, _9$$5, _10$$5, _13$$6, _14$$6;
 	zend_long precision, ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
@@ -3361,6 +3381,7 @@ PHP_METHOD(Tensor_Vector, round)
 	ZVAL_UNDEF(&_3$$4);
 	ZVAL_UNDEF(&_4$$4);
 	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_5);
 	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_11);
@@ -3402,21 +3423,23 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_CONCAT_SSVS(&_4$$4, "Decimal precision cannot", " be less than 0, ", &_3$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_4$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1305);
+		zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1321);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_5) == IS_STRING) {
+	ZEPHIR_CALL_METHOD(&a, &_5, "toArray", NULL, 0);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&a) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_7);
-		zephir_string_to_char_array(&_7, &_5);
+		zephir_string_to_char_array(&_7, &a);
 		_6 = &_7;
 	} else {
-		_6 = &_5;
+		_6 = &a;
 	}
-	zephir_is_iterable(_6, 0, "tensor/vector.zep", 1316);
+	zephir_is_iterable(_6, 0, "tensor/vector.zep", 1334);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -3425,7 +3448,7 @@ PHP_METHOD(Tensor_Vector, round)
 			ZEPHIR_INIT_NVAR(&_9$$5);
 			ZVAL_LONG(&_10$$5, precision);
 			zephir_round(&_9$$5, &valueA, &_10$$5, NULL);
-			zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/vector.zep", 1313);
+			zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/vector.zep", 1331);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -3448,7 +3471,7 @@ PHP_METHOD(Tensor_Vector, round)
 				ZEPHIR_INIT_NVAR(&_13$$6);
 				ZVAL_LONG(&_14$$6, precision);
 				zephir_round(&_13$$6, &valueA, &_14$$6, NULL);
-				zephir_array_append(&b, &_13$$6, PH_SEPARATE, "tensor/vector.zep", 1313);
+				zephir_array_append(&b, &_13$$6, PH_SEPARATE, "tensor/vector.zep", 1331);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -3519,12 +3542,13 @@ PHP_METHOD(Tensor_Vector, clip)
 	zval _1$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *min_param = NULL, *max_param = NULL, _0$$3, valueA, _2, *_3, _4, *_5, _8, _6$$5, _7$$6, _10$$8, _11$$9;
+	zval *min_param = NULL, *max_param = NULL, _0$$3, valueA, a, _2, *_3, _4, *_5, _8, _6$$5, _7$$6, _10$$8, _11$$9;
 	double min, max;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_8);
@@ -3555,21 +3579,23 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1352);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1370);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_2) == IS_STRING) {
+	ZEPHIR_CALL_METHOD(&a, &_2, "toArray", NULL, 0);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&a) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_2);
+		zephir_string_to_char_array(&_4, &a);
 		_3 = &_4;
 	} else {
-		_3 = &_2;
+		_3 = &a;
 	}
-	zephir_is_iterable(_3, 0, "tensor/vector.zep", 1375);
+	zephir_is_iterable(_3, 0, "tensor/vector.zep", 1395);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -3578,16 +3604,16 @@ PHP_METHOD(Tensor_Vector, clip)
 			if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 				ZEPHIR_INIT_NVAR(&_6$$5);
 				ZVAL_DOUBLE(&_6$$5, max);
-				zephir_array_append(&b, &_6$$5, PH_SEPARATE, "tensor/vector.zep", 1361);
+				zephir_array_append(&b, &_6$$5, PH_SEPARATE, "tensor/vector.zep", 1381);
 				continue;
 			}
 			if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 				ZEPHIR_INIT_NVAR(&_7$$6);
 				ZVAL_DOUBLE(&_7$$6, min);
-				zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1367);
+				zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1387);
 				continue;
 			}
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1372);
+			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1392);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -3610,16 +3636,16 @@ PHP_METHOD(Tensor_Vector, clip)
 				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 					ZEPHIR_INIT_NVAR(&_10$$8);
 					ZVAL_DOUBLE(&_10$$8, max);
-					zephir_array_append(&b, &_10$$8, PH_SEPARATE, "tensor/vector.zep", 1361);
+					zephir_array_append(&b, &_10$$8, PH_SEPARATE, "tensor/vector.zep", 1381);
 					continue;
 				}
 				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 					ZEPHIR_INIT_NVAR(&_11$$9);
 					ZVAL_DOUBLE(&_11$$9, min);
-					zephir_array_append(&b, &_11$$9, PH_SEPARATE, "tensor/vector.zep", 1367);
+					zephir_array_append(&b, &_11$$9, PH_SEPARATE, "tensor/vector.zep", 1387);
 					continue;
 				}
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1372);
+				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1392);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -3640,11 +3666,12 @@ PHP_METHOD(Tensor_Vector, clipLower)
 	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *min_param = NULL, valueA, _0, *_1, _2, *_3, _5, _4$$4, _7$$6;
+	zval *min_param = NULL, valueA, a, _0, *_1, _2, *_3, _5, _4$$4, _7$$6;
 	double min;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_5);
@@ -3666,14 +3693,16 @@ PHP_METHOD(Tensor_Vector, clipLower)
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
+	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&a) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
+		zephir_string_to_char_array(&_2, &a);
 		_1 = &_2;
 	} else {
-		_1 = &_0;
+		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1400);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1422);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -3682,10 +3711,10 @@ PHP_METHOD(Tensor_Vector, clipLower)
 			if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 				ZEPHIR_INIT_NVAR(&_4$$4);
 				ZVAL_DOUBLE(&_4$$4, min);
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1392);
+				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1414);
 				continue;
 			}
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1397);
+			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1419);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -3708,10 +3737,10 @@ PHP_METHOD(Tensor_Vector, clipLower)
 				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 					ZEPHIR_INIT_NVAR(&_7$$6);
 					ZVAL_DOUBLE(&_7$$6, min);
-					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1392);
+					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1414);
 					continue;
 				}
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1397);
+				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1419);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -3732,11 +3761,12 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *max_param = NULL, valueA, _0, *_1, _2, *_3, _5, _4$$4, _7$$6;
+	zval *max_param = NULL, valueA, a, _0, *_1, _2, *_3, _5, _4$$4, _7$$6;
 	double max;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_5);
@@ -3758,14 +3788,16 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
+	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&a) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
+		zephir_string_to_char_array(&_2, &a);
 		_1 = &_2;
 	} else {
-		_1 = &_0;
+		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1425);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1449);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -3774,10 +3806,10 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 			if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 				ZEPHIR_INIT_NVAR(&_4$$4);
 				ZVAL_DOUBLE(&_4$$4, max);
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1417);
+				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1441);
 				continue;
 			}
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1422);
+			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1446);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -3800,10 +3832,10 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 					ZEPHIR_INIT_NVAR(&_7$$6);
 					ZVAL_DOUBLE(&_7$$6, max);
-					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1417);
+					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1441);
 					continue;
 				}
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1422);
+				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1446);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -3821,12 +3853,13 @@ PHP_METHOD(Tensor_Vector, sign)
 {
 	zend_bool _8;
 	zval b;
-	zval valueA, _0, *_1, _2, *_3, _7, _4$$4, _5$$5, _6$$6, _9$$8, _10$$9, _11$$10;
+	zval valueA, a, _0, *_1, _2, *_3, _7, _4$$4, _5$$5, _6$$6, _9$$8, _10$$9, _11$$10;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_7);
@@ -3847,14 +3880,16 @@ PHP_METHOD(Tensor_Vector, sign)
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
+	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&a) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
+		zephir_string_to_char_array(&_2, &a);
 		_1 = &_2;
 	} else {
-		_1 = &_0;
+		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1449);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1475);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -3863,15 +3898,15 @@ PHP_METHOD(Tensor_Vector, sign)
 			if (ZEPHIR_GT_LONG(&valueA, 0)) {
 				ZEPHIR_INIT_NVAR(&_4$$4);
 				ZVAL_DOUBLE(&_4$$4, 1.0);
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1441);
+				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1467);
 			} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 				ZEPHIR_INIT_NVAR(&_5$$5);
 				ZVAL_DOUBLE(&_5$$5, -1.0);
-				zephir_array_append(&b, &_5$$5, PH_SEPARATE, "tensor/vector.zep", 1443);
+				zephir_array_append(&b, &_5$$5, PH_SEPARATE, "tensor/vector.zep", 1469);
 			} else {
 				ZEPHIR_INIT_NVAR(&_6$$6);
 				ZVAL_DOUBLE(&_6$$6, 0.0);
-				zephir_array_append(&b, &_6$$6, PH_SEPARATE, "tensor/vector.zep", 1445);
+				zephir_array_append(&b, &_6$$6, PH_SEPARATE, "tensor/vector.zep", 1471);
 			}
 		} ZEND_HASH_FOREACH_END();
 	} else {
@@ -3895,15 +3930,15 @@ PHP_METHOD(Tensor_Vector, sign)
 				if (ZEPHIR_GT_LONG(&valueA, 0)) {
 					ZEPHIR_INIT_NVAR(&_9$$8);
 					ZVAL_DOUBLE(&_9$$8, 1.0);
-					zephir_array_append(&b, &_9$$8, PH_SEPARATE, "tensor/vector.zep", 1441);
+					zephir_array_append(&b, &_9$$8, PH_SEPARATE, "tensor/vector.zep", 1467);
 				} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 					ZEPHIR_INIT_NVAR(&_10$$9);
 					ZVAL_DOUBLE(&_10$$9, -1.0);
-					zephir_array_append(&b, &_10$$9, PH_SEPARATE, "tensor/vector.zep", 1443);
+					zephir_array_append(&b, &_10$$9, PH_SEPARATE, "tensor/vector.zep", 1469);
 				} else {
 					ZEPHIR_INIT_NVAR(&_11$$10);
 					ZVAL_DOUBLE(&_11$$10, 0.0);
-					zephir_array_append(&b, &_11$$10, PH_SEPARATE, "tensor/vector.zep", 1445);
+					zephir_array_append(&b, &_11$$10, PH_SEPARATE, "tensor/vector.zep", 1471);
 				}
 		}
 	}
@@ -3922,12 +3957,13 @@ PHP_METHOD(Tensor_Vector, negate)
 {
 	zend_bool _5;
 	zval b;
-	zval valueA, _0, *_1, _2, *_3, _4;
+	zval valueA, a, _0, *_1, _2, *_3, _4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_4);
@@ -3942,21 +3978,23 @@ PHP_METHOD(Tensor_Vector, negate)
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
+	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&a) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
+		zephir_string_to_char_array(&_2, &a);
 		_1 = &_2;
 	} else {
-		_1 = &_0;
+		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1467);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1495);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
 			ZEPHIR_INIT_NVAR(&valueA);
 			ZVAL_COPY(&valueA, _3);
 			zephir_negate(&valueA);
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1464);
+			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1492);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -3977,7 +4015,7 @@ PHP_METHOD(Tensor_Vector, negate)
 			ZEPHIR_CALL_METHOD(&valueA, _1, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_negate(&valueA);
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1464);
+				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1492);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -4052,13 +4090,13 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1482);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1510);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4067,7 +4105,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1493);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1521);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4076,7 +4114,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1490);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1518);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4099,7 +4137,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1490);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1518);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4174,13 +4212,13 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1508);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1536);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4189,7 +4227,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1519);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1547);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4198,7 +4236,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1516);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1544);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4221,7 +4259,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1516);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1544);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4296,13 +4334,13 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1534);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1562);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4311,7 +4349,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1545);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1573);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4320,7 +4358,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1542);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1570);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4343,7 +4381,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1542);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1570);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4418,13 +4456,13 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1560);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1588);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4433,7 +4471,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1571);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1599);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4442,7 +4480,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1568);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1596);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4465,7 +4503,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1568);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1596);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4540,13 +4578,13 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1586);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1614);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4555,7 +4593,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1597);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1625);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4564,7 +4602,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1594);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1622);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4587,7 +4625,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1594);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1622);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4662,13 +4700,13 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1612);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1640);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4677,7 +4715,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1623);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1651);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4686,7 +4724,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1620);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1648);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4709,7 +4747,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1620);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1648);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4784,13 +4822,13 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1638);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1666);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4799,7 +4837,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1649);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1677);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4808,7 +4846,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1646);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1674);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4831,7 +4869,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1646);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1674);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4906,13 +4944,13 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1664);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1692);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -4921,7 +4959,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1675);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1703);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4930,7 +4968,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1672);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1700);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4953,7 +4991,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1672);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1700);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5028,13 +5066,13 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1690);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1718);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5043,7 +5081,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1701);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1729);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5052,7 +5090,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1698);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1726);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5075,7 +5113,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1698);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1726);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5150,13 +5188,13 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1716);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1744);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5165,7 +5203,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1727);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1755);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5174,7 +5212,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1724);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1752);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5197,7 +5235,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1724);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1752);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5272,13 +5310,13 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1742);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1770);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5287,7 +5325,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1753);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1781);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5296,7 +5334,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1750);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1778);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5319,7 +5357,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1750);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1778);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5394,13 +5432,13 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1768);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1796);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (Z_TYPE_P(&_8) == IS_STRING) {
 		ZEPHIR_INIT_VAR(&_10);
@@ -5409,7 +5447,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1779);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1807);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5418,7 +5456,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1776);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1804);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5441,7 +5479,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1776);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1804);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5508,16 +5546,15 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1794);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1822);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_multiply(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5580,16 +5617,15 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1812);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1840);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_divide(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5652,16 +5688,15 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1830);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1858);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_add(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5724,16 +5759,15 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1848);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1876);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_subtract(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5796,16 +5830,15 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1866);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1894);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_pow(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5868,16 +5901,15 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1884);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1912);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_mod(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5941,16 +5973,15 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1903);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1931);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_equal(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6013,16 +6044,15 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1921);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1949);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_not_equal(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6085,16 +6115,15 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1939);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1967);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6157,16 +6186,15 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1957);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1985);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater_equal(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6229,16 +6257,15 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1975);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 2003);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6301,16 +6328,15 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1993);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 2021);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
+	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less_equal(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6348,7 +6374,7 @@ PHP_METHOD(Tensor_Vector, multiplyScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_multiply_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6386,7 +6412,7 @@ PHP_METHOD(Tensor_Vector, divideScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_divide_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6424,7 +6450,7 @@ PHP_METHOD(Tensor_Vector, addScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_add_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6462,7 +6488,7 @@ PHP_METHOD(Tensor_Vector, subtractScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_subtract_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6500,7 +6526,7 @@ PHP_METHOD(Tensor_Vector, powScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_pow_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6538,7 +6564,7 @@ PHP_METHOD(Tensor_Vector, modScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_mod_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6576,7 +6602,7 @@ PHP_METHOD(Tensor_Vector, equalScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6614,7 +6640,7 @@ PHP_METHOD(Tensor_Vector, notEqualScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_not_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6652,7 +6678,7 @@ PHP_METHOD(Tensor_Vector, greaterScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_greater_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6691,7 +6717,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_greater_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6729,7 +6755,7 @@ PHP_METHOD(Tensor_Vector, lessScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_less_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6768,7 +6794,7 @@ PHP_METHOD(Tensor_Vector, lessEqualScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_less_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_0);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6800,7 +6826,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2150);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2178);
 	return;
 }
 
@@ -6812,22 +6838,30 @@ PHP_METHOD(Tensor_Vector, offsetSet)
  */
 PHP_METHOD(Tensor_Vector, offsetExists)
 {
-	zval *index, index_sub, _0;
+	zend_bool _0;
+	zval *index, index_sub, _1;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&index_sub);
-	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	RETURN_BOOL(zephir_array_isset_value(&_0, index));
+	if (UNEXPECTED(!(Z_TYPE_P(index) == IS_LONG))) {
+		RETURN_BOOL(0);
+	}
+	_0 = ZEPHIR_GE_LONG(index, 0);
+	if (_0) {
+		zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+		_0 = ZEPHIR_LT(index, &_1);
+	}
+	RETURN_BOOL(_0);
 }
 
 /**
@@ -6843,7 +6877,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2170);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2202);
 	return;
 }
 
@@ -6856,21 +6890,26 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
  */
 PHP_METHOD(Tensor_Vector, offsetGet)
 {
-	zval _2, _3;
+	zval _4$$3, _5$$3;
+	zend_bool _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *index, index_sub, value, _0, _1;
+	zval *index, index_sub, _2, _6, _3$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&index_sub);
-	ZVAL_UNDEF(&value);
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_5$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -6879,21 +6918,31 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &index);
-	zephir_memory_observe(&value);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	if (EXPECTED(zephir_array_isset_fetch(&value, &_0, index, 0))) {
-		RETURN_CCTOR(&value);
+	_0 = !(Z_TYPE_P(index) == IS_LONG);
+	if (!(_0)) {
+		_1 = ZEPHIR_LT_LONG(index, 0);
+		if (!(_1)) {
+			zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+			_1 = ZEPHIR_GE(index, &_2);
+		}
+		_0 = _1;
 	}
-	ZEPHIR_INIT_VAR(&_1);
-	object_init_ex(&_1, tensor_exceptions_invalidargumentexception_ce);
-	zephir_cast_to_string(&_2, index);
-	ZEPHIR_INIT_VAR(&_3);
-	ZEPHIR_CONCAT_SSVS(&_3, "Element not found at", " offset ", &_2, ".");
-	ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 3, &_3);
+	if (UNEXPECTED(_0)) {
+		ZEPHIR_INIT_VAR(&_3$$3);
+		object_init_ex(&_3$$3, tensor_exceptions_invalidargumentexception_ce);
+		zephir_cast_to_string(&_4$$3, index);
+		ZEPHIR_INIT_VAR(&_5$$3);
+		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
+		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 3, &_5$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2216);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_METHOD(&_6, "get", NULL, 0, index);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_1, "tensor/vector.zep", 2189);
-	ZEPHIR_MM_RESTORE();
-	return;
+	RETURN_MM();
 }
 
 /**
@@ -6903,12 +6952,13 @@ PHP_METHOD(Tensor_Vector, offsetGet)
  */
 PHP_METHOD(Tensor_Vector, getIterator)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -6918,7 +6968,9 @@ PHP_METHOD(Tensor_Vector, getIterator)
 
 	object_init_ex(return_value, spl_ce_ArrayIterator);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &_0);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 20, &_1);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/vector.zep.h b/ext/tensor/vector.zep.h
index 566df68..624a147 100644
--- a/ext/tensor/vector.zep.h
+++ b/ext/tensor/vector.zep.h
@@ -5,6 +5,7 @@ ZEPHIR_INIT_CLASS(Tensor_Vector);
 
 PHP_METHOD(Tensor_Vector, build);
 PHP_METHOD(Tensor_Vector, quick);
+PHP_METHOD(Tensor_Vector, fromTensorBuffer);
 PHP_METHOD(Tensor_Vector, zeros);
 PHP_METHOD(Tensor_Vector, ones);
 PHP_METHOD(Tensor_Vector, fill);
@@ -131,6 +132,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_vector_quick, 0, 0, 0)
 ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, a, IS_ARRAY, 0, "[]")
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_vector_fromtensorbuffer, 0, 0, 1)
+	ZEND_ARG_OBJ_INFO(0, a, Tensor\\TensorBuffer, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_zeros, 0, 1, Tensor\\Vector, 0)
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
@@ -174,7 +179,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_linspace, 0, 3, Ten
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_vector___construct, 0, 0, 1)
-	ZEND_ARG_ARRAY_INFO(0, a, 0)
+	ZEND_ARG_INFO(0, a)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
 ZEND_END_ARG_INFO()
 
@@ -577,6 +582,7 @@ ZEND_END_ARG_INFO()
 ZEPHIR_INIT_FUNCS(tensor_vector_method_entry) {
 	PHP_ME(Tensor_Vector, build, arginfo_tensor_vector_build, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, quick, arginfo_tensor_vector_quick, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	PHP_ME(Tensor_Vector, fromTensorBuffer, arginfo_tensor_vector_fromtensorbuffer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, zeros, arginfo_tensor_vector_zeros, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, ones, arginfo_tensor_vector_ones, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, fill, arginfo_tensor_vector_fill, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
diff --git a/optimizers/TensorBufferFromArrayOptimizer.php b/optimizers/TensorBufferFromArrayOptimizer.php
new file mode 100644
index 0000000..e64917a
--- /dev/null
+++ b/optimizers/TensorBufferFromArrayOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorBufferFromArrayOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor buffer from array accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/buffer',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_buffer_from_array($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/tensor/columnvector.zep b/tensor/columnvector.zep
index bfc8073..8451961 100644
--- a/tensor/columnvector.zep
+++ b/tensor/columnvector.zep
@@ -36,6 +36,17 @@ class ColumnVector extends Vector
         return new self(a, false);
     }
 
+    /**
+     * Build a column vector from a TensorBuffer object.
+     *
+     * @param \Tensor\TensorBuffer a
+     * @return self
+     */
+    public static function fromTensorBuffer(<TensorBuffer> a)
+    {
+        return new self(a, false);
+    }
+
     /**
      * Return the number of rows in the vector.
      *
@@ -63,7 +74,7 @@ class ColumnVector extends Vector
      */
     public function transpose()
     {
-        return Vector::quick(this->a);
+        return Vector::fromTensorBuffer(this->a);
     }
 
     /**
@@ -98,7 +109,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -133,7 +144,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -168,7 +179,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -203,7 +214,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -238,7 +249,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -273,7 +284,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -308,7 +319,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -343,7 +354,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -378,7 +389,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -413,7 +424,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -448,7 +459,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
@@ -483,7 +494,7 @@ class ColumnVector extends Vector
         array rowC = [];
 
         for i, rowB in b->asArray() {
-            let valueA = this->a[i];
+            let valueA = this->a->get(i);
 
             let rowC = [];
 
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 83fe8ac..01fe7ab 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -370,14 +370,29 @@ class Matrix implements Tensor
     }
 
     /**
-     * @param array[] a
+     * @param array[]|TensorBuffer[] a
      * @param bool validate
      * @throws \Tensor\Exceptions\InvalidArgumentException
      */
-    public function __construct(array a, const bool validate = true)
+    public function __construct(var a, const bool validate = true)
     {
         var i, rowA, valueA;
 
+        /* Transitional: rows may be given as TensorBuffer objects (internal
+         * callers build them from buffer operations). Materialise them so the
+         * array-backed storage below can consume them. Removed in the buffer
+         * storage phase which slices the backing buffer directly. */
+        if typeof a == "array" {
+            for i, rowA in a {
+                if typeof rowA == "object" && rowA instanceof TensorBuffer {
+                    let a[i] = rowA->toArray();
+                }
+            }
+        } else {
+            throw new InvalidArgumentException("Matrix requires an"
+                . " array of arrays.");
+        }
+
         int m = count(a);
         int n = count(current(a) ?: []);
  
@@ -528,6 +543,26 @@ class Matrix implements Tensor
         return this->a;
     }
 
+    /**
+     * Return each row of the matrix as a TensorBuffer.
+     *
+     * @return \Tensor\TensorBuffer[]
+     */
+    public function asRowBuffers() -> array
+    {
+        var row, buffer;
+
+        array b = [];
+
+        for row in this->a {
+            let buffer = tensor_buffer_from_array(row);
+
+            let b[] = new TensorBuffer(<Buffer> buffer);
+        }
+
+        return b;
+    }
+
     /**
      * Return each row as a vector in an array.
      *
diff --git a/tensor/vector.zep b/tensor/vector.zep
index bf9fb76..8b6c342 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -17,9 +17,9 @@ use ArrayIterator;
 class Vector implements Tensor
 {
     /**
-     * A 1-d sequential array holding the elements of the vector.
+     * A 1-d contiguous buffer holding the elements of the vector.
      *
-     * @var list<float>
+     * @var \Tensor\TensorBuffer
      */
     protected a;
 
@@ -52,6 +52,17 @@ class Vector implements Tensor
         return new self(a, false);
     }
 
+    /**
+     * Build a vector from a TensorBuffer object.
+     *
+     * @param \Tensor\TensorBuffer a
+     * @return self
+     */
+    public static function fromTensorBuffer(<TensorBuffer> a)
+    {
+        return new self(a, false);
+    }
+
     /**
      * Build a vector of zeros with n elements.
      *
@@ -287,22 +298,21 @@ class Vector implements Tensor
      * @param float[] a
      * @param bool validate
      */
-    public function __construct(array a, const bool validate = true)
+    public function __construct(var a, const bool validate = true)
     {
-        var valueA;
+        var buffer;
 
-        if validate {
-            array b = [];
+        if typeof a == "array" {
+            let buffer = tensor_buffer_from_array(a);
 
-            for valueA in a {
-                let b[] = is_float(valueA) ? valueA : (float) valueA;
-            }
-
-            let a = b;
+            let a = new TensorBuffer(<Buffer> buffer);
+        } elseif !(a instanceof TensorBuffer) {
+            throw new InvalidArgumentException("Vector requires"
+                . " an array or TensorBuffer object.");
         }
 
-        let this->a = a;
-        let this->n = count(a);
+        let this->a = <TensorBuffer> a;
+        let this->n = this->a->count();
     }
 
     /**
@@ -362,7 +372,7 @@ class Vector implements Tensor
      */
     public function asArray() -> array
     {
-        return this->a;
+        return this->a->toArray();
     }
 
     /**
@@ -384,9 +394,11 @@ class Vector implements Tensor
     {
         var valueA;
 
+        var aHat = this->a->toArray();
+
         array b = [];
 
-        for valueA in this->a {
+        for valueA in aHat {
             let b[] = [valueA];
         }
 
@@ -424,7 +436,7 @@ class Vector implements Tensor
             let rowB = [];
 
             while count(rowB) < n {
-                let rowB[] = this->a[i];
+                let rowB[] = this->a->get(i);
 
                 let i++;
             }
@@ -442,7 +454,7 @@ class Vector implements Tensor
      */
     public function transpose()
     {
-        return ColumnVector::quick(this->a);
+        return ColumnVector::fromTensorBuffer(this->a);
     }
 
     /**
@@ -455,7 +467,7 @@ class Vector implements Tensor
      */
     public function map(const var callback) -> <Vector>
     {
-        return static::quick(array_map(callback, this->a));
+        return static::quick(array_map(callback, this->a->toArray()));
     }
 
     /**
@@ -469,7 +481,7 @@ class Vector implements Tensor
      */
     public function reduce(const var callback, float initial = 0.0) -> float
     {
-        return array_reduce(this->a, callback, initial);
+        return array_reduce(this->a->toArray(), callback, initial);
     }
 
     /**
@@ -487,7 +499,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return tensor_dot(this->a, b->asArray());
+        return tensor_dot(this->a, b->a);
     }
 
     /**
@@ -510,7 +522,7 @@ class Vector implements Tensor
                 . " less than 1, " . strval(stride). " given.");
         }
 
-        return static::quick(tensor_convolve_1d(this->a, b->asArray(), stride));
+        return static::fromTensorBuffer(tensor_convolve_1d(this->a, b->a, stride));
     }
 
     /**
@@ -545,13 +557,15 @@ class Vector implements Tensor
     {
         var j, valueA, valueB;
         
+        var aHat = this->a->toArray();
+
         array bHat = [];
         array c = [];
         array rowC = [];
 
         let bHat = (array) b->asArray();
 
-        for valueA in this->a {
+        for valueA in aHat {
             let rowC = [];
 
             for j, valueB in bHat {
@@ -1056,9 +1070,11 @@ class Vector implements Tensor
 
         var valueA;
 
+        var a = this->a->toArray();
+
         array b = [];
 
-        for valueA in this->a {
+        for valueA in a {
             let b[] = log(valueA, base);
         }
 
@@ -1162,7 +1178,7 @@ class Vector implements Tensor
      */
     public function sum() -> float
     {
-        return (float) array_sum(this->a);
+        return this->a->sum();
     }
 
     /**
@@ -1172,7 +1188,7 @@ class Vector implements Tensor
      */
     public function product() -> float
     {
-        return (float) array_product(this->a);
+        return this->a->product();
     }
 
     /**
@@ -1182,7 +1198,7 @@ class Vector implements Tensor
      */
     public function min() -> float
     {
-        return (float) min(this->a);
+        return this->a->min();
     }
 
     /**
@@ -1192,7 +1208,7 @@ class Vector implements Tensor
      */
     public function max() -> float
     {
-        return (float) max(this->a);
+        return this->a->max();
     }
 
     /**
@@ -1216,7 +1232,7 @@ class Vector implements Tensor
 
         int mid = (int) intdiv(this->n, 2);
 
-        var a = this->a;
+        var a = this->a->toArray();
 
         sort(a);
 
@@ -1243,7 +1259,7 @@ class Vector implements Tensor
                 . " between 0 and 1, " . strval(q) . " given.");
         }
 
-        var a = this->a;
+        var a = this->a->toArray();
 
         sort(a);
 
@@ -1309,7 +1325,9 @@ class Vector implements Tensor
 
         array b = [];
 
-        for valueA in this->a {
+        var a = this->a->toArray();
+
+        for valueA in a {
             let b[] = round(valueA, precision);
         }
 
@@ -1356,7 +1374,9 @@ class Vector implements Tensor
 
         array b = [];
 
-        for valueA in this->a {
+        var a = this->a->toArray();
+
+        for valueA in a {
             if valueA > max {
                 let b[] = max;
 
@@ -1387,7 +1407,9 @@ class Vector implements Tensor
 
         array b = [];
         
-        for valueA in this->a {
+        var a = this->a->toArray();
+
+        for valueA in a {
             if valueA < min {
                 let b[] = min;
 
@@ -1412,7 +1434,9 @@ class Vector implements Tensor
 
         array b = [];
 
-        for valueA in this->a {
+        var a = this->a->toArray();
+
+        for valueA in a {
             if valueA > max {
                 let b[] = max;
 
@@ -1436,7 +1460,9 @@ class Vector implements Tensor
 
         array b = [];
 
-        for valueA in this->a {
+        var a = this->a->toArray();
+
+        for valueA in a {
             if valueA > 0 {
                 let b[] = 1.0;
             } elseif valueA < 0 {
@@ -1460,7 +1486,9 @@ class Vector implements Tensor
         
         array b = [];
 
-        for valueA in this->a {
+        var a = this->a->toArray();
+
+        for valueA in a {
             let b[] = -valueA;
         }
 
@@ -1486,7 +1514,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_multiply(this->a, rowB);
         }
  
@@ -1512,7 +1540,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_divide(this->a, rowB);
         }
  
@@ -1538,7 +1566,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_add(this->a, rowB);
         }
  
@@ -1564,7 +1592,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_subtract(this->a, rowB);
         }
  
@@ -1590,7 +1618,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_pow(this->a, rowB);
         }
  
@@ -1616,7 +1644,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_mod(this->a, rowB);
         }
  
@@ -1642,7 +1670,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_equal(this->a, rowB);
         }
  
@@ -1668,7 +1696,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_not_equal(this->a, rowB);
         }
  
@@ -1694,7 +1722,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_greater(this->a, rowB);
         }
  
@@ -1720,7 +1748,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_greater_equal(this->a, rowB);
         }
  
@@ -1746,7 +1774,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_less(this->a, rowB);
         }
  
@@ -1772,7 +1800,7 @@ class Vector implements Tensor
 
         array c = [];
  
-        for rowB in b->asArray() {
+        for rowB in b->asRowBuffers() {
             let c[] = tensor_less_equal(this->a, rowB);
         }
  
@@ -1794,7 +1822,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_multiply(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_multiply(this->a, b->a));
     }
 
     /**
@@ -1812,7 +1840,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_divide(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_divide(this->a, b->a));
     }
 
     /**
@@ -1830,7 +1858,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_add(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_add(this->a, b->a));
     }
 
     /**
@@ -1848,7 +1876,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_subtract(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_subtract(this->a, b->a));
     }
 
     /**
@@ -1866,7 +1894,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_pow(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_pow(this->a, b->a));
     }
 
     /**
@@ -1884,7 +1912,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_mod(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_mod(this->a, b->a));
     }
 
     /**
@@ -1903,7 +1931,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_equal(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_equal(this->a, b->a));
     }
 
     /**
@@ -1921,7 +1949,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_not_equal(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_not_equal(this->a, b->a));
     }
 
     /**
@@ -1939,7 +1967,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_greater(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_greater(this->a, b->a));
     }
 
     /**
@@ -1957,7 +1985,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_greater_equal(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_greater_equal(this->a, b->a));
     }
 
     /**
@@ -1975,7 +2003,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_less(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_less(this->a, b->a));
     }
 
     /**
@@ -1993,7 +2021,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::quick(tensor_less_equal(this->a, b->asArray()));
+        return static::fromTensorBuffer(tensor_less_equal(this->a, b->a));
     }
 
     /**
@@ -2004,7 +2032,7 @@ class Vector implements Tensor
      */
      public function multiplyScalar(const float b) -> <Vector>
      {
-        return static::quick(tensor_multiply_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_multiply_scalar(this->a, b));
     }
 
     /**
@@ -2015,7 +2043,7 @@ class Vector implements Tensor
      */
     public function divideScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_divide_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_divide_scalar(this->a, b));
     }
 
     /**
@@ -2026,7 +2054,7 @@ class Vector implements Tensor
      */
     public function addScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_add_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_add_scalar(this->a, b));
     }
 
     /**
@@ -2037,7 +2065,7 @@ class Vector implements Tensor
      */
     public function subtractScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_subtract_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_subtract_scalar(this->a, b));
     }
 
     /**
@@ -2048,7 +2076,7 @@ class Vector implements Tensor
      */
      public function powScalar(const float b) -> <Vector>
      {
-        return static::quick(tensor_pow_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_pow_scalar(this->a, b));
      }
 
     /**
@@ -2059,7 +2087,7 @@ class Vector implements Tensor
      */
     public function modScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_mod_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_mod_scalar(this->a, b));
     }
 
     /**
@@ -2070,7 +2098,7 @@ class Vector implements Tensor
      */
     public function equalScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_equal_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_equal_scalar(this->a, b));
     }
 
     /**
@@ -2081,7 +2109,7 @@ class Vector implements Tensor
      */
     public function notEqualScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_not_equal_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_not_equal_scalar(this->a, b));
     }
 
     /**
@@ -2092,7 +2120,7 @@ class Vector implements Tensor
      */
     public function greaterScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_greater_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_greater_scalar(this->a, b));
     }
 
     /**
@@ -2104,7 +2132,7 @@ class Vector implements Tensor
      */
     public function greaterEqualScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_greater_equal_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_greater_equal_scalar(this->a, b));
     }
 
     /**
@@ -2115,7 +2143,7 @@ class Vector implements Tensor
      */
     public function lessScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_less_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_less_scalar(this->a, b));
     }
 
     /**
@@ -2127,7 +2155,7 @@ class Vector implements Tensor
      */
     public function lessEqualScalar(const float b) -> <Vector>
     {
-        return static::quick(tensor_less_equal_scalar(this->a, b));
+        return static::fromTensorBuffer(tensor_less_equal_scalar(this->a, b));
     }
 
     /**
@@ -2158,7 +2186,11 @@ class Vector implements Tensor
      */
     public function offsetExists(const var index) -> bool
     {
-        return isset(this->a[index]);
+        if unlikely !is_int(index) {
+            return false;
+        }
+
+        return index >= 0 && index < this->n;
     }
 
     /**
@@ -2179,14 +2211,12 @@ class Vector implements Tensor
      */
     public function offsetGet(const var index) -> mixed
     {
-        var value;
-
-        if likely fetch value, this->a[index] {
-            return value;
+        if unlikely !is_int(index) || (index < 0 || index >= this->n) {
+            throw new InvalidArgumentException("Element not found at"
+                . " offset " . (string) index . ".");
         }
 
-        throw new InvalidArgumentException("Element not found at"
-            . " offset " . (string) index . ".");
+        return this->a->get(index);
     }
 
     /**
@@ -2196,6 +2226,6 @@ class Vector implements Tensor
      */
     public function getIterator() -> <\Traversable>
     {
-        return new ArrayIterator(this->a);
+        return new ArrayIterator(this->a->toArray());
     }
 }
\ No newline at end of file

From 78aeb955f193c6a89f005f1e1799a432d2a284ac Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 20:15:59 -0500
Subject: [PATCH 07/51] Save game

---
 tensor/matrix.zep | 273 +++++++++++++++++++++++++++++++++-------------
 1 file changed, 195 insertions(+), 78 deletions(-)

diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 01fe7ab..907feef 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -23,9 +23,9 @@ use ArrayIterator;
 class Matrix implements Tensor
 {
     /**
-     * A 2-dimensional sequential array that holds the values of the matrix.
+     * A contiguous row-major buffer holding the elements of the matrix.
      *
-     * @var list<list<float>>
+     * @var \Tensor\TensorBuffer
      */
     protected a;
 
@@ -376,53 +376,78 @@ class Matrix implements Tensor
      */
     public function __construct(var a, const bool validate = true)
     {
-        var i, rowA, valueA;
+        var i, rowA, valueA, firstRow;
 
-        /* Transitional: rows may be given as TensorBuffer objects (internal
-         * callers build them from buffer operations). Materialise them so the
-         * array-backed storage below can consume them. Removed in the buffer
-         * storage phase which slices the backing buffer directly. */
-        if typeof a == "array" {
-            for i, rowA in a {
-                if typeof rowA == "object" && rowA instanceof TensorBuffer {
-                    let a[i] = rowA->toArray();
-                }
-            }
-        } else {
+        if unlikely typeof a !== "array" {
             throw new InvalidArgumentException("Matrix requires an"
                 . " array of arrays.");
         }
 
         int m = count(a);
-        int n = count(current(a) ?: []);
- 
-        if validate {
-            array b = [];
-            array rowB = [];
 
+        int n = 0;
+
+        array flat = [];
+
+        let firstRow = current(a) ?: [];
+
+        if typeof firstRow == "object" {
+            if unlikely !(firstRow instanceof TensorBuffer) {
+                throw new InvalidArgumentException("Matrix requires an"
+                    . " array of arrays.");
+            }
+
+            let n = firstRow->count();
+        } else {
+            let n = count(firstRow);
+        }
+
+        if validate {
             let a = array_values(a);
 
             for i, rowA in a {
-                if unlikely count(rowA) !== n {
-                    throw new InvalidArgumentException("The number of columns"
-                        . " must be equal for all rows, " . strval(n)
-                        . " needed but " . count(rowA) . " given"
-                        . " at row offset " . i . ".");
+                if typeof rowA == "object" {
+                    if unlikely !(rowA instanceof TensorBuffer) {
+                        throw new InvalidArgumentException("Matrix requires an"
+                            . " array of arrays.");
+                    }
+
+                    if unlikely rowA->count() !== n {
+                        throw new InvalidArgumentException("The number of"
+                            . " columns must be equal for all rows, "
+                            .  strval(n) . " needed but " . rowA->count()
+                            .  " given at row offset " . i . ".");
+                    }
+
+                    let rowA = rowA->toArray();
+                } else {
+                    if unlikely count(rowA) !== n {
+                        throw new InvalidArgumentException("The number of"
+                            . " columns must be equal for all rows, "
+                            .  strval(n) . " needed but " . count(rowA)
+                            .  " given at row offset " . i . ".");
+                    }
                 }
 
-                let rowB = [];
-
                 for valueA in rowA {
-                    let rowB[] = is_float(valueA) ? valueA : (float) valueA;
+                    let flat[] = is_float(valueA) ? valueA : (float) valueA;
                 }
-
-                let b[] = rowB;
             }
+        } else {
+            for rowA in a {
+                if typeof rowA == "object" {
+                    let rowA = rowA->toArray();
+                }
 
-            let a = b;
+                for valueA in rowA {
+                    let flat[] = (float) valueA;
+                }
+            }
         }
- 
-        let this->a = a;
+
+        var buffer = tensor_buffer_from_array(flat);
+
+        let this->a = new TensorBuffer(<Buffer> buffer);
         let this->m = m;
         let this->n = n;
     }
@@ -492,10 +517,19 @@ class Matrix implements Tensor
      *
      * @param int index
      * @return \Tensor\Vector
+     * @throws \Tensor\Exceptions\OutOfBoundsException
      */
     public function rowAsVector(const int index) -> <Vector>
     {
-        return this->offsetGet(index);
+        if unlikely index < 0 || index >= this->m {
+            throw new OutOfBoundsException("Row offset out of"
+                . " bounds.");
+        }
+
+        return Vector::fromTensorBuffer(this->a->slice(index * this->n, this->n));
+    }
+
+        return Vector::fromTensorBuffer(this->a->slice(index * this->n, this->n));
     }
 
     /**
@@ -503,44 +537,77 @@ class Matrix implements Tensor
      *
      * @param int index
      * @return \Tensor\ColumnVector
+     * @throws \Tensor\Exceptions\OutOfBoundsException
      */
     public function columnAsVector(const int index) -> <ColumnVector>
     {
-        return ColumnVector::quick(array_column(this->a, index));
+        if unlikely index < 0 || index >= this->n {
+            throw new OutOfBoundsException("Column offset out of"
+                . " bounds.");
+        }
+
+        return ColumnVector::fromTensorBuffer(this->a->sliceStrided(index, this->m, this->n));
+    }
+
+        return ColumnVector::fromTensorBuffer(this->a->sliceStrided(index, this->m, this->n));
     }
 
     /**
      * Return the diagonal elements of a square matrix as a vector.
      *
+     * @return \Tensor\ColumnVector
      * @throws \Tensor\Exceptions\InvalidArgumentException
-     * @return \Tensor\Vector
      */
-    public function diagonalAsVector() -> <Vector>
+    public function diagonalAsVector() -> <ColumnVector>
     {
         if unlikely !this->isSquare() {
             throw new InvalidArgumentException("Matrix must be"
-                . " square, " . this->shapeString() .  " given.");
+                . " square, " . this->shapeString() . " given.");
         }
 
-        var i, rowA;
-
-        array b = [];
+        return ColumnVector::fromTensorBuffer(this->a->sliceStrided(0, this->m, this->n + 1));
+    }
 
-        for i, rowA in this->a {
-            let b[] = rowA[i];
-        }
+        return ColumnVector::fromTensorBuffer(this->a->sliceStrided(0, this->m, this->n + 1));
+    }
 
-        return Vector::quick(b);
+    /**
+     * Return the elements of the matrix as a vector taken in row-major order.
+     *
+     * @return \Tensor\Vector
+     */
+    public function asVector() -> <Vector>
+    {
+        return Vector::fromTensorBuffer(this->a);
     }
 
     /**
-     * Return the elements of the matrix in a 2-d array.
+     * Return the matrix as an array of arrays.
      *
-     * @return list<list<float>>
+     * @return array[]
      */
     public function asArray() -> array
     {
-        return this->a;
+        var rowBuffer;
+
+        array b = [];
+
+        if unlikely this->n < 1 {
+            return [];
+        }
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = rowBuffer->toArray();
+        }
+
+        return b;
+    }
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = rowBuffer->toArray();
+        }
+
+        return b;
     }
 
     /**
@@ -550,55 +617,113 @@ class Matrix implements Tensor
      */
     public function asRowBuffers() -> array
     {
-        var row, buffer;
+        if unlikely this->n < 1 {
+            return [];
+        }
+
+        return this->a->split(this->n);
+    }
+
+        return this->a->split(this->n);
+    }
+
+    /**
+     * Return the rows of the matrix as an array of Vector objects.
+     *
+     * @return \Tensor\Vector[]
+     */
+    public function asRowVectors() -> array
+    {
+        var rowBuffer;
 
         array b = [];
 
-        for row in this->a {
-            let buffer = tensor_buffer_from_array(row);
+        if unlikely this->n < 1 {
+            return [];
+        }
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = Vector::fromTensorBuffer(rowBuffer);
+        }
+
+        return b;
+    }
 
-            let b[] = new TensorBuffer(<Buffer> buffer);
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = Vector::fromTensorBuffer(rowBuffer);
         }
 
         return b;
     }
 
     /**
-     * Return each row as a vector in an array.
+     * Return each column of the matrix as a TensorBuffer.
      *
-     * @return \Tensor\Vector[]
+     * @return \Tensor\TensorBuffer[]
      */
-    public function asVectors() -> array
+    public function asColumnBuffers() -> array
     {
-        return array_map(["Tensor\\Vector", "quick"], this->a);
+        var i;
+
+        array b = [];
+
+        if unlikely this->n < 1 {
+            return [];
+        }
+
+        for i in range(0, this->n - 1) {
+            let b[] = this->a->sliceStrided(i, this->m, this->n);
+        }
+
+        return b;
+    }
+
+        return b;
     }
 
     /**
-     * Return each column as a column vector in an array.
+     * Return the columns of the matrix as an array of ColumnVector objects.
      *
      * @return \Tensor\ColumnVector[]
      */
     public function asColumnVectors() -> array
     {
-        int i;
+        var columnBuffer;
 
-        array vectors = [];
+        array b = [];
 
-        for i in range(0, this->n - 1) {
-            let vectors[] = this->columnAsVector(i);
+        if unlikely this->n < 1 {
+            return [];
         }
 
-        return vectors;
+        for columnBuffer in this->asColumnBuffers() {
+            let b[] = ColumnVector::fromTensorBuffer(columnBuffer);
+        }
+
+        return b;
+    }
+
+        return b;
     }
 
     /**
-     * Flatten i.e unravel the matrix into a vector.
+     * Return the rows of the matrix as an array of Vector objects.
+     *
+     * @return \Tensor\Vector[]
+     */
+    public function asVectors() -> array
+    {
+        return this->asRowVectors();
+    }
+    
+    /**
+     * Return the elements of the matrix as a vector taken in row-major order.
      *
      * @return \Tensor\Vector
      */
     public function flatten() -> <Vector>
     {
-        return Vector::quick(call_user_func_array("array_merge", this->a));
+        return Vector::fromTensorBuffer(this->a);
     }
 
     /**
@@ -611,17 +736,9 @@ class Matrix implements Tensor
      */
     public function map(const var callback) -> <Matrix>
     {
-        var rowA;
-
-        array b = [];
- 
-        for rowA in this->a {
-            let b[] = array_map(callback, rowA);
-        }
- 
-        return self::quick(b);
+        return self::fromTensorBuffer(this->a->map(callback), this->m, this->n);
     }
-    
+
     /**
      * Reduce the matrix down to a scalar using a callback function.
      *
@@ -633,16 +750,16 @@ class Matrix implements Tensor
      */
     public function reduce(const var callback, float initial = 0.0) -> float
     {
-        var rowA, valueA;
+        var rowBuffer, valueA;
 
         var carry = initial;
- 
-        for rowA in this->a {
-            for valueA in rowA {
+
+        for rowBuffer in this->a->split(this->n) {
+            for valueA in rowBuffer {
                 let carry = {callback}(carry, valueA);
             }
         }
- 
+
         return carry;
     }
  

From 64e547c6a45f587d6725d9076a1efad639e4e034 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 21:10:36 -0500
Subject: [PATCH 08/51] Remove a ton of AI slop

---
 tensor/matrix.zep | 32 --------------------------------
 1 file changed, 32 deletions(-)

diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 907feef..277120a 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -529,9 +529,6 @@ class Matrix implements Tensor
         return Vector::fromTensorBuffer(this->a->slice(index * this->n, this->n));
     }
 
-        return Vector::fromTensorBuffer(this->a->slice(index * this->n, this->n));
-    }
-
     /**
      * Return a column as a vector from the matrix.
      *
@@ -549,9 +546,6 @@ class Matrix implements Tensor
         return ColumnVector::fromTensorBuffer(this->a->sliceStrided(index, this->m, this->n));
     }
 
-        return ColumnVector::fromTensorBuffer(this->a->sliceStrided(index, this->m, this->n));
-    }
-
     /**
      * Return the diagonal elements of a square matrix as a vector.
      *
@@ -568,9 +562,6 @@ class Matrix implements Tensor
         return ColumnVector::fromTensorBuffer(this->a->sliceStrided(0, this->m, this->n + 1));
     }
 
-        return ColumnVector::fromTensorBuffer(this->a->sliceStrided(0, this->m, this->n + 1));
-    }
-
     /**
      * Return the elements of the matrix as a vector taken in row-major order.
      *
@@ -603,13 +594,6 @@ class Matrix implements Tensor
         return b;
     }
 
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = rowBuffer->toArray();
-        }
-
-        return b;
-    }
-
     /**
      * Return each row of the matrix as a TensorBuffer.
      *
@@ -624,9 +608,6 @@ class Matrix implements Tensor
         return this->a->split(this->n);
     }
 
-        return this->a->split(this->n);
-    }
-
     /**
      * Return the rows of the matrix as an array of Vector objects.
      *
@@ -649,13 +630,6 @@ class Matrix implements Tensor
         return b;
     }
 
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = Vector::fromTensorBuffer(rowBuffer);
-        }
-
-        return b;
-    }
-
     /**
      * Return each column of the matrix as a TensorBuffer.
      *
@@ -678,9 +652,6 @@ class Matrix implements Tensor
         return b;
     }
 
-        return b;
-    }
-
     /**
      * Return the columns of the matrix as an array of ColumnVector objects.
      *
@@ -703,9 +674,6 @@ class Matrix implements Tensor
         return b;
     }
 
-        return b;
-    }
-
     /**
      * Return the rows of the matrix as an array of Vector objects.
      *

From 618952defd13406b4340d4294d8aba8a473b8cc1 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 21:13:32 -0500
Subject: [PATCH 09/51] Clean up more AI slop

---
 ext/tensor/columnvector.zep.c |  2 +-
 ext/tensor/vector.zep.c       |  2 +-
 tensor/matrix.zep             | 10 +++++-----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index d0af344..f7380a7 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -123,7 +123,7 @@ PHP_METHOD(Tensor_ColumnVector, fromTensorBuffer)
 	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&_0);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_tensorbuffer_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 649a524..f48d61f 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -144,7 +144,7 @@ PHP_METHOD(Tensor_Vector, fromTensorBuffer)
 	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&_0);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, tensor_tensorbuffer_ce)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 277120a..83e6b6c 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -385,7 +385,7 @@ class Matrix implements Tensor
 
         int m = count(a);
 
-        int n = 0;
+        var n;
 
         array flat = [];
 
@@ -517,12 +517,12 @@ class Matrix implements Tensor
      *
      * @param int index
      * @return \Tensor\Vector
-     * @throws \Tensor\Exceptions\OutOfBoundsException
+     * @throws \InvalidArgumentException
      */
     public function rowAsVector(const int index) -> <Vector>
     {
         if unlikely index < 0 || index >= this->m {
-            throw new OutOfBoundsException("Row offset out of"
+            throw new InvalidArgumentException("Row offset out of"
                 . " bounds.");
         }
 
@@ -534,12 +534,12 @@ class Matrix implements Tensor
      *
      * @param int index
      * @return \Tensor\ColumnVector
-     * @throws \Tensor\Exceptions\OutOfBoundsException
+     * @throws \InvalidArgumentException
      */
     public function columnAsVector(const int index) -> <ColumnVector>
     {
         if unlikely index < 0 || index >= this->n {
-            throw new OutOfBoundsException("Column offset out of"
+            throw new InvalidArgumentException("Column offset out of"
                 . " bounds.");
         }
 

From c29eb1196b7054caa6f1c6a370e0f0350b7b5570 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 21:23:30 -0500
Subject: [PATCH 10/51] Remove even more AI slop

---
 CHANGELOG.md | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0d5e538..1d5f3e9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,13 +1,4 @@
-# Change Log
-
-- 3.2.0
-    - Added the `TensorBuffer` decorator class wrapping the kernel `Buffer`
-    - Added in-place `sort()` (ascending or descending) operating on the buffer's raw pointer
-    - Added `slice()` returning a new buffer without materialising a PHP array
-    - Added the `sum()`, `product()`, `min()`, `max()`, `argmin()`, and `argmax()` reductions operating on the buffer's raw pointer
-    - Added `sliceStrided()` for gathering elements at a fixed stride from a buffer
-    - Added `concat()` and `split()` for merging and partitioning buffers
-    - Added `repeat()` for tiling a buffer
+# Change Logdd
 
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension

From dce27285f4d73594f7d95d4e78ef6fcf412278c6 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 21:43:32 -0500
Subject: [PATCH 11/51] Fix more AI slop

---
 CHANGELOG.md                  |    2 +-
 ext/kernel/concat.c           |   35 +-
 ext/kernel/concat.h           |   10 +-
 ext/tensor/matrix.zep.c       | 2441 ++++++++++++++++++++-------------
 ext/tensor/matrix.zep.h       |   31 +-
 ext/tensor/tensorbuffer.zep.c |  112 +-
 ext/tensor/tensorbuffer.zep.h |    6 +
 stubs/TensorBuffer.php        |    4 +
 tensor/matrix.zep             |   21 +
 tensor/tensorbuffer.zep       |   25 +
 tests/TensorBufferTest.php    |   17 +
 11 files changed, 1682 insertions(+), 1022 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1d5f3e9..9059734 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,4 @@
-# Change Logdd
+# Change Log
 
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
diff --git a/ext/kernel/concat.c b/ext/kernel/concat.c
index e34f2ca..f4c0795 100644
--- a/ext/kernel/concat.c
+++ b/ext/kernel/concat.c
@@ -223,10 +223,10 @@ void zephir_concat_ssvsvs(zval *result, const char *op1, uint32_t op1_len, const
 
 }
 
-void zephir_concat_ssvsvssvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, zval *op5, const char *op6, uint32_t op6_len, const char *op7, uint32_t op7_len, zval *op8, const char *op9, uint32_t op9_len, int self_var){
+void zephir_concat_ssvsvsvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, zval *op5, const char *op6, uint32_t op6_len, zval *op7, const char *op8, uint32_t op8_len, int self_var){
 
-	zval result_copy, op3_copy, op5_copy, op8_copy;
-	int use_copy = 0, use_copy3 = 0, use_copy5 = 0, use_copy8 = 0;
+	zval result_copy, op3_copy, op5_copy, op7_copy;
+	int use_copy = 0, use_copy3 = 0, use_copy5 = 0, use_copy7 = 0;
 	size_t offset = 0, length;
 
 	if (Z_TYPE_P(op3) != IS_STRING) {
@@ -243,10 +243,10 @@ void zephir_concat_ssvsvssvs(zval *result, const char *op1, uint32_t op1_len, co
 	   }
 	}
 
-	if (Z_TYPE_P(op8) != IS_STRING) {
-	   use_copy8 = zend_make_printable_zval(op8, &op8_copy);
-	   if (use_copy8) {
-	       op8 = &op8_copy;
+	if (Z_TYPE_P(op7) != IS_STRING) {
+	   use_copy7 = zend_make_printable_zval(op7, &op7_copy);
+	   if (use_copy7) {
+	       op7 = &op7_copy;
 	   }
 	}
 
@@ -271,18 +271,14 @@ void zephir_concat_ssvsvssvs(zval *result, const char *op1, uint32_t op1_len, co
 		goto zephir_concat_overflow;
 	}
 	length += op6_len;
-	if (UNEXPECTED(op7_len > ZSTR_MAX_LEN - length)) {
+	if (UNEXPECTED(Z_STRLEN_P(op7) > ZSTR_MAX_LEN - length)) {
 		goto zephir_concat_overflow;
 	}
-	length += op7_len;
-	if (UNEXPECTED(Z_STRLEN_P(op8) > ZSTR_MAX_LEN - length)) {
+	length += Z_STRLEN_P(op7);
+	if (UNEXPECTED(op8_len > ZSTR_MAX_LEN - length)) {
 		goto zephir_concat_overflow;
 	}
-	length += Z_STRLEN_P(op8);
-	if (UNEXPECTED(op9_len > ZSTR_MAX_LEN - length)) {
-		goto zephir_concat_overflow;
-	}
-	length += op9_len;
+	length += op8_len;
 	if (self_var) {
 
 		if (Z_TYPE_P(result) != IS_STRING) {
@@ -309,9 +305,8 @@ void zephir_concat_ssvsvssvs(zval *result, const char *op1, uint32_t op1_len, co
 	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3), op4, op4_len);
 	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len, Z_STRVAL_P(op5), Z_STRLEN_P(op5));
 	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len + Z_STRLEN_P(op5), op6, op6_len);
-	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len + Z_STRLEN_P(op5) + op6_len, op7, op7_len);
-	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len + Z_STRLEN_P(op5) + op6_len + op7_len, Z_STRVAL_P(op8), Z_STRLEN_P(op8));
-	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len + Z_STRLEN_P(op5) + op6_len + op7_len + Z_STRLEN_P(op8), op9, op9_len);
+	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len + Z_STRLEN_P(op5) + op6_len, Z_STRVAL_P(op7), Z_STRLEN_P(op7));
+	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len + Z_STRLEN_P(op5) + op6_len + Z_STRLEN_P(op7), op8, op8_len);
 	Z_STRVAL_P(result)[length] = 0;
 	zend_string_forget_hash_val(Z_STR_P(result));
 	goto zephir_concat_cleanup;
@@ -331,8 +326,8 @@ void zephir_concat_ssvsvssvs(zval *result, const char *op1, uint32_t op1_len, co
 	   zval_dtor(op5);
 	}
 
-	if (use_copy8) {
-	   zval_dtor(op8);
+	if (use_copy7) {
+	   zval_dtor(op7);
 	}
 
 	if (use_copy) {
diff --git a/ext/kernel/concat.h b/ext/kernel/concat.h
index 97d81ee..a98f9f7 100644
--- a/ext/kernel/concat.h
+++ b/ext/kernel/concat.h
@@ -19,10 +19,10 @@
 #define ZEPHIR_SCONCAT_SSVSVS(result, op1, op2, op3, op4, op5, op6) \
 	 zephir_concat_ssvsvs(result, op1, sizeof(op1)-1, op2, sizeof(op2)-1, op3, op4, sizeof(op4)-1, op5, op6, sizeof(op6)-1, 1);
 
-#define ZEPHIR_CONCAT_SSVSVSSVS(result, op1, op2, op3, op4, op5, op6, op7, op8, op9) \
-	 zephir_concat_ssvsvssvs(result, op1, sizeof(op1)-1, op2, sizeof(op2)-1, op3, op4, sizeof(op4)-1, op5, op6, sizeof(op6)-1, op7, sizeof(op7)-1, op8, op9, sizeof(op9)-1, 0);
-#define ZEPHIR_SCONCAT_SSVSVSSVS(result, op1, op2, op3, op4, op5, op6, op7, op8, op9) \
-	 zephir_concat_ssvsvssvs(result, op1, sizeof(op1)-1, op2, sizeof(op2)-1, op3, op4, sizeof(op4)-1, op5, op6, sizeof(op6)-1, op7, sizeof(op7)-1, op8, op9, sizeof(op9)-1, 1);
+#define ZEPHIR_CONCAT_SSVSVSVS(result, op1, op2, op3, op4, op5, op6, op7, op8) \
+	 zephir_concat_ssvsvsvs(result, op1, sizeof(op1)-1, op2, sizeof(op2)-1, op3, op4, sizeof(op4)-1, op5, op6, sizeof(op6)-1, op7, op8, sizeof(op8)-1, 0);
+#define ZEPHIR_SCONCAT_SSVSVSVS(result, op1, op2, op3, op4, op5, op6, op7, op8) \
+	 zephir_concat_ssvsvsvs(result, op1, sizeof(op1)-1, op2, sizeof(op2)-1, op3, op4, sizeof(op4)-1, op5, op6, sizeof(op6)-1, op7, op8, sizeof(op8)-1, 1);
 
 #define ZEPHIR_CONCAT_SV(result, op1, op2) \
 	 zephir_concat_sv(result, op1, sizeof(op1)-1, op2, 0);
@@ -63,7 +63,7 @@
 void zephir_concat_ss(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, int self_var);
 void zephir_concat_ssvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, int self_var);
 void zephir_concat_ssvsvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, zval *op5, const char *op6, uint32_t op6_len, int self_var);
-void zephir_concat_ssvsvssvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, zval *op5, const char *op6, uint32_t op6_len, const char *op7, uint32_t op7_len, zval *op8, const char *op9, uint32_t op9_len, int self_var);
+void zephir_concat_ssvsvsvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, zval *op5, const char *op6, uint32_t op6_len, zval *op7, const char *op8, uint32_t op8_len, int self_var);
 void zephir_concat_sv(zval *result, const char *op1, uint32_t op1_len, zval *op2, int self_var);
 void zephir_concat_svsvs(zval *result, const char *op1, uint32_t op1_len, zval *op2, const char *op3, uint32_t op3_len, zval *op4, const char *op5, uint32_t op5_len, int self_var);
 void zephir_concat_vs(zval *result, zval *op1, const char *op2, uint32_t op2_len, int self_var);
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 4b52d4d..8180c2e 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -16,11 +16,11 @@
 #include "kernel/memory.h"
 #include "kernel/operators.h"
 #include "kernel/object.h"
+#include "kernel/string.h"
+#include "kernel/array.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
-#include "kernel/array.h"
 #include "math.h"
-#include "kernel/string.h"
 #include "kernel/math.h"
 #include "ext/spl/spl_array.h"
 #include "include/buffer.h"
@@ -44,9 +44,9 @@ ZEPHIR_INIT_CLASS(Tensor_Matrix)
 	ZEPHIR_REGISTER_CLASS(Tensor, Matrix, tensor, matrix, tensor_matrix_method_entry, 0);
 
 	/**
-	 * A 2-dimensional sequential array that holds the values of the matrix.
+	 * A contiguous row-major buffer holding the elements of the matrix.
 	 *
-	 * @var list<list<float>>
+	 * @var \Tensor\TensorBuffer
 	 */
 	zend_declare_property_null(tensor_matrix_ce, SL("a"), ZEND_ACC_PROTECTED);
 	/**
@@ -135,6 +135,86 @@ PHP_METHOD(Tensor_Matrix, quick)
 	RETURN_MM();
 }
 
+/**
+ * Build a matrix from a TensorBuffer object.
+ *
+ * @param \Tensor\TensorBuffer a
+ * @param int m
+ * @param int n
+ * @return self
+ */
+PHP_METHOD(Tensor_Matrix, fromTensorBuffer)
+{
+	zend_bool _6;
+	zval rows;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long m, n, ZEPHIR_LAST_CALL_STATUS;
+	zval *a, a_sub, *m_param = NULL, *n_param = NULL, rowBuffer, _0, _1, *_2, _3, *_4, _5;
+
+	ZVAL_UNDEF(&a_sub);
+	ZVAL_UNDEF(&rowBuffer);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&rows);
+	ZEND_PARSE_PARAMETERS_START(3, 3)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
+		Z_PARAM_LONG(m)
+		Z_PARAM_LONG(n)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 3, 0, &a, &m_param, &n_param);
+	ZEPHIR_INIT_VAR(&rows);
+	array_init(&rows);
+	ZVAL_LONG(&_1, n);
+	ZEPHIR_CALL_METHOD(&_0, a, "split", NULL, 0, &_1);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_0) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_3);
+		zephir_string_to_char_array(&_3, &_0);
+		_2 = &_3;
+	} else {
+		_2 = &_0;
+	}
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 86);
+	if (Z_TYPE_P(_2) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
+		{
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _4);
+			zephir_array_append(&rows, &rowBuffer, PH_SEPARATE, "tensor/matrix.zep", 83);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_6 = 1;
+		while (1) {
+			if (_6) {
+				_6 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _2, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_5, _2, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_5)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowBuffer, _2, "current", NULL, 0);
+			zephir_check_call_status();
+				zephir_array_append(&rows, &rowBuffer, PH_SEPARATE, "tensor/matrix.zep", 83);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&rowBuffer);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZVAL_BOOL(&_1, 0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &rows, &_1);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
 /**
  * Return an identity matrix with dimensionality n x n.
  *
@@ -173,7 +253,7 @@ PHP_METHOD(Tensor_Matrix, identity)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 79);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 100);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -219,10 +299,10 @@ PHP_METHOD(Tensor_Matrix, identity)
 						ZEPHIR_INIT_NVAR(&_10$$5);
 						ZVAL_DOUBLE(&_10$$5, 0.0);
 					}
-					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 91);
+					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 112);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 94);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 115);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
@@ -362,15 +442,15 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 					ZEPHIR_INIT_NVAR(&_7$$4);
 					if (i == j) {
 						ZEPHIR_OBS_NVAR(&_7$$4);
-						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 148);
+						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 169);
 					} else {
 						ZEPHIR_INIT_NVAR(&_7$$4);
 						ZVAL_DOUBLE(&_7$$4, 0.0);
 					}
-					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 148);
+					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 169);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 151);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 172);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
@@ -427,7 +507,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 170);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 191);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -441,7 +521,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 175);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 196);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -505,7 +585,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 193);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 214);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -519,7 +599,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 198);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 219);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -544,9 +624,9 @@ PHP_METHOD(Tensor_Matrix, rand)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_12$$6);
 			ZVAL_DOUBLE(&_12$$6, zephir_safe_div_zval_long(&_10$$6, max));
-			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 210);
+			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 231);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 213);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 234);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -608,7 +688,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 231);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 252);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -622,7 +702,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 236);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 257);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -646,7 +726,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZEPHIR_CALL_FUNCTION(&_10$$6, "array_pop", &_11, 9, &extras);
 			ZEPHIR_UNREF(&extras);
 			zephir_check_call_status();
-			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 251);
+			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 272);
 		}
 		while (1) {
 			if (!(zephir_fast_count_int(&rowA) < n)) {
@@ -665,20 +745,20 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZVAL_DOUBLE(&_18$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * sin(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 259);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 280);
 			ZVAL_DOUBLE(&_20$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * cos(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 260);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 281);
 		}
 		if (zephir_fast_count_int(&rowA) > n) {
 			ZEPHIR_MAKE_REF(&rowA);
 			ZEPHIR_CALL_FUNCTION(&_21$$8, "array_pop", &_11, 9, &rowA);
 			ZEPHIR_UNREF(&rowA);
 			zephir_check_call_status();
-			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 264);
+			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 285);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 267);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 288);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -749,7 +829,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 286);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 307);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -763,7 +843,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 291);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 312);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -777,7 +857,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_12$$5, "Lambda must be", " greater than or equal to 0, ", &_11$$5, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 3, &_12$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 296);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 317);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -823,9 +903,9 @@ PHP_METHOD(Tensor_Matrix, poisson)
 			}
 			ZEPHIR_INIT_NVAR(&_21$$8);
 			ZVAL_DOUBLE(&_21$$8, (k - 1.0));
-			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 325);
+			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 346);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 328);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 349);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -880,7 +960,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 346);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 367);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -894,7 +974,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 351);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 372);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -921,9 +1001,9 @@ PHP_METHOD(Tensor_Matrix, uniform)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_14$$6);
 			ZVAL_DOUBLE(&_14$$6, zephir_safe_div_zval_long(&_12$$6, max));
-			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 363);
+			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 384);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 366);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 387);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -937,57 +1017,83 @@ PHP_METHOD(Tensor_Matrix, uniform)
  */
 PHP_METHOD(Tensor_Matrix, __construct)
 {
-	zval b$$11, rowB$$11;
-	zval _12$$8;
-	zend_string *_4$$3, *_20$$11;
-	zend_ulong _3$$3, _19$$11;
+	zend_string *_10$$9;
+	zend_ulong _9$$9;
+	zval _1$$3, _4$$7, _12$$12, _37$$20;
+	zval flat;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_24 = NULL, *_32 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, m, n;
-	zend_bool validate, _8$$3, _5$$4, _9$$6, _38$$11, _34$$12, _50$$16;
-	zval *a = NULL, a_sub, *validate_param = NULL, i, rowA, valueA, _13, _14, _53, *_0$$3, _1$$3, *_2$$3, _7$$3, _6$$5, _10$$7, _11$$8, _15$$11, *_16$$11, _17$$11, *_18$$11, _37$$11, _21$$13, _22$$13, _23$$13, _25$$13, _26$$13, *_27$$12, _28$$12, *_29$$12, _33$$12, _30$$14, _31$$14, _35$$15, _36$$15, _39$$17, _40$$17, _41$$17, _42$$17, _43$$17, *_44$$16, _45$$16, *_46$$16, _49$$16, _47$$18, _48$$18, _51$$19, _52$$19;
+	zephir_fcall_cache_entry *_16 = NULL, *_29 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, m;
+	zend_bool validate, _35$$9, _31$$10, _54$$18, _69$$26, _66$$27, _76$$31;
+	zval *a = NULL, a_sub, *validate_param = NULL, i, rowA, valueA, firstRow, n, _2, buffer, _78, _79, _0$$3, _3$$7, _5$$9, *_6$$9, _7$$9, *_8$$9, _34$$9, _11$$12, _13$$11, _19$$11, _14$$13, _15$$13, _17$$13, _18$$13, _20$$15, _21$$15, _22$$15, _23$$15, *_24$$10, _25$$10, *_26$$10, _30$$10, _27$$16, _28$$16, _32$$17, _33$$17, _36$$20, _38$$19, _43$$19, _39$$21, _40$$21, _41$$21, _42$$21, _44$$23, _45$$23, _46$$23, _47$$23, *_48$$18, _49$$18, *_50$$18, _53$$18, _51$$24, _52$$24, _55$$25, _56$$25, *_57$$26, _58$$26, *_59$$26, _68$$26, _60$$28, *_61$$27, _62$$27, *_63$$27, _65$$27, _64$$29, _67$$30, _70$$32, *_71$$31, _72$$31, *_73$$31, _75$$31, _74$$33, _77$$34;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&_13);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_53);
+	ZVAL_UNDEF(&firstRow);
+	ZVAL_UNDEF(&n);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&_78);
+	ZVAL_UNDEF(&_79);
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_3$$7);
+	ZVAL_UNDEF(&_5$$9);
+	ZVAL_UNDEF(&_7$$9);
+	ZVAL_UNDEF(&_34$$9);
+	ZVAL_UNDEF(&_11$$12);
+	ZVAL_UNDEF(&_13$$11);
+	ZVAL_UNDEF(&_19$$11);
+	ZVAL_UNDEF(&_14$$13);
+	ZVAL_UNDEF(&_15$$13);
+	ZVAL_UNDEF(&_17$$13);
+	ZVAL_UNDEF(&_18$$13);
+	ZVAL_UNDEF(&_20$$15);
+	ZVAL_UNDEF(&_21$$15);
+	ZVAL_UNDEF(&_22$$15);
+	ZVAL_UNDEF(&_23$$15);
+	ZVAL_UNDEF(&_25$$10);
+	ZVAL_UNDEF(&_30$$10);
+	ZVAL_UNDEF(&_27$$16);
+	ZVAL_UNDEF(&_28$$16);
+	ZVAL_UNDEF(&_32$$17);
+	ZVAL_UNDEF(&_33$$17);
+	ZVAL_UNDEF(&_36$$20);
+	ZVAL_UNDEF(&_38$$19);
+	ZVAL_UNDEF(&_43$$19);
+	ZVAL_UNDEF(&_39$$21);
+	ZVAL_UNDEF(&_40$$21);
+	ZVAL_UNDEF(&_41$$21);
+	ZVAL_UNDEF(&_42$$21);
+	ZVAL_UNDEF(&_44$$23);
+	ZVAL_UNDEF(&_45$$23);
+	ZVAL_UNDEF(&_46$$23);
+	ZVAL_UNDEF(&_47$$23);
+	ZVAL_UNDEF(&_49$$18);
+	ZVAL_UNDEF(&_53$$18);
+	ZVAL_UNDEF(&_51$$24);
+	ZVAL_UNDEF(&_52$$24);
+	ZVAL_UNDEF(&_55$$25);
+	ZVAL_UNDEF(&_56$$25);
+	ZVAL_UNDEF(&_58$$26);
+	ZVAL_UNDEF(&_68$$26);
+	ZVAL_UNDEF(&_60$$28);
+	ZVAL_UNDEF(&_62$$27);
+	ZVAL_UNDEF(&_65$$27);
+	ZVAL_UNDEF(&_64$$29);
+	ZVAL_UNDEF(&_67$$30);
+	ZVAL_UNDEF(&_70$$32);
+	ZVAL_UNDEF(&_72$$31);
+	ZVAL_UNDEF(&_75$$31);
+	ZVAL_UNDEF(&_74$$33);
+	ZVAL_UNDEF(&_77$$34);
+	ZVAL_UNDEF(&flat);
 	ZVAL_UNDEF(&_1$$3);
-	ZVAL_UNDEF(&_7$$3);
-	ZVAL_UNDEF(&_6$$5);
-	ZVAL_UNDEF(&_10$$7);
-	ZVAL_UNDEF(&_11$$8);
-	ZVAL_UNDEF(&_15$$11);
-	ZVAL_UNDEF(&_17$$11);
-	ZVAL_UNDEF(&_37$$11);
-	ZVAL_UNDEF(&_21$$13);
-	ZVAL_UNDEF(&_22$$13);
-	ZVAL_UNDEF(&_23$$13);
-	ZVAL_UNDEF(&_25$$13);
-	ZVAL_UNDEF(&_26$$13);
-	ZVAL_UNDEF(&_28$$12);
-	ZVAL_UNDEF(&_33$$12);
-	ZVAL_UNDEF(&_30$$14);
-	ZVAL_UNDEF(&_31$$14);
-	ZVAL_UNDEF(&_35$$15);
-	ZVAL_UNDEF(&_36$$15);
-	ZVAL_UNDEF(&_39$$17);
-	ZVAL_UNDEF(&_40$$17);
-	ZVAL_UNDEF(&_41$$17);
-	ZVAL_UNDEF(&_42$$17);
-	ZVAL_UNDEF(&_43$$17);
-	ZVAL_UNDEF(&_45$$16);
-	ZVAL_UNDEF(&_49$$16);
-	ZVAL_UNDEF(&_47$$18);
-	ZVAL_UNDEF(&_48$$18);
-	ZVAL_UNDEF(&_51$$19);
-	ZVAL_UNDEF(&_52$$19);
-	ZVAL_UNDEF(&_12$$8);
-	ZVAL_UNDEF(&b$$11);
-	ZVAL_UNDEF(&rowB$$11);
+	ZVAL_UNDEF(&_4$$7);
+	ZVAL_UNDEF(&_12$$12);
+	ZVAL_UNDEF(&_37$$20);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
@@ -1014,303 +1120,443 @@ PHP_METHOD(Tensor_Matrix, __construct)
 		validate = 1;
 	} else {
 		}
-	if (Z_TYPE_P(a) == IS_ARRAY) {
+	if (UNEXPECTED(Z_TYPE_P(a) != IS_ARRAY)) {
+		ZEPHIR_INIT_VAR(&_0$$3);
+		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_1$$3);
+		ZEPHIR_CONCAT_SS(&_1$$3, "Matrix requires an", " array of arrays.");
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 404);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	m = zephir_fast_count_int(a);
+	ZEPHIR_INIT_VAR(&flat);
+	array_init(&flat);
+	ZEPHIR_CALL_FUNCTION(&_2, "current", NULL, 27, a);
+	zephir_check_call_status();
+	if (!(zephir_is_true(&_2))) {
+		ZEPHIR_INIT_VAR(&firstRow);
+		array_init(&firstRow);
+	} else {
+		ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 27, a);
+		zephir_check_call_status();
+	}
+	if (Z_TYPE_P(&firstRow) == IS_OBJECT) {
+		if (UNEXPECTED(!((zephir_instance_of_ev(&firstRow, tensor_tensorbuffer_ce))))) {
+			ZEPHIR_INIT_VAR(&_3$$7);
+			object_init_ex(&_3$$7, tensor_exceptions_invalidargumentexception_ce);
+			ZEPHIR_INIT_VAR(&_4$$7);
+			ZEPHIR_CONCAT_SS(&_4$$7, "Matrix requires an", " array of arrays.");
+			ZEPHIR_CALL_METHOD(NULL, &_3$$7, "__construct", NULL, 3, &_4$$7);
+			zephir_check_call_status();
+			zephir_throw_exception_debug(&_3$$7, "tensor/matrix.zep", 418);
+			ZEPHIR_MM_RESTORE();
+			return;
+		}
+		ZEPHIR_CALL_METHOD(&n, &firstRow, "count", NULL, 0);
+		zephir_check_call_status();
+	} else {
+		ZEPHIR_INIT_NVAR(&n);
+		ZVAL_LONG(&n, zephir_fast_count_int(&firstRow));
+	}
+	if (validate) {
+		ZEPHIR_CALL_FUNCTION(&_5$$9, "array_values", NULL, 26, a);
+		zephir_check_call_status();
+		ZEPHIR_CPY_WRT(a, &_5$$9);
 		if (Z_TYPE_P(a) == IS_STRING) {
-			ZEPHIR_INIT_VAR(&_1$$3);
-			zephir_string_to_char_array(&_1$$3, a);
-			_0$$3 = &_1$$3;
+			ZEPHIR_INIT_VAR(&_7$$9);
+			zephir_string_to_char_array(&_7$$9, a);
+			_6$$9 = &_7$$9;
 		} else {
-			_0$$3 = a;
+			_6$$9 = a;
 		}
-		zephir_is_iterable(_0$$3, 0, "tensor/matrix.zep", 391);
-		if (Z_TYPE_P(_0$$3) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_0$$3), _3$$3, _4$$3, _2$$3)
+		zephir_is_iterable(_6$$9, 0, "tensor/matrix.zep", 457);
+		if (Z_TYPE_P(_6$$9) == IS_ARRAY) {
+			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_6$$9), _9$$9, _10$$9, _8$$9)
 			{
 				ZEPHIR_INIT_NVAR(&i);
-				if (_4$$3 != NULL) { 
-					ZVAL_STR_COPY(&i, _4$$3);
+				if (_10$$9 != NULL) { 
+					ZVAL_STR_COPY(&i, _10$$9);
 				} else {
-					ZVAL_LONG(&i, _3$$3);
+					ZVAL_LONG(&i, _9$$9);
 				}
 				ZEPHIR_INIT_NVAR(&rowA);
-				ZVAL_COPY(&rowA, _2$$3);
-				_5$$4 = Z_TYPE_P(&rowA) == IS_OBJECT;
-				if (_5$$4) {
-					_5$$4 = zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce);
+				ZVAL_COPY(&rowA, _8$$9);
+				if (Z_TYPE_P(&rowA) == IS_OBJECT) {
+					if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
+						ZEPHIR_INIT_NVAR(&_11$$12);
+						object_init_ex(&_11$$12, tensor_exceptions_invalidargumentexception_ce);
+						ZEPHIR_INIT_NVAR(&_12$$12);
+						ZEPHIR_CONCAT_SS(&_12$$12, "Matrix requires an", " array of arrays.");
+						ZEPHIR_CALL_METHOD(NULL, &_11$$12, "__construct", NULL, 3, &_12$$12);
+						zephir_check_call_status();
+						zephir_throw_exception_debug(&_11$$12, "tensor/matrix.zep", 433);
+						ZEPHIR_MM_RESTORE();
+						return;
+					}
+					ZEPHIR_CALL_METHOD(&_13$$11, &rowA, "count", NULL, 0);
+					zephir_check_call_status();
+					if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_13$$11, &n))) {
+						ZEPHIR_INIT_NVAR(&_14$$13);
+						object_init_ex(&_14$$13, tensor_exceptions_invalidargumentexception_ce);
+						ZEPHIR_CALL_FUNCTION(&_15$$13, "strval", &_16, 4, &n);
+						zephir_check_call_status();
+						ZEPHIR_CALL_METHOD(&_17$$13, &rowA, "count", NULL, 0);
+						zephir_check_call_status();
+						ZEPHIR_INIT_NVAR(&_18$$13);
+						ZEPHIR_CONCAT_SSVSVSVS(&_18$$13, "The number of", " columns must be equal for all rows, ", &_15$$13, " needed but ", &_17$$13, " given at row offset ", &i, ".");
+						ZEPHIR_CALL_METHOD(NULL, &_14$$13, "__construct", NULL, 3, &_18$$13);
+						zephir_check_call_status();
+						zephir_throw_exception_debug(&_14$$13, "tensor/matrix.zep", 440);
+						ZEPHIR_MM_RESTORE();
+						return;
+					}
+					ZEPHIR_CALL_METHOD(&_19$$11, &rowA, "toArray", NULL, 0);
+					zephir_check_call_status();
+					ZEPHIR_CPY_WRT(&rowA, &_19$$11);
+				} else {
+					if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA)))) {
+						ZEPHIR_INIT_NVAR(&_20$$15);
+						object_init_ex(&_20$$15, tensor_exceptions_invalidargumentexception_ce);
+						ZEPHIR_CALL_FUNCTION(&_21$$15, "strval", &_16, 4, &n);
+						zephir_check_call_status();
+						ZEPHIR_INIT_NVAR(&_22$$15);
+						ZVAL_LONG(&_22$$15, zephir_fast_count_int(&rowA));
+						ZEPHIR_INIT_NVAR(&_23$$15);
+						ZEPHIR_CONCAT_SSVSVSVS(&_23$$15, "The number of", " columns must be equal for all rows, ", &_21$$15, " needed but ", &_22$$15, " given at row offset ", &i, ".");
+						ZEPHIR_CALL_METHOD(NULL, &_20$$15, "__construct", NULL, 3, &_23$$15);
+						zephir_check_call_status();
+						zephir_throw_exception_debug(&_20$$15, "tensor/matrix.zep", 449);
+						ZEPHIR_MM_RESTORE();
+						return;
+					}
 				}
-				if (_5$$4) {
-					ZEPHIR_CALL_METHOD(&_6$$5, &rowA, "toArray", NULL, 0);
+				if (Z_TYPE_P(&rowA) == IS_STRING) {
+					ZEPHIR_INIT_NVAR(&_25$$10);
+					zephir_string_to_char_array(&_25$$10, &rowA);
+					_24$$10 = &_25$$10;
+				} else {
+					_24$$10 = &rowA;
+				}
+				zephir_is_iterable(_24$$10, 0, "tensor/matrix.zep", 456);
+				if (Z_TYPE_P(_24$$10) == IS_ARRAY) {
+					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_24$$10), _26$$10)
+					{
+						ZEPHIR_INIT_NVAR(&valueA);
+						ZVAL_COPY(&valueA, _26$$10);
+						ZEPHIR_INIT_NVAR(&_27$$16);
+						ZEPHIR_CALL_FUNCTION(&_28$$16, "is_float", &_29, 2, &valueA);
+						zephir_check_call_status();
+						if (zephir_is_true(&_28$$16)) {
+							ZEPHIR_CPY_WRT(&_27$$16, &valueA);
+						} else {
+							ZEPHIR_INIT_NVAR(&_27$$16);
+							ZVAL_DOUBLE(&_27$$16, zephir_get_doubleval(&valueA));
+						}
+						zephir_array_append(&flat, &_27$$16, PH_SEPARATE, "tensor/matrix.zep", 454);
+					} ZEND_HASH_FOREACH_END();
+				} else {
+					ZEPHIR_CALL_METHOD(NULL, _24$$10, "rewind", NULL, 0);
 					zephir_check_call_status();
-					zephir_array_update_zval(a, &i, &_6$$5, PH_COPY | PH_SEPARATE);
+					_31$$10 = 1;
+					while (1) {
+						if (_31$$10) {
+							_31$$10 = 0;
+						} else {
+							ZEPHIR_CALL_METHOD(NULL, _24$$10, "next", NULL, 0);
+							zephir_check_call_status();
+						}
+						ZEPHIR_CALL_METHOD(&_30$$10, _24$$10, "valid", NULL, 0);
+						zephir_check_call_status();
+						if (!zend_is_true(&_30$$10)) {
+							break;
+						}
+						ZEPHIR_CALL_METHOD(&valueA, _24$$10, "current", NULL, 0);
+						zephir_check_call_status();
+							ZEPHIR_INIT_NVAR(&_32$$17);
+							ZEPHIR_CALL_FUNCTION(&_33$$17, "is_float", &_29, 2, &valueA);
+							zephir_check_call_status();
+							if (zephir_is_true(&_33$$17)) {
+								ZEPHIR_CPY_WRT(&_32$$17, &valueA);
+							} else {
+								ZEPHIR_INIT_NVAR(&_32$$17);
+								ZVAL_DOUBLE(&_32$$17, zephir_get_doubleval(&valueA));
+							}
+							zephir_array_append(&flat, &_32$$17, PH_SEPARATE, "tensor/matrix.zep", 454);
+					}
 				}
+				ZEPHIR_INIT_NVAR(&valueA);
 			} ZEND_HASH_FOREACH_END();
 		} else {
-			ZEPHIR_CALL_METHOD(NULL, _0$$3, "rewind", NULL, 0);
+			ZEPHIR_CALL_METHOD(NULL, _6$$9, "rewind", NULL, 0);
 			zephir_check_call_status();
-			_8$$3 = 1;
+			_35$$9 = 1;
 			while (1) {
-				if (_8$$3) {
-					_8$$3 = 0;
+				if (_35$$9) {
+					_35$$9 = 0;
 				} else {
-					ZEPHIR_CALL_METHOD(NULL, _0$$3, "next", NULL, 0);
+					ZEPHIR_CALL_METHOD(NULL, _6$$9, "next", NULL, 0);
 					zephir_check_call_status();
 				}
-				ZEPHIR_CALL_METHOD(&_7$$3, _0$$3, "valid", NULL, 0);
+				ZEPHIR_CALL_METHOD(&_34$$9, _6$$9, "valid", NULL, 0);
 				zephir_check_call_status();
-				if (!zend_is_true(&_7$$3)) {
+				if (!zend_is_true(&_34$$9)) {
 					break;
 				}
-				ZEPHIR_CALL_METHOD(&i, _0$$3, "key", NULL, 0);
+				ZEPHIR_CALL_METHOD(&i, _6$$9, "key", NULL, 0);
 				zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(&rowA, _0$$3, "current", NULL, 0);
+				ZEPHIR_CALL_METHOD(&rowA, _6$$9, "current", NULL, 0);
 				zephir_check_call_status();
-					_9$$6 = Z_TYPE_P(&rowA) == IS_OBJECT;
-					if (_9$$6) {
-						_9$$6 = zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce);
+					if (Z_TYPE_P(&rowA) == IS_OBJECT) {
+						if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
+							ZEPHIR_INIT_NVAR(&_36$$20);
+							object_init_ex(&_36$$20, tensor_exceptions_invalidargumentexception_ce);
+							ZEPHIR_INIT_NVAR(&_37$$20);
+							ZEPHIR_CONCAT_SS(&_37$$20, "Matrix requires an", " array of arrays.");
+							ZEPHIR_CALL_METHOD(NULL, &_36$$20, "__construct", NULL, 3, &_37$$20);
+							zephir_check_call_status();
+							zephir_throw_exception_debug(&_36$$20, "tensor/matrix.zep", 433);
+							ZEPHIR_MM_RESTORE();
+							return;
+						}
+						ZEPHIR_CALL_METHOD(&_38$$19, &rowA, "count", NULL, 0);
+						zephir_check_call_status();
+						if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_38$$19, &n))) {
+							ZEPHIR_INIT_NVAR(&_39$$21);
+							object_init_ex(&_39$$21, tensor_exceptions_invalidargumentexception_ce);
+							ZEPHIR_CALL_FUNCTION(&_40$$21, "strval", &_16, 4, &n);
+							zephir_check_call_status();
+							ZEPHIR_CALL_METHOD(&_41$$21, &rowA, "count", NULL, 0);
+							zephir_check_call_status();
+							ZEPHIR_INIT_NVAR(&_42$$21);
+							ZEPHIR_CONCAT_SSVSVSVS(&_42$$21, "The number of", " columns must be equal for all rows, ", &_40$$21, " needed but ", &_41$$21, " given at row offset ", &i, ".");
+							ZEPHIR_CALL_METHOD(NULL, &_39$$21, "__construct", NULL, 3, &_42$$21);
+							zephir_check_call_status();
+							zephir_throw_exception_debug(&_39$$21, "tensor/matrix.zep", 440);
+							ZEPHIR_MM_RESTORE();
+							return;
+						}
+						ZEPHIR_CALL_METHOD(&_43$$19, &rowA, "toArray", NULL, 0);
+						zephir_check_call_status();
+						ZEPHIR_CPY_WRT(&rowA, &_43$$19);
+					} else {
+						if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA)))) {
+							ZEPHIR_INIT_NVAR(&_44$$23);
+							object_init_ex(&_44$$23, tensor_exceptions_invalidargumentexception_ce);
+							ZEPHIR_CALL_FUNCTION(&_45$$23, "strval", &_16, 4, &n);
+							zephir_check_call_status();
+							ZEPHIR_INIT_NVAR(&_46$$23);
+							ZVAL_LONG(&_46$$23, zephir_fast_count_int(&rowA));
+							ZEPHIR_INIT_NVAR(&_47$$23);
+							ZEPHIR_CONCAT_SSVSVSVS(&_47$$23, "The number of", " columns must be equal for all rows, ", &_45$$23, " needed but ", &_46$$23, " given at row offset ", &i, ".");
+							ZEPHIR_CALL_METHOD(NULL, &_44$$23, "__construct", NULL, 3, &_47$$23);
+							zephir_check_call_status();
+							zephir_throw_exception_debug(&_44$$23, "tensor/matrix.zep", 449);
+							ZEPHIR_MM_RESTORE();
+							return;
+						}
 					}
-					if (_9$$6) {
-						ZEPHIR_CALL_METHOD(&_10$$7, &rowA, "toArray", NULL, 0);
+					if (Z_TYPE_P(&rowA) == IS_STRING) {
+						ZEPHIR_INIT_NVAR(&_49$$18);
+						zephir_string_to_char_array(&_49$$18, &rowA);
+						_48$$18 = &_49$$18;
+					} else {
+						_48$$18 = &rowA;
+					}
+					zephir_is_iterable(_48$$18, 0, "tensor/matrix.zep", 456);
+					if (Z_TYPE_P(_48$$18) == IS_ARRAY) {
+						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_48$$18), _50$$18)
+						{
+							ZEPHIR_INIT_NVAR(&valueA);
+							ZVAL_COPY(&valueA, _50$$18);
+							ZEPHIR_INIT_NVAR(&_51$$24);
+							ZEPHIR_CALL_FUNCTION(&_52$$24, "is_float", &_29, 2, &valueA);
+							zephir_check_call_status();
+							if (zephir_is_true(&_52$$24)) {
+								ZEPHIR_CPY_WRT(&_51$$24, &valueA);
+							} else {
+								ZEPHIR_INIT_NVAR(&_51$$24);
+								ZVAL_DOUBLE(&_51$$24, zephir_get_doubleval(&valueA));
+							}
+							zephir_array_append(&flat, &_51$$24, PH_SEPARATE, "tensor/matrix.zep", 454);
+						} ZEND_HASH_FOREACH_END();
+					} else {
+						ZEPHIR_CALL_METHOD(NULL, _48$$18, "rewind", NULL, 0);
 						zephir_check_call_status();
-						zephir_array_update_zval(a, &i, &_10$$7, PH_COPY | PH_SEPARATE);
+						_54$$18 = 1;
+						while (1) {
+							if (_54$$18) {
+								_54$$18 = 0;
+							} else {
+								ZEPHIR_CALL_METHOD(NULL, _48$$18, "next", NULL, 0);
+								zephir_check_call_status();
+							}
+							ZEPHIR_CALL_METHOD(&_53$$18, _48$$18, "valid", NULL, 0);
+							zephir_check_call_status();
+							if (!zend_is_true(&_53$$18)) {
+								break;
+							}
+							ZEPHIR_CALL_METHOD(&valueA, _48$$18, "current", NULL, 0);
+							zephir_check_call_status();
+								ZEPHIR_INIT_NVAR(&_55$$25);
+								ZEPHIR_CALL_FUNCTION(&_56$$25, "is_float", &_29, 2, &valueA);
+								zephir_check_call_status();
+								if (zephir_is_true(&_56$$25)) {
+									ZEPHIR_CPY_WRT(&_55$$25, &valueA);
+								} else {
+									ZEPHIR_INIT_NVAR(&_55$$25);
+									ZVAL_DOUBLE(&_55$$25, zephir_get_doubleval(&valueA));
+								}
+								zephir_array_append(&flat, &_55$$25, PH_SEPARATE, "tensor/matrix.zep", 454);
+						}
 					}
+					ZEPHIR_INIT_NVAR(&valueA);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 		ZEPHIR_INIT_NVAR(&i);
 	} else {
-		ZEPHIR_INIT_VAR(&_11$$8);
-		object_init_ex(&_11$$8, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_INIT_VAR(&_12$$8);
-		ZEPHIR_CONCAT_SS(&_12$$8, "Matrix requires an", " array of arrays.");
-		ZEPHIR_CALL_METHOD(NULL, &_11$$8, "__construct", NULL, 3, &_12$$8);
-		zephir_check_call_status();
-		zephir_throw_exception_debug(&_11$$8, "tensor/matrix.zep", 393);
-		ZEPHIR_MM_RESTORE();
-		return;
-	}
-	m = zephir_fast_count_int(a);
-	ZEPHIR_INIT_VAR(&_13);
-	ZEPHIR_CALL_FUNCTION(&_14, "current", NULL, 27, a);
-	zephir_check_call_status();
-	if (!(zephir_is_true(&_14))) {
-		ZEPHIR_INIT_NVAR(&_13);
-		array_init(&_13);
-	} else {
-		ZEPHIR_CALL_FUNCTION(&_13, "current", NULL, 27, a);
-		zephir_check_call_status();
-	}
-	n = zephir_fast_count_int(&_13);
-	if (validate) {
-		ZEPHIR_INIT_VAR(&b$$11);
-		array_init(&b$$11);
-		ZEPHIR_INIT_VAR(&rowB$$11);
-		array_init(&rowB$$11);
-		ZEPHIR_CALL_FUNCTION(&_15$$11, "array_values", NULL, 26, a);
-		zephir_check_call_status();
-		ZEPHIR_CPY_WRT(a, &_15$$11);
 		if (Z_TYPE_P(a) == IS_STRING) {
-			ZEPHIR_INIT_VAR(&_17$$11);
-			zephir_string_to_char_array(&_17$$11, a);
-			_16$$11 = &_17$$11;
+			ZEPHIR_INIT_VAR(&_58$$26);
+			zephir_string_to_char_array(&_58$$26, a);
+			_57$$26 = &_58$$26;
 		} else {
-			_16$$11 = a;
+			_57$$26 = a;
 		}
-		zephir_is_iterable(_16$$11, 0, "tensor/matrix.zep", 422);
-		if (Z_TYPE_P(_16$$11) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_16$$11), _19$$11, _20$$11, _18$$11)
+		zephir_is_iterable(_57$$26, 0, "tensor/matrix.zep", 467);
+		if (Z_TYPE_P(_57$$26) == IS_ARRAY) {
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_57$$26), _59$$26)
 			{
-				ZEPHIR_INIT_NVAR(&i);
-				if (_20$$11 != NULL) { 
-					ZVAL_STR_COPY(&i, _20$$11);
-				} else {
-					ZVAL_LONG(&i, _19$$11);
-				}
 				ZEPHIR_INIT_NVAR(&rowA);
-				ZVAL_COPY(&rowA, _18$$11);
-				if (UNEXPECTED(zephir_fast_count_int(&rowA) != n)) {
-					ZEPHIR_INIT_NVAR(&_21$$13);
-					object_init_ex(&_21$$13, tensor_exceptions_invalidargumentexception_ce);
-					ZVAL_LONG(&_22$$13, n);
-					ZEPHIR_CALL_FUNCTION(&_23$$13, "strval", &_24, 4, &_22$$13);
-					zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&_25$$13);
-					ZVAL_LONG(&_25$$13, zephir_fast_count_int(&rowA));
-					ZEPHIR_INIT_NVAR(&_26$$13);
-					ZEPHIR_CONCAT_SSVSVSSVS(&_26$$13, "The number of columns", " must be equal for all rows, ", &_23$$13, " needed but ", &_25$$13, " given", " at row offset ", &i, ".");
-					ZEPHIR_CALL_METHOD(NULL, &_21$$13, "__construct", NULL, 3, &_26$$13);
+				ZVAL_COPY(&rowA, _59$$26);
+				if (Z_TYPE_P(&rowA) == IS_OBJECT) {
+					ZEPHIR_CALL_METHOD(&_60$$28, &rowA, "toArray", NULL, 0);
 					zephir_check_call_status();
-					zephir_throw_exception_debug(&_21$$13, "tensor/matrix.zep", 410);
-					ZEPHIR_MM_RESTORE();
-					return;
+					ZEPHIR_CPY_WRT(&rowA, &_60$$28);
 				}
-				ZEPHIR_INIT_NVAR(&rowB$$11);
-				array_init(&rowB$$11);
-				ZEPHIR_CPY_WRT(&rowB$$11, &rowB$$11);
 				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_28$$12);
-					zephir_string_to_char_array(&_28$$12, &rowA);
-					_27$$12 = &_28$$12;
+					ZEPHIR_INIT_NVAR(&_62$$27);
+					zephir_string_to_char_array(&_62$$27, &rowA);
+					_61$$27 = &_62$$27;
 				} else {
-					_27$$12 = &rowA;
+					_61$$27 = &rowA;
 				}
-				zephir_is_iterable(_27$$12, 0, "tensor/matrix.zep", 419);
-				if (Z_TYPE_P(_27$$12) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_27$$12), _29$$12)
+				zephir_is_iterable(_61$$27, 0, "tensor/matrix.zep", 466);
+				if (Z_TYPE_P(_61$$27) == IS_ARRAY) {
+					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_61$$27), _63$$27)
 					{
 						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _29$$12);
-						ZEPHIR_INIT_NVAR(&_30$$14);
-						ZEPHIR_CALL_FUNCTION(&_31$$14, "is_float", &_32, 2, &valueA);
-						zephir_check_call_status();
-						if (zephir_is_true(&_31$$14)) {
-							ZEPHIR_CPY_WRT(&_30$$14, &valueA);
-						} else {
-							ZEPHIR_INIT_NVAR(&_30$$14);
-							ZVAL_DOUBLE(&_30$$14, zephir_get_doubleval(&valueA));
-						}
-						zephir_array_append(&rowB$$11, &_30$$14, PH_SEPARATE, "tensor/matrix.zep", 416);
+						ZVAL_COPY(&valueA, _63$$27);
+						ZEPHIR_INIT_NVAR(&_64$$29);
+						ZVAL_DOUBLE(&_64$$29, zephir_get_doubleval(&valueA));
+						zephir_array_append(&flat, &_64$$29, PH_SEPARATE, "tensor/matrix.zep", 464);
 					} ZEND_HASH_FOREACH_END();
 				} else {
-					ZEPHIR_CALL_METHOD(NULL, _27$$12, "rewind", NULL, 0);
+					ZEPHIR_CALL_METHOD(NULL, _61$$27, "rewind", NULL, 0);
 					zephir_check_call_status();
-					_34$$12 = 1;
+					_66$$27 = 1;
 					while (1) {
-						if (_34$$12) {
-							_34$$12 = 0;
+						if (_66$$27) {
+							_66$$27 = 0;
 						} else {
-							ZEPHIR_CALL_METHOD(NULL, _27$$12, "next", NULL, 0);
+							ZEPHIR_CALL_METHOD(NULL, _61$$27, "next", NULL, 0);
 							zephir_check_call_status();
 						}
-						ZEPHIR_CALL_METHOD(&_33$$12, _27$$12, "valid", NULL, 0);
+						ZEPHIR_CALL_METHOD(&_65$$27, _61$$27, "valid", NULL, 0);
 						zephir_check_call_status();
-						if (!zend_is_true(&_33$$12)) {
+						if (!zend_is_true(&_65$$27)) {
 							break;
 						}
-						ZEPHIR_CALL_METHOD(&valueA, _27$$12, "current", NULL, 0);
+						ZEPHIR_CALL_METHOD(&valueA, _61$$27, "current", NULL, 0);
 						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_35$$15);
-							ZEPHIR_CALL_FUNCTION(&_36$$15, "is_float", &_32, 2, &valueA);
-							zephir_check_call_status();
-							if (zephir_is_true(&_36$$15)) {
-								ZEPHIR_CPY_WRT(&_35$$15, &valueA);
-							} else {
-								ZEPHIR_INIT_NVAR(&_35$$15);
-								ZVAL_DOUBLE(&_35$$15, zephir_get_doubleval(&valueA));
-							}
-							zephir_array_append(&rowB$$11, &_35$$15, PH_SEPARATE, "tensor/matrix.zep", 416);
+							ZEPHIR_INIT_NVAR(&_67$$30);
+							ZVAL_DOUBLE(&_67$$30, zephir_get_doubleval(&valueA));
+							zephir_array_append(&flat, &_67$$30, PH_SEPARATE, "tensor/matrix.zep", 464);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b$$11, &rowB$$11, PH_SEPARATE, "tensor/matrix.zep", 419);
 			} ZEND_HASH_FOREACH_END();
 		} else {
-			ZEPHIR_CALL_METHOD(NULL, _16$$11, "rewind", NULL, 0);
+			ZEPHIR_CALL_METHOD(NULL, _57$$26, "rewind", NULL, 0);
 			zephir_check_call_status();
-			_38$$11 = 1;
+			_69$$26 = 1;
 			while (1) {
-				if (_38$$11) {
-					_38$$11 = 0;
+				if (_69$$26) {
+					_69$$26 = 0;
 				} else {
-					ZEPHIR_CALL_METHOD(NULL, _16$$11, "next", NULL, 0);
+					ZEPHIR_CALL_METHOD(NULL, _57$$26, "next", NULL, 0);
 					zephir_check_call_status();
 				}
-				ZEPHIR_CALL_METHOD(&_37$$11, _16$$11, "valid", NULL, 0);
+				ZEPHIR_CALL_METHOD(&_68$$26, _57$$26, "valid", NULL, 0);
 				zephir_check_call_status();
-				if (!zend_is_true(&_37$$11)) {
+				if (!zend_is_true(&_68$$26)) {
 					break;
 				}
-				ZEPHIR_CALL_METHOD(&i, _16$$11, "key", NULL, 0);
+				ZEPHIR_CALL_METHOD(&rowA, _57$$26, "current", NULL, 0);
 				zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(&rowA, _16$$11, "current", NULL, 0);
-				zephir_check_call_status();
-					if (UNEXPECTED(zephir_fast_count_int(&rowA) != n)) {
-						ZEPHIR_INIT_NVAR(&_39$$17);
-						object_init_ex(&_39$$17, tensor_exceptions_invalidargumentexception_ce);
-						ZVAL_LONG(&_40$$17, n);
-						ZEPHIR_CALL_FUNCTION(&_41$$17, "strval", &_24, 4, &_40$$17);
-						zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_42$$17);
-						ZVAL_LONG(&_42$$17, zephir_fast_count_int(&rowA));
-						ZEPHIR_INIT_NVAR(&_43$$17);
-						ZEPHIR_CONCAT_SSVSVSSVS(&_43$$17, "The number of columns", " must be equal for all rows, ", &_41$$17, " needed but ", &_42$$17, " given", " at row offset ", &i, ".");
-						ZEPHIR_CALL_METHOD(NULL, &_39$$17, "__construct", NULL, 3, &_43$$17);
+					if (Z_TYPE_P(&rowA) == IS_OBJECT) {
+						ZEPHIR_CALL_METHOD(&_70$$32, &rowA, "toArray", NULL, 0);
 						zephir_check_call_status();
-						zephir_throw_exception_debug(&_39$$17, "tensor/matrix.zep", 410);
-						ZEPHIR_MM_RESTORE();
-						return;
+						ZEPHIR_CPY_WRT(&rowA, &_70$$32);
 					}
-					ZEPHIR_INIT_NVAR(&rowB$$11);
-					array_init(&rowB$$11);
-					ZEPHIR_CPY_WRT(&rowB$$11, &rowB$$11);
 					if (Z_TYPE_P(&rowA) == IS_STRING) {
-						ZEPHIR_INIT_NVAR(&_45$$16);
-						zephir_string_to_char_array(&_45$$16, &rowA);
-						_44$$16 = &_45$$16;
+						ZEPHIR_INIT_NVAR(&_72$$31);
+						zephir_string_to_char_array(&_72$$31, &rowA);
+						_71$$31 = &_72$$31;
 					} else {
-						_44$$16 = &rowA;
+						_71$$31 = &rowA;
 					}
-					zephir_is_iterable(_44$$16, 0, "tensor/matrix.zep", 419);
-					if (Z_TYPE_P(_44$$16) == IS_ARRAY) {
-						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_44$$16), _46$$16)
+					zephir_is_iterable(_71$$31, 0, "tensor/matrix.zep", 466);
+					if (Z_TYPE_P(_71$$31) == IS_ARRAY) {
+						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_71$$31), _73$$31)
 						{
 							ZEPHIR_INIT_NVAR(&valueA);
-							ZVAL_COPY(&valueA, _46$$16);
-							ZEPHIR_INIT_NVAR(&_47$$18);
-							ZEPHIR_CALL_FUNCTION(&_48$$18, "is_float", &_32, 2, &valueA);
-							zephir_check_call_status();
-							if (zephir_is_true(&_48$$18)) {
-								ZEPHIR_CPY_WRT(&_47$$18, &valueA);
-							} else {
-								ZEPHIR_INIT_NVAR(&_47$$18);
-								ZVAL_DOUBLE(&_47$$18, zephir_get_doubleval(&valueA));
-							}
-							zephir_array_append(&rowB$$11, &_47$$18, PH_SEPARATE, "tensor/matrix.zep", 416);
+							ZVAL_COPY(&valueA, _73$$31);
+							ZEPHIR_INIT_NVAR(&_74$$33);
+							ZVAL_DOUBLE(&_74$$33, zephir_get_doubleval(&valueA));
+							zephir_array_append(&flat, &_74$$33, PH_SEPARATE, "tensor/matrix.zep", 464);
 						} ZEND_HASH_FOREACH_END();
 					} else {
-						ZEPHIR_CALL_METHOD(NULL, _44$$16, "rewind", NULL, 0);
+						ZEPHIR_CALL_METHOD(NULL, _71$$31, "rewind", NULL, 0);
 						zephir_check_call_status();
-						_50$$16 = 1;
+						_76$$31 = 1;
 						while (1) {
-							if (_50$$16) {
-								_50$$16 = 0;
+							if (_76$$31) {
+								_76$$31 = 0;
 							} else {
-								ZEPHIR_CALL_METHOD(NULL, _44$$16, "next", NULL, 0);
+								ZEPHIR_CALL_METHOD(NULL, _71$$31, "next", NULL, 0);
 								zephir_check_call_status();
 							}
-							ZEPHIR_CALL_METHOD(&_49$$16, _44$$16, "valid", NULL, 0);
+							ZEPHIR_CALL_METHOD(&_75$$31, _71$$31, "valid", NULL, 0);
 							zephir_check_call_status();
-							if (!zend_is_true(&_49$$16)) {
+							if (!zend_is_true(&_75$$31)) {
 								break;
 							}
-							ZEPHIR_CALL_METHOD(&valueA, _44$$16, "current", NULL, 0);
+							ZEPHIR_CALL_METHOD(&valueA, _71$$31, "current", NULL, 0);
 							zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_51$$19);
-								ZEPHIR_CALL_FUNCTION(&_52$$19, "is_float", &_32, 2, &valueA);
-								zephir_check_call_status();
-								if (zephir_is_true(&_52$$19)) {
-									ZEPHIR_CPY_WRT(&_51$$19, &valueA);
-								} else {
-									ZEPHIR_INIT_NVAR(&_51$$19);
-									ZVAL_DOUBLE(&_51$$19, zephir_get_doubleval(&valueA));
-								}
-								zephir_array_append(&rowB$$11, &_51$$19, PH_SEPARATE, "tensor/matrix.zep", 416);
+								ZEPHIR_INIT_NVAR(&_77$$34);
+								ZVAL_DOUBLE(&_77$$34, zephir_get_doubleval(&valueA));
+								zephir_array_append(&flat, &_77$$34, PH_SEPARATE, "tensor/matrix.zep", 464);
 						}
 					}
 					ZEPHIR_INIT_NVAR(&valueA);
-					zephir_array_append(&b$$11, &rowB$$11, PH_SEPARATE, "tensor/matrix.zep", 419);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
-		ZEPHIR_INIT_NVAR(&i);
-		ZEPHIR_CPY_WRT(a, &b$$11);
-	}
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, a);
-	ZVAL_UNDEF(&_53);
-	ZVAL_LONG(&_53, m);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_53);
-	ZVAL_UNDEF(&_53);
-	ZVAL_LONG(&_53, n);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_53);
+	}
+	ZEPHIR_INIT_VAR(&buffer);
+	tensor_buffer_from_array(&buffer, &flat);
+	ZEPHIR_INIT_VAR(&_78);
+	object_init_ex(&_78, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, &_78, "__construct", NULL, 14, &buffer);
+	zephir_check_call_status();
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_78);
+	ZVAL_UNDEF(&_79);
+	ZVAL_LONG(&_79, m);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_79);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &n);
 	ZEPHIR_MM_RESTORE();
 }
 
@@ -1462,23 +1708,67 @@ PHP_METHOD(Tensor_Matrix, n)
  *
  * @param int index
  * @return \Tensor\Vector
+ * @throws \InvalidArgumentException
  */
 PHP_METHOD(Tensor_Matrix, rowAsVector)
 {
+	zval _3$$3;
+	zend_bool _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *index_param = NULL, _0;
+	zval *index_param = NULL, _1, _4, _5, _6, _7, _8, _2$$3;
 	zend_long index, ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
+
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_LONG(index)
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &index_param);
-	ZVAL_LONG(&_0, index);
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "offsetGet", NULL, 0, &_0);
+	_0 = index < 0;
+	if (!(_0)) {
+		zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+		_0 = ZEPHIR_LE_LONG(&_1, index);
+	}
+	if (UNEXPECTED(_0)) {
+		ZEPHIR_INIT_VAR(&_2$$3);
+		object_init_ex(&_2$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_3$$3);
+		ZEPHIR_CONCAT_SS(&_3$$3, "Row offset out of", " bounds.");
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 547);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_8, (index * (zend_long) zephir_get_numberval(&_6)));
+	ZEPHIR_CALL_METHOD(&_5, &_4, "slice", NULL, 0, &_8, &_7);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1488,20 +1778,36 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
  *
  * @param int index
  * @return \Tensor\ColumnVector
+ * @throws \InvalidArgumentException
  */
 PHP_METHOD(Tensor_Matrix, columnAsVector)
 {
+	zval _3$$3;
+	zend_bool _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *index_param = NULL, _0, _1, _2;
+	zval *index_param = NULL, _1, _4, _5, _6, _7, _8, _2$$3;
 	zend_long index, ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -1510,11 +1816,29 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &index_param);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZVAL_LONG(&_1, index);
-	ZEPHIR_CALL_FUNCTION(&_2, "array_column", NULL, 28, &_0, &_1);
+	_0 = index < 0;
+	if (!(_0)) {
+		zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+		_0 = ZEPHIR_LE_LONG(&_1, index);
+	}
+	if (UNEXPECTED(_0)) {
+		ZEPHIR_INIT_VAR(&_2$$3);
+		object_init_ex(&_2$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_3$$3);
+		ZEPHIR_CONCAT_SS(&_3$$3, "Column offset out of", " bounds.");
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 564);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_8, index);
+	ZEPHIR_CALL_METHOD(&_5, &_4, "sliceStrided", NULL, 0, &_8, &_6, &_7);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromTensorBuffer", NULL, 0, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1522,36 +1846,38 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 /**
  * Return the diagonal elements of a square matrix as a vector.
  *
+ * @return \Tensor\ColumnVector
  * @throws \Tensor\Exceptions\InvalidArgumentException
- * @return \Tensor\Vector
  */
 PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 {
-	zend_bool _12;
-	zend_string *_9;
-	zend_ulong _8;
-	zval b;
-	zval _0, i, rowA, _4, *_5, _6, *_7, _11, _1$$3, _2$$3, _3$$3, _10$$4, _13$$5;
+	zval _0, _4, _5, _6, _7, _8, _9, _1$$3, _2$$3, _3$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
 	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
-	ZVAL_UNDEF(&_10$$4);
-	ZVAL_UNDEF(&_13$$5);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
@@ -1566,268 +1892,452 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 522);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 580);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_8, 0);
+	ZVAL_LONG(&_9, (zephir_get_numberval(&_7) + 1));
+	ZEPHIR_CALL_METHOD(&_5, &_4, "sliceStrided", NULL, 0, &_8, &_6, &_9);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromTensorBuffer", NULL, 0, &_5);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return the elements of the matrix as a vector taken in row-major order.
+ *
+ * @return \Tensor\Vector
+ */
+PHP_METHOD(Tensor_Matrix, asVector)
+{
+	zval _0;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_0);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return the matrix as an array of arrays.
+ *
+ * @return array[]
+ */
+PHP_METHOD(Tensor_Matrix, asArray)
+{
+	zend_bool _9;
+	zval b;
+	zval rowBuffer, _0, _1, _2, _3, *_4, _5, *_6, _8, _7$$4, _10$$5;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&rowBuffer);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&_10$$5);
+	ZVAL_UNDEF(&b);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_4) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_6);
-		zephir_string_to_char_array(&_6, &_4);
-		_5 = &_6;
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		array_init(return_value);
+		RETURN_MM();
+	}
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_2, &_1, "split", NULL, 0, &_3);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_2) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_5);
+		zephir_string_to_char_array(&_5, &_2);
+		_4 = &_5;
 	} else {
-		_5 = &_4;
+		_4 = &_2;
 	}
-	zephir_is_iterable(_5, 0, "tensor/matrix.zep", 533);
-	if (Z_TYPE_P(_5) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_5), _8, _9, _7)
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 615);
+	if (Z_TYPE_P(_4) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_9 != NULL) { 
-				ZVAL_STR_COPY(&i, _9);
-			} else {
-				ZVAL_LONG(&i, _8);
-			}
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _7);
-			ZEPHIR_OBS_NVAR(&_10$$4);
-			zephir_array_fetch(&_10$$4, &rowA, &i, PH_NOISY, "tensor/matrix.zep", 530);
-			zephir_array_append(&b, &_10$$4, PH_SEPARATE, "tensor/matrix.zep", 530);
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _6);
+			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 612);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _5, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_12 = 1;
+		_9 = 1;
 		while (1) {
-			if (_12) {
-				_12 = 0;
+			if (_9) {
+				_9 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _5, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _4, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_11, _5, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_8, _4, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_11)) {
+			if (!zend_is_true(&_8)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&i, _5, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowA, _5, "current", NULL, 0);
+			ZEPHIR_CALL_METHOD(&rowBuffer, _4, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_OBS_NVAR(&_13$$5);
-				zephir_array_fetch(&_13$$5, &rowA, &i, PH_NOISY, "tensor/matrix.zep", 530);
-				zephir_array_append(&b, &_13$$5, PH_SEPARATE, "tensor/matrix.zep", 530);
+				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
+				zephir_check_call_status();
+				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 612);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "quick", NULL, 0, &b);
+	ZEPHIR_INIT_NVAR(&rowBuffer);
+	RETURN_CTOR(&b);
+}
+
+/**
+ * Return each row of the matrix as a TensorBuffer.
+ *
+ * @return \Tensor\TensorBuffer[]
+ */
+PHP_METHOD(Tensor_Matrix, asRowBuffers)
+{
+	zval _0, _1, _2;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		array_init(return_value);
+		RETURN_MM();
+	}
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_METHOD(&_1, "split", NULL, 0, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
 
 /**
- * Return the elements of the matrix in a 2-d array.
+ * Return the rows of the matrix as an array of Vector objects.
  *
- * @return list<list<float>>
+ * @return \Tensor\Vector[]
  */
-PHP_METHOD(Tensor_Matrix, asArray)
+PHP_METHOD(Tensor_Matrix, asRowVectors)
+{
+	zend_bool _10;
+	zval b;
+	zval rowBuffer, _0, _1, _2, _3, *_4, _5, *_6, _9, _7$$4, _11$$5;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zephir_fcall_cache_entry *_8 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&rowBuffer);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&_11$$5);
+	ZVAL_UNDEF(&b);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		array_init(return_value);
+		RETURN_MM();
+	}
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_2, &_1, "split", NULL, 0, &_3);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_2) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_5);
+		zephir_string_to_char_array(&_5, &_2);
+		_4 = &_5;
+	} else {
+		_4 = &_2;
+	}
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 651);
+	if (Z_TYPE_P(_4) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
+		{
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _6);
+			ZEPHIR_CALL_CE_STATIC(&_7$$4, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 648);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_10 = 1;
+		while (1) {
+			if (_10) {
+				_10 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _4, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_9, _4, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_9)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowBuffer, _4, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_CALL_CE_STATIC(&_11$$5, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
+				zephir_check_call_status();
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 648);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&rowBuffer);
+	RETURN_CTOR(&b);
+}
+
+/**
+ * Return each column of the matrix as a TensorBuffer.
+ *
+ * @return \Tensor\TensorBuffer[]
+ */
+PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 {
+	zend_bool _2;
+	zval b;
+	zval i, _0, _1, _5$$4, _6$$4, _7$$4, _8$$4;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _3, _4;
+	zval *this_ptr = getThis();
 
-	RETURN_MEMBER_TYPED(getThis(), "a", IS_ARRAY);
+	ZVAL_UNDEF(&i);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&_8$$4);
+	ZVAL_UNDEF(&b);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		array_init(return_value);
+		RETURN_MM();
+	}
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	_4 = (zephir_get_numberval(&_1) - 1);
+	_3 = 0;
+	_2 = 0;
+	if (_3 <= _4) {
+		while (1) {
+			if (_2) {
+				_3++;
+				if (!(_3 <= _4)) {
+					break;
+				}
+			} else {
+				_2 = 1;
+			}
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _3);
+			zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 670);
+		}
+	}
+	RETURN_CTOR(&b);
 }
 
 /**
- * Return each row of the matrix as a TensorBuffer.
+ * Return the columns of the matrix as an array of ColumnVector objects.
  *
- * @return \Tensor\TensorBuffer[]
+ * @return \Tensor\ColumnVector[]
  */
-PHP_METHOD(Tensor_Matrix, asRowBuffers)
+PHP_METHOD(Tensor_Matrix, asColumnVectors)
 {
-	zend_bool _7;
+	zend_bool _8;
 	zval b;
-	zval row, buffer, _0, *_1, _2, *_3, _6, _4$$3, _8$$4;
+	zval columnBuffer, _0, _1, *_2, _3, *_4, _7, _5$$4, _9$$5;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_5 = NULL;
+	zephir_fcall_cache_entry *_6 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&row);
-	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&columnBuffer);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_8$$4);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_9$$5);
 	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		array_init(return_value);
+		RETURN_MM();
+	}
+	ZEPHIR_CALL_METHOD(&_1, this_ptr, "asColumnBuffers", NULL, 0);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_3);
+		zephir_string_to_char_array(&_3, &_1);
+		_2 = &_3;
 	} else {
-		_1 = &_0;
+		_2 = &_1;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 563);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 695);
+	if (Z_TYPE_P(_2) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
-			ZEPHIR_INIT_NVAR(&row);
-			ZVAL_COPY(&row, _3);
-			ZEPHIR_INIT_NVAR(&buffer);
-			tensor_buffer_from_array(&buffer, &row);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			object_init_ex(&_4$$3, tensor_tensorbuffer_ce);
-			ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", &_5, 14, &buffer);
+			ZEPHIR_INIT_NVAR(&columnBuffer);
+			ZVAL_COPY(&columnBuffer, _4);
+			ZEPHIR_CALL_CE_STATIC(&_5$$4, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 560);
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 692);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_7 = 1;
+		_8 = 1;
 		while (1) {
-			if (_7) {
-				_7 = 0;
+			if (_8) {
+				_8 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _2, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_7, _2, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
+			if (!zend_is_true(&_7)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&row, _1, "current", NULL, 0);
+			ZEPHIR_CALL_METHOD(&columnBuffer, _2, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&buffer);
-				tensor_buffer_from_array(&buffer, &row);
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				object_init_ex(&_8$$4, tensor_tensorbuffer_ce);
-				ZEPHIR_CALL_METHOD(NULL, &_8$$4, "__construct", &_5, 14, &buffer);
+				ZEPHIR_CALL_CE_STATIC(&_9$$5, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 560);
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 692);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&row);
+	ZEPHIR_INIT_NVAR(&columnBuffer);
 	RETURN_CTOR(&b);
 }
 
 /**
- * Return each row as a vector in an array.
+ * Return the rows of the matrix as an array of Vector objects.
  *
  * @return \Tensor\Vector[]
  */
 PHP_METHOD(Tensor_Matrix, asVectors)
 {
-	zval _1, _2;
-	zval _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
-	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&_0);
-	zephir_create_array(&_0, 2, 0);
-	ZEPHIR_INIT_VAR(&_1);
-	ZVAL_STRING(&_1, "Tensor\\Vector");
-	zephir_array_fast_append(&_0, &_1);
-	ZEPHIR_INIT_NVAR(&_1);
-	ZVAL_STRING(&_1, "quick");
-	zephir_array_fast_append(&_0, &_1);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_FUNCTION("array_map", NULL, 15, &_0, &_2);
+	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "asRowVectors", NULL, 0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
 
 /**
- * Return each column as a column vector in an array.
- *
- * @return \Tensor\ColumnVector[]
- */
-PHP_METHOD(Tensor_Matrix, asColumnVectors)
-{
-	zend_bool _1;
-	zval _0, _4$$3, _5$$3;
-	zval vectors;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_6 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0, _2, _3;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&vectors);
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("n", 1, 1);
-	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
-	ZEPHIR_INIT_VAR(&vectors);
-	array_init(&vectors);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	_3 = (zephir_get_numberval(&_0) - 1);
-	_2 = 0;
-	_1 = 0;
-	if (_2 <= _3) {
-		while (1) {
-			if (_1) {
-				_2++;
-				if (!(_2 <= _3)) {
-					break;
-				}
-			} else {
-				_1 = 1;
-			}
-			i = _2;
-			ZVAL_LONG(&_5$$3, i);
-			ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "columnAsVector", &_6, 0, &_5$$3);
-			zephir_check_call_status();
-			zephir_array_append(&vectors, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 588);
-		}
-	}
-	RETURN_CTOR(&vectors);
-}
-
-/**
- * Flatten i.e unravel the matrix into a vector.
+ * Return the elements of the matrix as a vector taken in row-major order.
  *
  * @return \Tensor\Vector
  */
 PHP_METHOD(Tensor_Matrix, flatten)
 {
-	zval _0, _1, _2;
+	zval _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -1835,13 +2345,8 @@ PHP_METHOD(Tensor_Matrix, flatten)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&_0);
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_INIT_VAR(&_2);
-	ZVAL_STRING(&_2, "array_merge");
-	ZEPHIR_CALL_USER_FUNC_ARRAY(&_0, &_2, &_1);
-	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "quick", NULL, 0, &_0);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1856,26 +2361,28 @@ PHP_METHOD(Tensor_Matrix, flatten)
  */
 PHP_METHOD(Tensor_Matrix, map)
 {
-	zend_bool _7;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_5 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *callback, callback_sub, rowA, _0, *_1, _2, *_3, _6, _4$$3, _8$$4;
+	zval *callback, callback_sub, _0, _1, _2, _3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&callback_sub);
-	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(callback)
@@ -1883,51 +2390,12 @@ PHP_METHOD(Tensor_Matrix, map)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &callback);
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 622);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_CALL_FUNCTION(&_4$$3, "array_map", &_5, 15, callback, &rowA);
-			zephir_check_call_status();
-			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 619);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_CALL_FUNCTION(&_8$$4, "array_map", &_5, 15, callback, &rowA);
-				zephir_check_call_status();
-				zephir_array_append(&b, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 619);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "map", NULL, 0, callback);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_1, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1943,32 +2411,38 @@ PHP_METHOD(Tensor_Matrix, map)
  */
 PHP_METHOD(Tensor_Matrix, reduce)
 {
-	zend_bool _12, _9$$3, _18$$6;
+	zend_bool _14, _11$$3, _20$$6;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	double initial;
-	zval *callback, callback_sub, *initial_param = NULL, rowA, valueA, carry, _0, *_1, _2, *_3, _11, *_4$$3, _5$$3, *_6$$3, _8$$3, _7$$4, _10$$5, *_13$$6, _14$$6, *_15$$6, _17$$6, _16$$7, _19$$8;
+	zval *callback, callback_sub, *initial_param = NULL, rowBuffer, valueA, carry, _0, _1, _2, *_3, _4, *_5, _13, *_6$$3, _7$$3, *_8$$3, _10$$3, _9$$4, _12$$5, *_15$$6, _16$$6, *_17$$6, _19$$6, _18$$7, _21$$8;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&callback_sub);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&carry);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$3);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_14$$6);
-	ZVAL_UNDEF(&_17$$6);
-	ZVAL_UNDEF(&_16$$7);
-	ZVAL_UNDEF(&_19$$8);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&_7$$3);
+	ZVAL_UNDEF(&_10$$3);
+	ZVAL_UNDEF(&_9$$4);
+	ZVAL_UNDEF(&_12$$5);
+	ZVAL_UNDEF(&_16$$6);
+	ZVAL_UNDEF(&_19$$6);
+	ZVAL_UNDEF(&_18$$7);
+	ZVAL_UNDEF(&_21$$8);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		Z_PARAM_ZVAL(callback)
@@ -1986,123 +2460,126 @@ PHP_METHOD(Tensor_Matrix, reduce)
 	ZEPHIR_INIT_VAR(&carry);
 	ZVAL_DOUBLE(&carry, initial);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
 	} else {
-		_1 = &_0;
+		_3 = &_1;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 646);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 752);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_5$$3);
-				zephir_string_to_char_array(&_5$$3, &rowA);
-				_4$$3 = &_5$$3;
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _5);
+			if (Z_TYPE_P(&rowBuffer) == IS_STRING) {
+				ZEPHIR_INIT_NVAR(&_7$$3);
+				zephir_string_to_char_array(&_7$$3, &rowBuffer);
+				_6$$3 = &_7$$3;
 			} else {
-				_4$$3 = &rowA;
+				_6$$3 = &rowBuffer;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 644);
-			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
+			zephir_is_iterable(_6$$3, 0, "tensor/matrix.zep", 750);
+			if (Z_TYPE_P(_6$$3) == IS_ARRAY) {
+				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6$$3), _8$$3)
 				{
 					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _6$$3);
-					ZEPHIR_CALL_ZVAL_FUNCTION(&_7$$4, callback, NULL, 0, &carry, &valueA);
+					ZVAL_COPY(&valueA, _8$$3);
+					ZEPHIR_CALL_ZVAL_FUNCTION(&_9$$4, callback, NULL, 0, &carry, &valueA);
 					zephir_check_call_status();
-					ZEPHIR_CPY_WRT(&carry, &_7$$4);
+					ZEPHIR_CPY_WRT(&carry, &_9$$4);
 				} ZEND_HASH_FOREACH_END();
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _6$$3, "rewind", NULL, 0);
 				zephir_check_call_status();
-				_9$$3 = 1;
+				_11$$3 = 1;
 				while (1) {
-					if (_9$$3) {
-						_9$$3 = 0;
+					if (_11$$3) {
+						_11$$3 = 0;
 					} else {
-						ZEPHIR_CALL_METHOD(NULL, _4$$3, "next", NULL, 0);
+						ZEPHIR_CALL_METHOD(NULL, _6$$3, "next", NULL, 0);
 						zephir_check_call_status();
 					}
-					ZEPHIR_CALL_METHOD(&_8$$3, _4$$3, "valid", NULL, 0);
+					ZEPHIR_CALL_METHOD(&_10$$3, _6$$3, "valid", NULL, 0);
 					zephir_check_call_status();
-					if (!zend_is_true(&_8$$3)) {
+					if (!zend_is_true(&_10$$3)) {
 						break;
 					}
-					ZEPHIR_CALL_METHOD(&valueA, _4$$3, "current", NULL, 0);
+					ZEPHIR_CALL_METHOD(&valueA, _6$$3, "current", NULL, 0);
 					zephir_check_call_status();
-						ZEPHIR_CALL_ZVAL_FUNCTION(&_10$$5, callback, NULL, 0, &carry, &valueA);
+						ZEPHIR_CALL_ZVAL_FUNCTION(&_12$$5, callback, NULL, 0, &carry, &valueA);
 						zephir_check_call_status();
-						ZEPHIR_CPY_WRT(&carry, &_10$$5);
+						ZEPHIR_CPY_WRT(&carry, &_12$$5);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_12 = 1;
+		_14 = 1;
 		while (1) {
-			if (_12) {
-				_12 = 0;
+			if (_14) {
+				_14 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_11, _1, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_13, _3, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_11)) {
+			if (!zend_is_true(&_13)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
+			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
 			zephir_check_call_status();
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_14$$6);
-					zephir_string_to_char_array(&_14$$6, &rowA);
-					_13$$6 = &_14$$6;
+				if (Z_TYPE_P(&rowBuffer) == IS_STRING) {
+					ZEPHIR_INIT_NVAR(&_16$$6);
+					zephir_string_to_char_array(&_16$$6, &rowBuffer);
+					_15$$6 = &_16$$6;
 				} else {
-					_13$$6 = &rowA;
+					_15$$6 = &rowBuffer;
 				}
-				zephir_is_iterable(_13$$6, 0, "tensor/matrix.zep", 644);
-				if (Z_TYPE_P(_13$$6) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_13$$6), _15$$6)
+				zephir_is_iterable(_15$$6, 0, "tensor/matrix.zep", 750);
+				if (Z_TYPE_P(_15$$6) == IS_ARRAY) {
+					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$6), _17$$6)
 					{
 						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _15$$6);
-						ZEPHIR_CALL_ZVAL_FUNCTION(&_16$$7, callback, NULL, 0, &carry, &valueA);
+						ZVAL_COPY(&valueA, _17$$6);
+						ZEPHIR_CALL_ZVAL_FUNCTION(&_18$$7, callback, NULL, 0, &carry, &valueA);
 						zephir_check_call_status();
-						ZEPHIR_CPY_WRT(&carry, &_16$$7);
+						ZEPHIR_CPY_WRT(&carry, &_18$$7);
 					} ZEND_HASH_FOREACH_END();
 				} else {
-					ZEPHIR_CALL_METHOD(NULL, _13$$6, "rewind", NULL, 0);
+					ZEPHIR_CALL_METHOD(NULL, _15$$6, "rewind", NULL, 0);
 					zephir_check_call_status();
-					_18$$6 = 1;
+					_20$$6 = 1;
 					while (1) {
-						if (_18$$6) {
-							_18$$6 = 0;
+						if (_20$$6) {
+							_20$$6 = 0;
 						} else {
-							ZEPHIR_CALL_METHOD(NULL, _13$$6, "next", NULL, 0);
+							ZEPHIR_CALL_METHOD(NULL, _15$$6, "next", NULL, 0);
 							zephir_check_call_status();
 						}
-						ZEPHIR_CALL_METHOD(&_17$$6, _13$$6, "valid", NULL, 0);
+						ZEPHIR_CALL_METHOD(&_19$$6, _15$$6, "valid", NULL, 0);
 						zephir_check_call_status();
-						if (!zend_is_true(&_17$$6)) {
+						if (!zend_is_true(&_19$$6)) {
 							break;
 						}
-						ZEPHIR_CALL_METHOD(&valueA, _13$$6, "current", NULL, 0);
+						ZEPHIR_CALL_METHOD(&valueA, _15$$6, "current", NULL, 0);
 						zephir_check_call_status();
-							ZEPHIR_CALL_ZVAL_FUNCTION(&_19$$8, callback, NULL, 0, &carry, &valueA);
+							ZEPHIR_CALL_ZVAL_FUNCTION(&_21$$8, callback, NULL, 0, &carry, &valueA);
 							zephir_check_call_status();
-							ZEPHIR_CPY_WRT(&carry, &_19$$8);
+							ZEPHIR_CPY_WRT(&carry, &_21$$8);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
+	ZEPHIR_INIT_NVAR(&rowBuffer);
 	RETURN_CCTOR(&carry);
 }
 
@@ -2158,7 +2635,7 @@ PHP_METHOD(Tensor_Matrix, transpose)
 			ZVAL_LONG(&_5$$3, i);
 			ZEPHIR_CALL_FUNCTION(&_6$$3, "array_column", &_7, 28, &_4$$3, &_5$$3);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 661);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 767);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
@@ -2209,7 +2686,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 677);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 783);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2222,7 +2699,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 29, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 682);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 788);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2236,7 +2713,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_9$$5, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_8$$5, "__construct", NULL, 29, &_9$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_8$$5, "tensor/matrix.zep", 689);
+		zephir_throw_exception_debug(&_8$$5, "tensor/matrix.zep", 795);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2279,7 +2756,7 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		ZEPHIR_CONCAT_SS(&_2$$3, "Failed to compute the pseudoinverse", " of the matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 29, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 706);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 812);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2326,7 +2803,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 722);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 828);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2412,7 +2889,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 	ZEPHIR_CPY_WRT(&a, &_3);
 	pivots = 0;
 	epsilon =  (0.00000001);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 777);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 883);
 	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _4)
 	{
 		ZEPHIR_INIT_NVAR(&rowA);
@@ -2425,7 +2902,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 		} else {
 			_5$$3 = &rowA;
 		}
-		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 775);
+		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 881);
 		if (Z_TYPE_P(_5$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$3), _7$$3)
 			{
@@ -2562,7 +3039,7 @@ PHP_METHOD(Tensor_Matrix, symmetric)
 			i = _3;
 			zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&rowA);
-			zephir_array_fetch_long(&rowA, &_5$$4, i, PH_NOISY, "tensor/matrix.zep", 806);
+			zephir_array_fetch_long(&rowA, &_5$$4, i, PH_NOISY, "tensor/matrix.zep", 912);
 			zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 			_9$$4 = (zephir_get_numberval(&_6$$4) - 1);
 			_8$$4 = (i + 1);
@@ -2579,12 +3056,12 @@ PHP_METHOD(Tensor_Matrix, symmetric)
 					}
 					j = _8$$4;
 					ZEPHIR_OBS_NVAR(&_10$$5);
-					zephir_array_fetch_long(&_10$$5, &rowA, j, PH_NOISY, "tensor/matrix.zep", 809);
+					zephir_array_fetch_long(&_10$$5, &rowA, j, PH_NOISY, "tensor/matrix.zep", 915);
 					zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 					ZEPHIR_OBS_NVAR(&_12$$5);
-					zephir_array_fetch_long(&_12$$5, &_11$$5, j, PH_NOISY, "tensor/matrix.zep", 809);
+					zephir_array_fetch_long(&_12$$5, &_11$$5, j, PH_NOISY, "tensor/matrix.zep", 915);
 					ZEPHIR_OBS_NVAR(&_13$$5);
-					zephir_array_fetch_long(&_13$$5, &_12$$5, i, PH_NOISY, "tensor/matrix.zep", 809);
+					zephir_array_fetch_long(&_13$$5, &_12$$5, i, PH_NOISY, "tensor/matrix.zep", 915);
 					if (!ZEPHIR_IS_EQUAL(&_10$$5, &_13$$5)) {
 						RETURN_MM_BOOL(0);
 					}
@@ -2653,7 +3130,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_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/matrix.zep", 830);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 936);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2721,7 +3198,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements 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", 848);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 954);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2809,7 +3286,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 3, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 866);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 972);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2823,7 +3300,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 3, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 871);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 977);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3140,7 +3617,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1010);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1116);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3211,7 +3688,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1043);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1149);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3283,7 +3760,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1077);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1183);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3355,7 +3832,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1111);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1217);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3427,7 +3904,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1145);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1251);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3499,7 +3976,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1179);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1285);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3571,7 +4048,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1213);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1319);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3643,7 +4120,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1247);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1353);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3715,7 +4192,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1281);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1387);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3787,7 +4264,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1315);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1421);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3859,7 +4336,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1349);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1455);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3931,7 +4408,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1383);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1489);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4154,7 +4631,7 @@ PHP_METHOD(Tensor_Matrix, log)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 1474);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 1580);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -4169,7 +4646,7 @@ PHP_METHOD(Tensor_Matrix, log)
 			} else {
 				_5$$4 = &rowA;
 			}
-			zephir_is_iterable(_5$$4, 0, "tensor/matrix.zep", 1471);
+			zephir_is_iterable(_5$$4, 0, "tensor/matrix.zep", 1577);
 			if (Z_TYPE_P(_5$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$4), _7$$4)
 				{
@@ -4178,7 +4655,7 @@ PHP_METHOD(Tensor_Matrix, log)
 					ZVAL_DOUBLE(&_8$$5, base);
 					ZEPHIR_CALL_FUNCTION(&_9$$5, "log", &_10, 8, &valueA, &_8$$5);
 					zephir_check_call_status();
-					zephir_array_append(&rowB, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 1468);
+					zephir_array_append(&rowB, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 1574);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _5$$4, "rewind", NULL, 0);
@@ -4201,11 +4678,11 @@ PHP_METHOD(Tensor_Matrix, log)
 						ZVAL_DOUBLE(&_13$$6, base);
 						ZEPHIR_CALL_FUNCTION(&_14$$6, "log", &_10, 8, &valueA, &_13$$6);
 						zephir_check_call_status();
-						zephir_array_append(&rowB, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 1468);
+						zephir_array_append(&rowB, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 1574);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1471);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1577);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -4234,7 +4711,7 @@ PHP_METHOD(Tensor_Matrix, log)
 				} else {
 					_17$$7 = &rowA;
 				}
-				zephir_is_iterable(_17$$7, 0, "tensor/matrix.zep", 1471);
+				zephir_is_iterable(_17$$7, 0, "tensor/matrix.zep", 1577);
 				if (Z_TYPE_P(_17$$7) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$7), _19$$7)
 					{
@@ -4243,7 +4720,7 @@ PHP_METHOD(Tensor_Matrix, log)
 						ZVAL_DOUBLE(&_20$$8, base);
 						ZEPHIR_CALL_FUNCTION(&_21$$8, "log", &_10, 8, &valueA, &_20$$8);
 						zephir_check_call_status();
-						zephir_array_append(&rowB, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 1468);
+						zephir_array_append(&rowB, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 1574);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _17$$7, "rewind", NULL, 0);
@@ -4266,11 +4743,11 @@ PHP_METHOD(Tensor_Matrix, log)
 							ZVAL_DOUBLE(&_24$$9, base);
 							ZEPHIR_CALL_FUNCTION(&_25$$9, "log", &_10, 8, &valueA, &_24$$9);
 							zephir_check_call_status();
-							zephir_array_append(&rowB, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 1468);
+							zephir_array_append(&rowB, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 1574);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1471);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1577);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -4701,7 +5178,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_4 = &_3;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 1643);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 1749);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -4713,18 +5190,18 @@ PHP_METHOD(Tensor_Matrix, median)
 			zephir_check_call_status();
 			if (odd) {
 				ZEPHIR_OBS_NVAR(&median);
-				zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1635);
+				zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1741);
 			} else {
 				ZEPHIR_OBS_NVAR(&_8$$5);
-				zephir_array_fetch_long(&_8$$5, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1637);
+				zephir_array_fetch_long(&_8$$5, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1743);
 				ZEPHIR_OBS_NVAR(&_9$$5);
-				zephir_array_fetch_long(&_9$$5, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1637);
+				zephir_array_fetch_long(&_9$$5, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1743);
 				ZEPHIR_INIT_NVAR(&_10$$5);
 				zephir_add_function(&_10$$5, &_8$$5, &_9$$5);
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_10$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1640);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1746);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -4750,18 +5227,18 @@ PHP_METHOD(Tensor_Matrix, median)
 				zephir_check_call_status();
 				if (odd) {
 					ZEPHIR_OBS_NVAR(&median);
-					zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1635);
+					zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1741);
 				} else {
 					ZEPHIR_OBS_NVAR(&_13$$8);
-					zephir_array_fetch_long(&_13$$8, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1637);
+					zephir_array_fetch_long(&_13$$8, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1743);
 					ZEPHIR_OBS_NVAR(&_14$$8);
-					zephir_array_fetch_long(&_14$$8, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1637);
+					zephir_array_fetch_long(&_14$$8, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1743);
 					ZEPHIR_INIT_NVAR(&_15$$8);
 					zephir_add_function(&_15$$8, &_13$$8, &_14$$8);
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_15$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1640);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1746);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -4842,7 +5319,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1657);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1763);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4860,7 +5337,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 1685);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 1791);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_7), _9)
 		{
@@ -4874,20 +5351,20 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			if (ZEPHIR_LE_LONG(&_11$$4, xHat)) {
 				ZEPHIR_OBS_NVAR(&_12$$5);
 				zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-				zephir_array_fetch_long(&_12$$5, &rowA, (zephir_get_numberval(&_13$$5) - 1), PH_NOISY, "tensor/matrix.zep", 1675);
+				zephir_array_fetch_long(&_12$$5, &rowA, (zephir_get_numberval(&_13$$5) - 1), PH_NOISY, "tensor/matrix.zep", 1781);
 				ZEPHIR_INIT_NVAR(&_14$$5);
 				ZVAL_DOUBLE(&_14$$5, zephir_get_doubleval(&_12$$5));
-				zephir_array_append(&b, &_14$$5, PH_SEPARATE, "tensor/matrix.zep", 1675);
+				zephir_array_append(&b, &_14$$5, PH_SEPARATE, "tensor/matrix.zep", 1781);
 				continue;
 			}
 			ZEPHIR_OBS_NVAR(&_15$$4);
-			zephir_array_fetch_long(&_15$$4, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1680);
+			zephir_array_fetch_long(&_15$$4, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1786);
 			t =  (zephir_get_doubleval(&_15$$4));
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch_long(&_16$$4, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1682);
+			zephir_array_fetch_long(&_16$$4, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1788);
 			ZEPHIR_INIT_NVAR(&_17$$4);
 			ZVAL_DOUBLE(&_17$$4, (t + (remainder * (zephir_get_numberval(&_16$$4) - t))));
-			zephir_array_append(&b, &_17$$4, PH_SEPARATE, "tensor/matrix.zep", 1682);
+			zephir_array_append(&b, &_17$$4, PH_SEPARATE, "tensor/matrix.zep", 1788);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -4915,20 +5392,20 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				if (ZEPHIR_LE_LONG(&_20$$6, xHat)) {
 					ZEPHIR_OBS_NVAR(&_21$$7);
 					zephir_read_property_cached(&_22$$7, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-					zephir_array_fetch_long(&_21$$7, &rowA, (zephir_get_numberval(&_22$$7) - 1), PH_NOISY, "tensor/matrix.zep", 1675);
+					zephir_array_fetch_long(&_21$$7, &rowA, (zephir_get_numberval(&_22$$7) - 1), PH_NOISY, "tensor/matrix.zep", 1781);
 					ZEPHIR_INIT_NVAR(&_23$$7);
 					ZVAL_DOUBLE(&_23$$7, zephir_get_doubleval(&_21$$7));
-					zephir_array_append(&b, &_23$$7, PH_SEPARATE, "tensor/matrix.zep", 1675);
+					zephir_array_append(&b, &_23$$7, PH_SEPARATE, "tensor/matrix.zep", 1781);
 					continue;
 				}
 				ZEPHIR_OBS_NVAR(&_24$$6);
-				zephir_array_fetch_long(&_24$$6, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1680);
+				zephir_array_fetch_long(&_24$$6, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1786);
 				t =  (zephir_get_doubleval(&_24$$6));
 				ZEPHIR_OBS_NVAR(&_25$$6);
-				zephir_array_fetch_long(&_25$$6, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1682);
+				zephir_array_fetch_long(&_25$$6, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1788);
 				ZEPHIR_INIT_NVAR(&_26$$6);
 				ZVAL_DOUBLE(&_26$$6, (t + (remainder * (zephir_get_numberval(&_25$$6) - t))));
-				zephir_array_append(&b, &_26$$6, PH_SEPARATE, "tensor/matrix.zep", 1682);
+				zephir_array_append(&b, &_26$$6, PH_SEPARATE, "tensor/matrix.zep", 1788);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5003,7 +5480,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1701);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1807);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5023,7 +5500,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 3, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1707);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1813);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5112,7 +5589,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 3, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1732);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1838);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5204,7 +5681,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_4$$4, "Decimal precision cannot", " be less than 0, ", &_3$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_4$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$4, "tensor/matrix.zep", 1758);
+		zephir_throw_exception_debug(&_1$$4, "tensor/matrix.zep", 1864);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5220,7 +5697,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_6 = &_5;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1776);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1882);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5235,7 +5712,7 @@ PHP_METHOD(Tensor_Matrix, round)
 			} else {
 				_9$$5 = &rowA;
 			}
-			zephir_is_iterable(_9$$5, 0, "tensor/matrix.zep", 1773);
+			zephir_is_iterable(_9$$5, 0, "tensor/matrix.zep", 1879);
 			if (Z_TYPE_P(_9$$5) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9$$5), _11$$5)
 				{
@@ -5244,7 +5721,7 @@ PHP_METHOD(Tensor_Matrix, round)
 					ZEPHIR_INIT_NVAR(&_12$$6);
 					ZVAL_LONG(&_13$$6, precision);
 					zephir_round(&_12$$6, &valueA, &_13$$6, NULL);
-					zephir_array_append(&rowB, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 1770);
+					zephir_array_append(&rowB, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 1876);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9$$5, "rewind", NULL, 0);
@@ -5267,11 +5744,11 @@ PHP_METHOD(Tensor_Matrix, round)
 						ZEPHIR_INIT_NVAR(&_16$$7);
 						ZVAL_LONG(&_17$$7, precision);
 						zephir_round(&_16$$7, &valueA, &_17$$7, NULL);
-						zephir_array_append(&rowB, &_16$$7, PH_SEPARATE, "tensor/matrix.zep", 1770);
+						zephir_array_append(&rowB, &_16$$7, PH_SEPARATE, "tensor/matrix.zep", 1876);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1773);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1879);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5300,7 +5777,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				} else {
 					_20$$8 = &rowA;
 				}
-				zephir_is_iterable(_20$$8, 0, "tensor/matrix.zep", 1773);
+				zephir_is_iterable(_20$$8, 0, "tensor/matrix.zep", 1879);
 				if (Z_TYPE_P(_20$$8) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_20$$8), _22$$8)
 					{
@@ -5309,7 +5786,7 @@ PHP_METHOD(Tensor_Matrix, round)
 						ZEPHIR_INIT_NVAR(&_23$$9);
 						ZVAL_LONG(&_24$$9, precision);
 						zephir_round(&_23$$9, &valueA, &_24$$9, NULL);
-						zephir_array_append(&rowB, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 1770);
+						zephir_array_append(&rowB, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 1876);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _20$$8, "rewind", NULL, 0);
@@ -5332,11 +5809,11 @@ PHP_METHOD(Tensor_Matrix, round)
 							ZEPHIR_INIT_NVAR(&_27$$10);
 							ZVAL_LONG(&_28$$10, precision);
 							zephir_round(&_27$$10, &valueA, &_28$$10, NULL);
-							zephir_array_append(&rowB, &_27$$10, PH_SEPARATE, "tensor/matrix.zep", 1770);
+							zephir_array_append(&rowB, &_27$$10, PH_SEPARATE, "tensor/matrix.zep", 1876);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1773);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1879);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5453,7 +5930,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1812);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1918);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5469,7 +5946,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 	} else {
 		_3 = &_2;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1842);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1948);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5484,7 +5961,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 			} else {
 				_6$$4 = &rowA;
 			}
-			zephir_is_iterable(_6$$4, 0, "tensor/matrix.zep", 1839);
+			zephir_is_iterable(_6$$4, 0, "tensor/matrix.zep", 1945);
 			if (Z_TYPE_P(_6$$4) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6$$4), _8$$4)
 				{
@@ -5493,16 +5970,16 @@ PHP_METHOD(Tensor_Matrix, clip)
 					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 						ZEPHIR_INIT_NVAR(&_9$$6);
 						ZVAL_DOUBLE(&_9$$6, max);
-						zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/matrix.zep", 1825);
+						zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/matrix.zep", 1931);
 						continue;
 					}
 					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 						ZEPHIR_INIT_NVAR(&_10$$7);
 						ZVAL_DOUBLE(&_10$$7, min);
-						zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1831);
+						zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1937);
 						continue;
 					}
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1836);
+					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1942);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _6$$4, "rewind", NULL, 0);
@@ -5525,20 +6002,20 @@ PHP_METHOD(Tensor_Matrix, clip)
 						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 							ZEPHIR_INIT_NVAR(&_13$$9);
 							ZVAL_DOUBLE(&_13$$9, max);
-							zephir_array_append(&rowB, &_13$$9, PH_SEPARATE, "tensor/matrix.zep", 1825);
+							zephir_array_append(&rowB, &_13$$9, PH_SEPARATE, "tensor/matrix.zep", 1931);
 							continue;
 						}
 						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 							ZEPHIR_INIT_NVAR(&_14$$10);
 							ZVAL_DOUBLE(&_14$$10, min);
-							zephir_array_append(&rowB, &_14$$10, PH_SEPARATE, "tensor/matrix.zep", 1831);
+							zephir_array_append(&rowB, &_14$$10, PH_SEPARATE, "tensor/matrix.zep", 1937);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1836);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1942);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1839);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1945);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5567,7 +6044,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 				} else {
 					_17$$11 = &rowA;
 				}
-				zephir_is_iterable(_17$$11, 0, "tensor/matrix.zep", 1839);
+				zephir_is_iterable(_17$$11, 0, "tensor/matrix.zep", 1945);
 				if (Z_TYPE_P(_17$$11) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$11), _19$$11)
 					{
@@ -5576,16 +6053,16 @@ PHP_METHOD(Tensor_Matrix, clip)
 						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 							ZEPHIR_INIT_NVAR(&_20$$13);
 							ZVAL_DOUBLE(&_20$$13, max);
-							zephir_array_append(&rowB, &_20$$13, PH_SEPARATE, "tensor/matrix.zep", 1825);
+							zephir_array_append(&rowB, &_20$$13, PH_SEPARATE, "tensor/matrix.zep", 1931);
 							continue;
 						}
 						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 							ZEPHIR_INIT_NVAR(&_21$$14);
 							ZVAL_DOUBLE(&_21$$14, min);
-							zephir_array_append(&rowB, &_21$$14, PH_SEPARATE, "tensor/matrix.zep", 1831);
+							zephir_array_append(&rowB, &_21$$14, PH_SEPARATE, "tensor/matrix.zep", 1937);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1836);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1942);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _17$$11, "rewind", NULL, 0);
@@ -5608,20 +6085,20 @@ PHP_METHOD(Tensor_Matrix, clip)
 							if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 								ZEPHIR_INIT_NVAR(&_24$$16);
 								ZVAL_DOUBLE(&_24$$16, max);
-								zephir_array_append(&rowB, &_24$$16, PH_SEPARATE, "tensor/matrix.zep", 1825);
+								zephir_array_append(&rowB, &_24$$16, PH_SEPARATE, "tensor/matrix.zep", 1931);
 								continue;
 							}
 							if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 								ZEPHIR_INIT_NVAR(&_25$$17);
 								ZVAL_DOUBLE(&_25$$17, min);
-								zephir_array_append(&rowB, &_25$$17, PH_SEPARATE, "tensor/matrix.zep", 1831);
+								zephir_array_append(&rowB, &_25$$17, PH_SEPARATE, "tensor/matrix.zep", 1937);
 								continue;
 							}
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1836);
+							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1942);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1839);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1945);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5685,7 +6162,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1874);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1980);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -5700,7 +6177,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 			} else {
 				_4$$3 = &rowA;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1871);
+			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1977);
 			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
 				{
@@ -5709,10 +6186,10 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 						ZEPHIR_INIT_NVAR(&_7$$5);
 						ZVAL_DOUBLE(&_7$$5, min);
-						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1863);
+						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1969);
 						continue;
 					}
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1868);
+					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1974);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
@@ -5735,14 +6212,14 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 							ZEPHIR_INIT_NVAR(&_10$$7);
 							ZVAL_DOUBLE(&_10$$7, min);
-							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1863);
+							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1969);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1868);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1974);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1871);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1977);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -5771,7 +6248,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 				} else {
 					_13$$8 = &rowA;
 				}
-				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 1871);
+				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 1977);
 				if (Z_TYPE_P(_13$$8) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_13$$8), _15$$8)
 					{
@@ -5780,10 +6257,10 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 							ZEPHIR_INIT_NVAR(&_16$$10);
 							ZVAL_DOUBLE(&_16$$10, min);
-							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 1863);
+							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 1969);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1868);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1974);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _13$$8, "rewind", NULL, 0);
@@ -5806,14 +6283,14 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 							if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 								ZEPHIR_INIT_NVAR(&_19$$12);
 								ZVAL_DOUBLE(&_19$$12, min);
-								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 1863);
+								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 1969);
 								continue;
 							}
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1868);
+							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1974);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1871);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1977);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5877,7 +6354,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1906);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 2012);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -5892,7 +6369,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 			} else {
 				_4$$3 = &rowA;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1903);
+			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 2009);
 			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
 				{
@@ -5901,10 +6378,10 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 						ZEPHIR_INIT_NVAR(&_7$$5);
 						ZVAL_DOUBLE(&_7$$5, max);
-						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1895);
+						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 2001);
 						continue;
 					}
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1900);
+					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2006);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
@@ -5927,14 +6404,14 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 							ZEPHIR_INIT_NVAR(&_10$$7);
 							ZVAL_DOUBLE(&_10$$7, max);
-							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1895);
+							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 2001);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1900);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2006);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1903);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2009);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -5963,7 +6440,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 				} else {
 					_13$$8 = &rowA;
 				}
-				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 1903);
+				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 2009);
 				if (Z_TYPE_P(_13$$8) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_13$$8), _15$$8)
 					{
@@ -5972,10 +6449,10 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 							ZEPHIR_INIT_NVAR(&_16$$10);
 							ZVAL_DOUBLE(&_16$$10, max);
-							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 1895);
+							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 2001);
 							continue;
 						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1900);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2006);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _13$$8, "rewind", NULL, 0);
@@ -5998,14 +6475,14 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 							if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 								ZEPHIR_INIT_NVAR(&_19$$12);
 								ZVAL_DOUBLE(&_19$$12, max);
-								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 1895);
+								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 2001);
 								continue;
 							}
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1900);
+							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2006);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1903);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2009);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6070,7 +6547,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1937);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 2043);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -6085,7 +6562,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 			} else {
 				_4$$3 = &rowA;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1934);
+			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 2040);
 			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
 				{
@@ -6094,15 +6571,15 @@ PHP_METHOD(Tensor_Matrix, sign)
 					if (ZEPHIR_GT_LONG(&valueA, 0)) {
 						ZEPHIR_INIT_NVAR(&_7$$5);
 						ZVAL_DOUBLE(&_7$$5, 1.0);
-						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1926);
+						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 2032);
 					} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 						ZEPHIR_INIT_NVAR(&_8$$6);
 						ZVAL_DOUBLE(&_8$$6, -1.0);
-						zephir_array_append(&rowB, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 1928);
+						zephir_array_append(&rowB, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 2034);
 					} else {
 						ZEPHIR_INIT_NVAR(&_9$$7);
 						ZVAL_DOUBLE(&_9$$7, 0.0);
-						zephir_array_append(&rowB, &_9$$7, PH_SEPARATE, "tensor/matrix.zep", 1930);
+						zephir_array_append(&rowB, &_9$$7, PH_SEPARATE, "tensor/matrix.zep", 2036);
 					}
 				} ZEND_HASH_FOREACH_END();
 			} else {
@@ -6126,20 +6603,20 @@ PHP_METHOD(Tensor_Matrix, sign)
 						if (ZEPHIR_GT_LONG(&valueA, 0)) {
 							ZEPHIR_INIT_NVAR(&_12$$9);
 							ZVAL_DOUBLE(&_12$$9, 1.0);
-							zephir_array_append(&rowB, &_12$$9, PH_SEPARATE, "tensor/matrix.zep", 1926);
+							zephir_array_append(&rowB, &_12$$9, PH_SEPARATE, "tensor/matrix.zep", 2032);
 						} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 							ZEPHIR_INIT_NVAR(&_13$$10);
 							ZVAL_DOUBLE(&_13$$10, -1.0);
-							zephir_array_append(&rowB, &_13$$10, PH_SEPARATE, "tensor/matrix.zep", 1928);
+							zephir_array_append(&rowB, &_13$$10, PH_SEPARATE, "tensor/matrix.zep", 2034);
 						} else {
 							ZEPHIR_INIT_NVAR(&_14$$11);
 							ZVAL_DOUBLE(&_14$$11, 0.0);
-							zephir_array_append(&rowB, &_14$$11, PH_SEPARATE, "tensor/matrix.zep", 1930);
+							zephir_array_append(&rowB, &_14$$11, PH_SEPARATE, "tensor/matrix.zep", 2036);
 						}
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1934);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2040);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -6168,7 +6645,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 				} else {
 					_17$$12 = &rowA;
 				}
-				zephir_is_iterable(_17$$12, 0, "tensor/matrix.zep", 1934);
+				zephir_is_iterable(_17$$12, 0, "tensor/matrix.zep", 2040);
 				if (Z_TYPE_P(_17$$12) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$12), _19$$12)
 					{
@@ -6177,15 +6654,15 @@ PHP_METHOD(Tensor_Matrix, sign)
 						if (ZEPHIR_GT_LONG(&valueA, 0)) {
 							ZEPHIR_INIT_NVAR(&_20$$14);
 							ZVAL_DOUBLE(&_20$$14, 1.0);
-							zephir_array_append(&rowB, &_20$$14, PH_SEPARATE, "tensor/matrix.zep", 1926);
+							zephir_array_append(&rowB, &_20$$14, PH_SEPARATE, "tensor/matrix.zep", 2032);
 						} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 							ZEPHIR_INIT_NVAR(&_21$$15);
 							ZVAL_DOUBLE(&_21$$15, -1.0);
-							zephir_array_append(&rowB, &_21$$15, PH_SEPARATE, "tensor/matrix.zep", 1928);
+							zephir_array_append(&rowB, &_21$$15, PH_SEPARATE, "tensor/matrix.zep", 2034);
 						} else {
 							ZEPHIR_INIT_NVAR(&_22$$16);
 							ZVAL_DOUBLE(&_22$$16, 0.0);
-							zephir_array_append(&rowB, &_22$$16, PH_SEPARATE, "tensor/matrix.zep", 1930);
+							zephir_array_append(&rowB, &_22$$16, PH_SEPARATE, "tensor/matrix.zep", 2036);
 						}
 					} ZEND_HASH_FOREACH_END();
 				} else {
@@ -6209,20 +6686,20 @@ PHP_METHOD(Tensor_Matrix, sign)
 							if (ZEPHIR_GT_LONG(&valueA, 0)) {
 								ZEPHIR_INIT_NVAR(&_25$$18);
 								ZVAL_DOUBLE(&_25$$18, 1.0);
-								zephir_array_append(&rowB, &_25$$18, PH_SEPARATE, "tensor/matrix.zep", 1926);
+								zephir_array_append(&rowB, &_25$$18, PH_SEPARATE, "tensor/matrix.zep", 2032);
 							} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 								ZEPHIR_INIT_NVAR(&_26$$19);
 								ZVAL_DOUBLE(&_26$$19, -1.0);
-								zephir_array_append(&rowB, &_26$$19, PH_SEPARATE, "tensor/matrix.zep", 1928);
+								zephir_array_append(&rowB, &_26$$19, PH_SEPARATE, "tensor/matrix.zep", 2034);
 							} else {
 								ZEPHIR_INIT_NVAR(&_27$$20);
 								ZVAL_DOUBLE(&_27$$20, 0.0);
-								zephir_array_append(&rowB, &_27$$20, PH_SEPARATE, "tensor/matrix.zep", 1930);
+								zephir_array_append(&rowB, &_27$$20, PH_SEPARATE, "tensor/matrix.zep", 2036);
 							}
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1934);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2040);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6275,7 +6752,7 @@ PHP_METHOD(Tensor_Matrix, negate)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1962);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 2068);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -6290,14 +6767,14 @@ PHP_METHOD(Tensor_Matrix, negate)
 			} else {
 				_4$$3 = &rowA;
 			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1959);
+			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 2065);
 			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
 				{
 					ZEPHIR_INIT_NVAR(&valueA);
 					ZVAL_COPY(&valueA, _6$$3);
 					zephir_negate(&valueA);
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1956);
+					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2062);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
@@ -6318,11 +6795,11 @@ PHP_METHOD(Tensor_Matrix, negate)
 					ZEPHIR_CALL_METHOD(&valueA, _4$$3, "current", NULL, 0);
 					zephir_check_call_status();
 						zephir_negate(&valueA);
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1956);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2062);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1959);
+			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2065);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -6351,14 +6828,14 @@ PHP_METHOD(Tensor_Matrix, negate)
 				} else {
 					_11$$6 = &rowA;
 				}
-				zephir_is_iterable(_11$$6, 0, "tensor/matrix.zep", 1959);
+				zephir_is_iterable(_11$$6, 0, "tensor/matrix.zep", 2065);
 				if (Z_TYPE_P(_11$$6) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_11$$6), _13$$6)
 					{
 						ZEPHIR_INIT_NVAR(&valueA);
 						ZVAL_COPY(&valueA, _13$$6);
 						zephir_negate(&valueA);
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1956);
+						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2062);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _11$$6, "rewind", NULL, 0);
@@ -6379,11 +6856,11 @@ PHP_METHOD(Tensor_Matrix, negate)
 						ZEPHIR_CALL_METHOD(&valueA, _11$$6, "current", NULL, 0);
 						zephir_check_call_status();
 							zephir_negate(&valueA);
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1956);
+							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2062);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1959);
+				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2065);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6461,7 +6938,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", 1977);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2083);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6544,7 +7021,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", 1995);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2101);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6624,7 +7101,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", 2013);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2119);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6706,7 +7183,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", 2031);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2137);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6776,7 +7253,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_1$$3 = &_0$$3;
 		}
-		zephir_is_iterable(_1$$3, 0, "tensor/matrix.zep", 2061);
+		zephir_is_iterable(_1$$3, 0, "tensor/matrix.zep", 2167);
 		if (Z_TYPE_P(_1$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1$$3), _3$$3)
 			{
@@ -6788,14 +7265,14 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					if (!(zephir_fast_count_int(&temp) <= n)) {
 						break;
 					}
-					zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2056);
+					zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2162);
 				}
 				ZEPHIR_INIT_NVAR(&_4$$4);
 				ZEPHIR_INIT_NVAR(&_5$$4);
 				ZVAL_STRING(&_5$$4, "array_merge");
 				ZEPHIR_CALL_USER_FUNC_ARRAY(&_4$$4, &_5$$4, &temp);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/matrix.zep", 2059);
+				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/matrix.zep", 2165);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _1$$3, "rewind", NULL, 0);
@@ -6821,14 +7298,14 @@ PHP_METHOD(Tensor_Matrix, repeat)
 						if (!(zephir_fast_count_int(&temp) <= n)) {
 							break;
 						}
-						zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2056);
+						zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2162);
 					}
 					ZEPHIR_INIT_NVAR(&_8$$6);
 					ZEPHIR_INIT_NVAR(&_9$$6);
 					ZVAL_STRING(&_9$$6, "array_merge");
 					ZEPHIR_CALL_USER_FUNC_ARRAY(&_8$$6, &_9$$6, &temp);
 					zephir_check_call_status();
-					zephir_array_append(&b, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 2059);
+					zephir_array_append(&b, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 2165);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
@@ -6839,7 +7316,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		if (!(zephir_fast_count_int(&temp) <= m)) {
 			break;
 		}
-		zephir_array_append(&temp, &b, PH_SEPARATE, "tensor/matrix.zep", 2066);
+		zephir_array_append(&temp, &b, PH_SEPARATE, "tensor/matrix.zep", 2172);
 	}
 	ZEPHIR_INIT_VAR(&_10);
 	ZEPHIR_INIT_VAR(&_11);
@@ -6914,7 +7391,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2083);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2189);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6929,7 +7406,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2094);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2200);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -6944,9 +7421,9 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2091);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2197);
 			tensor_multiply(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2091);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2197);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -6971,9 +7448,9 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2091);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2197);
 				tensor_multiply(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2091);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2197);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7046,7 +7523,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2108);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2214);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7061,7 +7538,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2119);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2225);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7076,9 +7553,9 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2116);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2222);
 			tensor_divide(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2116);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2222);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7103,9 +7580,9 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2116);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2222);
 				tensor_divide(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2116);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2222);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7178,7 +7655,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2133);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2239);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7193,7 +7670,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2144);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2250);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7208,9 +7685,9 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2141);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2247);
 			tensor_add(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2141);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2247);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7235,9 +7712,9 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2141);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2247);
 				tensor_add(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2141);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2247);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7310,7 +7787,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2158);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2264);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7325,7 +7802,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2169);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2275);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7340,9 +7817,9 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2166);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2272);
 			tensor_subtract(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2166);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2272);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7367,9 +7844,9 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2166);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2272);
 				tensor_subtract(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2166);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2272);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7443,7 +7920,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2184);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2290);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7458,7 +7935,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2195);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2301);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7473,9 +7950,9 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2192);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2298);
 			tensor_pow(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2192);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2298);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7500,9 +7977,9 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2192);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2298);
 				tensor_pow(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2192);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2298);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7576,7 +8053,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2210);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2316);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7591,7 +8068,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2221);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2327);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7606,9 +8083,9 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2218);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2324);
 			tensor_mod(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2218);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2324);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7633,9 +8110,9 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2218);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2324);
 				tensor_mod(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2218);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2324);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7709,7 +8186,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2236);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2342);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7724,7 +8201,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2247);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2353);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7739,9 +8216,9 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2244);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2350);
 			tensor_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2244);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2350);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7766,9 +8243,9 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2244);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2350);
 				tensor_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2244);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2350);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7841,7 +8318,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2261);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2367);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7856,7 +8333,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2272);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2378);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -7871,9 +8348,9 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2269);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2375);
 			tensor_not_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2269);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2375);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -7898,9 +8375,9 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2269);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2375);
 				tensor_not_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2269);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2375);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -7974,7 +8451,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2287);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2393);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7989,7 +8466,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2298);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2404);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -8004,9 +8481,9 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2295);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2401);
 			tensor_greater(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2295);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2401);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -8031,9 +8508,9 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2295);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2401);
 				tensor_greater(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2295);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2401);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -8107,7 +8584,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2313);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2419);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8122,7 +8599,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2324);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2430);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -8137,9 +8614,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2321);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2427);
 			tensor_greater_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2321);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2427);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -8164,9 +8641,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2321);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2427);
 				tensor_greater_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2321);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2427);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -8239,7 +8716,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2338);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2444);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8254,7 +8731,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2349);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2455);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -8269,9 +8746,9 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2346);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2452);
 			tensor_less(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2346);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2452);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -8296,9 +8773,9 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2346);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2452);
 				tensor_less(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2346);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2452);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -8371,7 +8848,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2363);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2469);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8386,7 +8863,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 	} else {
 		_7 = &_6;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2374);
+	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2480);
 	if (Z_TYPE_P(_7) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
 		{
@@ -8401,9 +8878,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2371);
+			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2477);
 			tensor_less_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2371);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2477);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
@@ -8428,9 +8905,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_17$$5);
 				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2371);
+				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2477);
 				tensor_less_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2371);
+				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2477);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -8505,7 +8982,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2389);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2495);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8521,7 +8998,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2402);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2508);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8529,7 +9006,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_multiply(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2399);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2505);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8551,7 +9028,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_multiply(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2399);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2505);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8625,7 +9102,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2417);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2523);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8641,7 +9118,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2430);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2536);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8649,7 +9126,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_divide(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2427);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2533);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8671,7 +9148,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_divide(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2427);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2533);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8745,7 +9222,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2445);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2551);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8761,7 +9238,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2458);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2564);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8769,7 +9246,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_add(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2455);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2561);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8791,7 +9268,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_add(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2455);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2561);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8865,7 +9342,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2473);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2579);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8881,7 +9358,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2486);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2592);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -8889,7 +9366,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_subtract(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2483);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2589);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -8911,7 +9388,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_subtract(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2483);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2589);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -8985,7 +9462,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2501);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2607);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9001,7 +9478,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2514);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2620);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9009,7 +9486,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_pow(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2511);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2617);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9031,7 +9508,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_pow(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2511);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2617);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9105,7 +9582,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2529);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2635);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9121,7 +9598,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2542);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2648);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9129,7 +9606,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_mod(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2539);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2645);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9151,7 +9628,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_mod(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2539);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2645);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9226,7 +9703,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2558);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2664);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9242,7 +9719,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2571);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2677);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9250,7 +9727,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2568);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2674);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9272,7 +9749,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2568);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2674);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9346,7 +9823,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2586);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2692);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9362,7 +9839,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2599);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2705);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9370,7 +9847,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_not_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2596);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2702);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9392,7 +9869,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_not_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2596);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2702);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9466,7 +9943,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2614);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2720);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9482,7 +9959,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2627);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2733);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9490,7 +9967,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_greater(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2624);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2730);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9512,7 +9989,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_greater(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2624);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2730);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9586,7 +10063,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2642);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2748);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9602,7 +10079,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2655);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2761);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9610,7 +10087,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_greater_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2652);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2758);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9632,7 +10109,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_greater_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2652);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2758);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9706,7 +10183,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2670);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2776);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9722,7 +10199,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2683);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2789);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9730,7 +10207,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_less(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2680);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2786);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9752,7 +10229,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_less(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2680);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2786);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9827,7 +10304,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2699);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2805);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9843,7 +10320,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2712);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2818);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -9851,7 +10328,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			ZVAL_COPY(&rowA, _11);
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			tensor_less_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2709);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2815);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9873,7 +10350,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$5);
 				tensor_less_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2709);
+				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2815);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -9953,7 +10430,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2727);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2833);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9968,7 +10445,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2738);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2844);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -9983,9 +10460,9 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2735);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2841);
 			tensor_multiply_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2735);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2841);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10010,9 +10487,9 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2735);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2841);
 				tensor_multiply_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2735);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2841);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10093,7 +10570,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2753);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2859);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10108,7 +10585,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2764);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2870);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10123,9 +10600,9 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2761);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2867);
 			tensor_divide_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2761);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2867);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10150,9 +10627,9 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2761);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2867);
 				tensor_divide_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2761);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2867);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10233,7 +10710,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2779);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2885);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10248,7 +10725,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2790);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2896);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10263,9 +10740,9 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2787);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2893);
 			tensor_add_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2787);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2893);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10290,9 +10767,9 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2787);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2893);
 				tensor_add_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2787);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2893);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10373,7 +10850,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2805);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2911);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10388,7 +10865,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2816);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2922);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10403,9 +10880,9 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2813);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2919);
 			tensor_subtract_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2813);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2919);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10430,9 +10907,9 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2813);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2919);
 				tensor_subtract_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2813);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2919);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10513,7 +10990,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2831);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2937);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10528,7 +11005,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2842);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2948);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10543,9 +11020,9 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2839);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2945);
 			tensor_pow_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2839);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2945);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10570,9 +11047,9 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2839);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2945);
 				tensor_pow_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2839);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2945);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10653,7 +11130,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2857);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2963);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10668,7 +11145,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2868);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2974);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10683,9 +11160,9 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2865);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2971);
 			tensor_mod_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2865);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2971);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10710,9 +11187,9 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2865);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2971);
 				tensor_mod_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2865);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2971);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10793,7 +11270,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2883);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2989);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10808,7 +11285,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2894);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3000);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10823,9 +11300,9 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2891);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2997);
 			tensor_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2891);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2997);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10850,9 +11327,9 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2891);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2997);
 				tensor_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2891);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2997);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10933,7 +11410,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2909);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3015);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10948,7 +11425,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2920);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3026);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10963,9 +11440,9 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2917);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3023);
 			tensor_not_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2917);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3023);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10990,9 +11467,9 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2917);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3023);
 				tensor_not_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2917);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3023);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11073,7 +11550,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2935);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3041);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11088,7 +11565,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2946);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3052);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11103,9 +11580,9 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2943);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3049);
 			tensor_greater_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2943);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3049);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11130,9 +11607,9 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2943);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3049);
 				tensor_greater_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2943);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3049);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11213,7 +11690,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2961);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3067);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11228,7 +11705,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2972);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3078);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11243,9 +11720,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2969);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3075);
 			tensor_greater_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2969);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3075);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11270,9 +11747,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2969);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3075);
 				tensor_greater_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2969);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3075);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11353,7 +11830,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2987);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3093);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11368,7 +11845,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2998);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3104);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11383,9 +11860,9 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2995);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3101);
 			tensor_less_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2995);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3101);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11410,9 +11887,9 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2995);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3101);
 				tensor_less_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2995);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3101);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11493,7 +11970,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3013);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3119);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11508,7 +11985,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3024);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3130);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11523,9 +12000,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3021);
+			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3127);
 			tensor_less_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3021);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3127);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11550,9 +12027,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 				ZEPHIR_INIT_NVAR(&_19$$5);
 				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3021);
+				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3127);
 				tensor_less_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3021);
+				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3127);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11609,7 +12086,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3043);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3149);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11618,7 +12095,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_multiply_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3040);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3146);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11641,7 +12118,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_multiply_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3040);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3146);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11697,7 +12174,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3062);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3168);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11706,7 +12183,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_divide_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3059);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3165);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11729,7 +12206,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_divide_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3059);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3165);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11785,7 +12262,7 @@ PHP_METHOD(Tensor_Matrix, addScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3081);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3187);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11794,7 +12271,7 @@ PHP_METHOD(Tensor_Matrix, addScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_add_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3078);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3184);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11817,7 +12294,7 @@ PHP_METHOD(Tensor_Matrix, addScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_add_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3078);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3184);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11873,7 +12350,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3100);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3206);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11882,7 +12359,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_subtract_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3097);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3203);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11905,7 +12382,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_subtract_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3097);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3203);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -11961,7 +12438,7 @@ PHP_METHOD(Tensor_Matrix, powScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3119);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3225);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -11970,7 +12447,7 @@ PHP_METHOD(Tensor_Matrix, powScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_pow_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3116);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3222);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -11993,7 +12470,7 @@ PHP_METHOD(Tensor_Matrix, powScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_pow_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3116);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3222);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12049,7 +12526,7 @@ PHP_METHOD(Tensor_Matrix, modScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3138);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3244);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12058,7 +12535,7 @@ PHP_METHOD(Tensor_Matrix, modScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_mod_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3135);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3241);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12081,7 +12558,7 @@ PHP_METHOD(Tensor_Matrix, modScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_mod_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3135);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3241);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12137,7 +12614,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3157);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3263);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12146,7 +12623,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3154);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3260);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12169,7 +12646,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3154);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3260);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12225,7 +12702,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3176);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3282);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12234,7 +12711,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_not_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3173);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3279);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12257,7 +12734,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_not_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3173);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3279);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12313,7 +12790,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3195);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3301);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12322,7 +12799,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_greater_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3192);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3298);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12345,7 +12822,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_greater_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3192);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3298);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12402,7 +12879,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3215);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3321);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12411,7 +12888,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_greater_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3212);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3318);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12434,7 +12911,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_greater_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3212);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3318);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12490,7 +12967,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3234);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3340);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12499,7 +12976,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_less_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3231);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3337);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12522,7 +12999,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_less_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3231);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3337);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12579,7 +13056,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 	} else {
 		_1 = &_0;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3254);
+	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3360);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -12588,7 +13065,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			ZVAL_DOUBLE(&_5$$3, b);
 			tensor_less_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3251);
+			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3357);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -12611,7 +13088,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 				ZEPHIR_INIT_NVAR(&_8$$4);
 				ZVAL_DOUBLE(&_9$$4, b);
 				tensor_less_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3251);
+				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3357);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -12652,7 +13129,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3272);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3378);
 	return;
 }
 
@@ -12695,7 +13172,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3292);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3398);
 	return;
 }
 
@@ -12745,7 +13222,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", 3311);
+	zephir_throw_exception_debug(&_1, "tensor/matrix.zep", 3417);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index 3621ea3..e2d2e09 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -5,6 +5,7 @@ ZEPHIR_INIT_CLASS(Tensor_Matrix);
 
 PHP_METHOD(Tensor_Matrix, build);
 PHP_METHOD(Tensor_Matrix, quick);
+PHP_METHOD(Tensor_Matrix, fromTensorBuffer);
 PHP_METHOD(Tensor_Matrix, identity);
 PHP_METHOD(Tensor_Matrix, zeros);
 PHP_METHOD(Tensor_Matrix, ones);
@@ -24,10 +25,13 @@ PHP_METHOD(Tensor_Matrix, n);
 PHP_METHOD(Tensor_Matrix, rowAsVector);
 PHP_METHOD(Tensor_Matrix, columnAsVector);
 PHP_METHOD(Tensor_Matrix, diagonalAsVector);
+PHP_METHOD(Tensor_Matrix, asVector);
 PHP_METHOD(Tensor_Matrix, asArray);
 PHP_METHOD(Tensor_Matrix, asRowBuffers);
-PHP_METHOD(Tensor_Matrix, asVectors);
+PHP_METHOD(Tensor_Matrix, asRowVectors);
+PHP_METHOD(Tensor_Matrix, asColumnBuffers);
 PHP_METHOD(Tensor_Matrix, asColumnVectors);
+PHP_METHOD(Tensor_Matrix, asVectors);
 PHP_METHOD(Tensor_Matrix, flatten);
 PHP_METHOD(Tensor_Matrix, map);
 PHP_METHOD(Tensor_Matrix, reduce);
@@ -165,6 +169,12 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_quick, 0, 0, Tensor
 ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, a, IS_ARRAY, 0, "[]")
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromtensorbuffer, 0, 3, Tensor\\Matrix, 0)
+	ZEND_ARG_OBJ_INFO(0, a, Tensor\\TensorBuffer, 0)
+	ZEND_ARG_TYPE_INFO(0, m, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_identity, 0, 1, Tensor\\Matrix, 0)
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
@@ -241,7 +251,10 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_columnasvector, 0,
 	ZEND_ARG_TYPE_INFO(0, index, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_diagonalasvector, 0, 0, Tensor\\Vector, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_diagonalasvector, 0, 0, Tensor\\ColumnVector, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_asvector, 0, 0, Tensor\\Vector, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asarray, 0, 0, IS_ARRAY, 0)
@@ -250,12 +263,18 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asrowbuffers, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asvectors, 0, 0, IS_ARRAY, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asrowvectors, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_ascolumnbuffers, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_ascolumnvectors, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asvectors, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_flatten, 0, 0, Tensor\\Vector, 0)
 ZEND_END_ARG_INFO()
 
@@ -733,6 +752,7 @@ ZEND_END_ARG_INFO()
 ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, build, arginfo_tensor_matrix_build, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, quick, arginfo_tensor_matrix_quick, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	PHP_ME(Tensor_Matrix, fromTensorBuffer, arginfo_tensor_matrix_fromtensorbuffer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, identity, arginfo_tensor_matrix_identity, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, zeros, arginfo_tensor_matrix_zeros, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, ones, arginfo_tensor_matrix_ones, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
@@ -752,10 +772,13 @@ ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, rowAsVector, arginfo_tensor_matrix_rowasvector, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, columnAsVector, arginfo_tensor_matrix_columnasvector, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, diagonalAsVector, arginfo_tensor_matrix_diagonalasvector, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, asVector, arginfo_tensor_matrix_asvector, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asArray, arginfo_tensor_matrix_asarray, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asRowBuffers, arginfo_tensor_matrix_asrowbuffers, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_Matrix, asVectors, arginfo_tensor_matrix_asvectors, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, asRowVectors, arginfo_tensor_matrix_asrowvectors, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, asColumnBuffers, arginfo_tensor_matrix_ascolumnbuffers, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asColumnVectors, arginfo_tensor_matrix_ascolumnvectors, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, asVectors, arginfo_tensor_matrix_asvectors, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, flatten, arginfo_tensor_matrix_flatten, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, map, arginfo_tensor_matrix_map, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, reduce, arginfo_tensor_matrix_reduce, ZEND_ACC_PUBLIC)
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 3697c39..22ed0a6 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -61,7 +61,7 @@ PHP_METHOD(Tensor_TensorBuffer, __construct)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(buffer, tensor_buffer_ce)
+		Z_PARAM_OBJECT_OF_CLASS(buffer, zephir_get_internal_ce(SL("tensor\\buffer")))
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &buffer);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 20, buffer);
@@ -330,6 +330,98 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 	RETURN_MM();
 }
 
+/**
+ * Map a function over the elements in the buffer and return a new decorator.
+ *
+ * @internal
+ *
+ * @param callable callback
+ * @return self
+ */
+PHP_METHOD(Tensor_TensorBuffer, map)
+{
+	zend_bool _6;
+	zval b;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *callback, callback_sub, value, a, _0, *_1, _2, *_3, _5, buffer, _4$$3, _7$$4;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&callback_sub);
+	ZVAL_UNDEF(&value);
+	ZVAL_UNDEF(&a);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&b);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(callback)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &callback);
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&a) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_2);
+		zephir_string_to_char_array(&_2, &a);
+		_1 = &_2;
+	} else {
+		_1 = &a;
+	}
+	zephir_is_iterable(_1, 0, "tensor/tensorbuffer.zep", 146);
+	if (Z_TYPE_P(_1) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
+		{
+			ZEPHIR_INIT_NVAR(&value);
+			ZVAL_COPY(&value, _3);
+			ZEPHIR_CALL_ZVAL_FUNCTION(&_4$$3, callback, NULL, 0, &value);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 143);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_6 = 1;
+		while (1) {
+			if (_6) {
+				_6 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_5, _1, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_5)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&value, _1, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_CALL_ZVAL_FUNCTION(&_7$$4, callback, NULL, 0, &value);
+				zephir_check_call_status();
+				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 143);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&value);
+	ZEPHIR_INIT_VAR(&buffer);
+	tensor_buffer_from_array(&buffer, &b);
+	object_init_ex(return_value, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &buffer);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
 /**
  * Return the sum of the elements in the buffer.
  *
@@ -516,7 +608,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 		ZEPHIR_CONCAT_SS(&_7$$3, "Offset, length, and", " stride must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 3, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_6$$3, "tensor/tensorbuffer.zep", 200);
+		zephir_throw_exception_debug(&_6$$3, "tensor/tensorbuffer.zep", 225);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -570,7 +662,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_get_arrval(&buffers, buffers_param);
 	ZEPHIR_INIT_VAR(&unwrapped);
 	array_init(&unwrapped);
-	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 225);
+	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 250);
 	if (Z_TYPE_P(&buffers) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&buffers), _0)
 		{
@@ -578,7 +670,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			ZVAL_COPY(&buffer, _0);
 			ZEPHIR_CALL_METHOD(&_1$$3, &buffer, "asBuffer", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 222);
+			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 247);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, &buffers, "rewind", NULL, 0);
@@ -600,7 +692,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_4$$4, &buffer, "asBuffer", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 222);
+				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 247);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -665,7 +757,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Chunk length must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 242);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 267);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -682,7 +774,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 	} else {
 		_6 = &buffers;
 	}
-	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 255);
+	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 280);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -692,7 +784,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 14, &buffer);
 			zephir_check_call_status();
-			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 252);
+			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 277);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -716,7 +808,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 14, &buffer);
 				zephir_check_call_status();
-				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 252);
+				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 277);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -766,7 +858,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Times must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 270);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 295);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/tensorbuffer.zep.h b/ext/tensor/tensorbuffer.zep.h
index b4e454e..f71e676 100644
--- a/ext/tensor/tensorbuffer.zep.h
+++ b/ext/tensor/tensorbuffer.zep.h
@@ -12,6 +12,7 @@ PHP_METHOD(Tensor_TensorBuffer, get);
 PHP_METHOD(Tensor_TensorBuffer, set);
 PHP_METHOD(Tensor_TensorBuffer, sort);
 PHP_METHOD(Tensor_TensorBuffer, slice);
+PHP_METHOD(Tensor_TensorBuffer, map);
 PHP_METHOD(Tensor_TensorBuffer, sum);
 PHP_METHOD(Tensor_TensorBuffer, product);
 PHP_METHOD(Tensor_TensorBuffer, min);
@@ -59,6 +60,10 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_slice, 0, 2,
 	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_map, 0, 1, Tensor\\TensorBuffer, 0)
+	ZEND_ARG_INFO(0, callback)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_sum, 0, 0, IS_DOUBLE, 0)
 ZEND_END_ARG_INFO()
 
@@ -105,6 +110,7 @@ ZEPHIR_INIT_FUNCS(tensor_tensorbuffer_method_entry) {
 	PHP_ME(Tensor_TensorBuffer, set, arginfo_tensor_tensorbuffer_set, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, sort, arginfo_tensor_tensorbuffer_sort, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, slice, arginfo_tensor_tensorbuffer_slice, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, map, arginfo_tensor_tensorbuffer_map, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, sum, arginfo_tensor_tensorbuffer_sum, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, product, arginfo_tensor_tensorbuffer_product, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, min, arginfo_tensor_tensorbuffer_min, ZEND_ACC_PUBLIC)
diff --git a/stubs/TensorBuffer.php b/stubs/TensorBuffer.php
index 3723af7..2b29be1 100644
--- a/stubs/TensorBuffer.php
+++ b/stubs/TensorBuffer.php
@@ -116,6 +116,10 @@ public function slice(int $offset, int $length) : TensorBuffer
         {
         }
 
+        public function map(callable $callback) : TensorBuffer
+        {
+        }
+
         public function sum() : float
         {
         }
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 83e6b6c..fb167a0 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -65,6 +65,27 @@ class Matrix implements Tensor
         return new self(a, false);
     }
 
+    /**
+     * Build a matrix from a TensorBuffer object.
+     *
+     * @param \Tensor\TensorBuffer a
+     * @param int m
+     * @param int n
+     * @return self
+     */
+    public static function fromTensorBuffer(<TensorBuffer> a, const int m, const int n) -> <Matrix>
+    {
+        var rowBuffer;
+
+        array rows = [];
+
+        for rowBuffer in a->split(n) {
+            let rows[] = rowBuffer;
+        }
+
+        return new self(rows, false);
+    }
+
     /**
      * Return an identity matrix with dimensionality n x n.
      *
diff --git a/tensor/tensorbuffer.zep b/tensor/tensorbuffer.zep
index f3dc328..9be8a20 100644
--- a/tensor/tensorbuffer.zep
+++ b/tensor/tensorbuffer.zep
@@ -123,6 +123,31 @@ class TensorBuffer
         return new TensorBuffer(<Buffer> b);
     }
 
+    /**
+     * Map a function over the elements in the buffer and return a new decorator.
+     *
+     * @internal
+     *
+     * @param callable callback
+     * @return self
+     */
+    public function map(const var callback) -> <TensorBuffer>
+    {
+        var value;
+
+        array b = [];
+
+        var a = this->buffer->toArray();
+
+        for value in a {
+            let b[] = {callback}(value);
+        }
+
+        var buffer = tensor_buffer_from_array(b);
+
+        return new TensorBuffer(<Buffer> buffer);
+    }
+
     /**
      * Return the sum of the elements in the buffer.
      *
diff --git a/tests/TensorBufferTest.php b/tests/TensorBufferTest.php
index 2a1b6c5..f221661 100644
--- a/tests/TensorBufferTest.php
+++ b/tests/TensorBufferTest.php
@@ -210,6 +210,23 @@ public function sliceNegativeLength() : void
         $decorator->slice(0, -1);
     }
 
+    /**
+     * @test
+     */
+    public function map() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
+
+        $mapped = $decorator->map(static function ($value) : float {
+            return $value ** 2;
+        });
+
+        $this->assertInstanceOf(TensorBuffer::class, $mapped);
+        $this->assertNotSame($decorator->asBuffer(), $mapped->asBuffer());
+        $this->assertEqualsWithDelta([1.0, 4.0, 9.0], $mapped->toArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta([1.0, 2.0, 3.0], $decorator->toArray(), self::MAX_DELTA);
+    }
+
     /**
      * @test
      */

From 040fca959ab38c2294b024f4cc7a785bb14d92e7 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 22:07:27 -0500
Subject: [PATCH 12/51] Save game

---
 ext/include/linear_algebra.c                |  205 +-
 ext/include/linear_algebra.h                |    6 +-
 ext/include/signal_processing.c             |   86 +-
 ext/include/signal_processing.h             |    2 +-
 ext/tensor/matrix.zep.c                     | 7658 ++++++++-----------
 ext/tensor/matrix.zep.h                     |    2 +
 ext/tensor/vector.zep.c                     |  283 +-
 ext/tensor/vector.zep.h                     |    5 +
 optimizers/TensorConvolve2dOptimizer.php    |    6 +-
 optimizers/TensorInverseOptimizer.php       |    6 +-
 optimizers/TensorMatmulOptimizer.php        |    6 +-
 optimizers/TensorPseudoinverseOptimizer.php |    6 +-
 tensor/matrix.zep                           |  887 ++-
 tensor/vector.zep                           |   10 +
 14 files changed, 4120 insertions(+), 5048 deletions(-)

diff --git a/ext/include/linear_algebra.c b/ext/include/linear_algebra.c
index da8b21c..8ac960d 100644
--- a/ext/include/linear_algebra.c
+++ b/ext/include/linear_algebra.c
@@ -17,59 +17,43 @@
  * @param return_value
  * @param a
  * @param b
+ * @param m
+ * @param p
+ * @param n
  */
-void tensor_matmul(zval * return_value, zval * a, zval * b)
+void tensor_matmul(zval * return_value, zval * a, zval * b, zval * m, zval * p, zval * n)
 {
-    unsigned int i, j;
-    zval * row;
-    zval rowC, c;
+    zend_long i;
+    zend_long ma = zephir_get_intval(m);
+    zend_long pa = zephir_get_intval(p);
+    zend_long nb = zephir_get_intval(n);
+    zend_long na = 0, nbb = 0;
+    int ok_a = 0, ok_b = 0;
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
-
-    unsigned int m = zend_array_count(aa);
-    unsigned int p = zend_array_count(ab);
-    unsigned int n = zend_array_count(Z_ARR_P(zend_hash_index_find(ab, 0)));
+    double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+    double * vb = tensor_tensorbuffer_doubles(b, &nbb, &ok_b);
 
-    double * va = emalloc(m * p * sizeof(double));
-    double * vb = emalloc(n * p * sizeof(double));
-    double * vc = emalloc(m * n * sizeof(double));
-
-    for (i = 0; i < m; ++i) {
-        row = zend_hash_index_find(aa, i);
-
-        for (j = 0; j < p; ++j) {
-            va[i * p + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    if (UNEXPECTED(!ok_a || !ok_b)) {
+        return;
     }
 
-    for (i = 0; i < p; ++i) {
-        row = zend_hash_index_find(ab, i);
-
-        for (j = 0; j < n; ++j) {
-            vb[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    if (UNEXPECTED(na != ma * pa || nbb != pa * nb)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffers must match the given dimensions."));
+        return;
     }
 
-    cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, m, n, p, 1.0, va, p, vb, n, 0.0, vc, n);
-
-    array_init_size(&c, m);
-
-    for (i = 0; i < m; ++i) {
-        array_init_size(&rowC, n);
+    zval c;
 
-        for (j = 0; j < n; ++j) {
-            add_next_index_double(&rowC, vc[i * n + j]);
-        }
-
-        add_next_index_zval(&c, &rowC);
+    if (UNEXPECTED(tensor_tensorbuffer_create(return_value, ma * nb, &c) == FAILURE)) {
+        return;
     }
 
-    RETVAL_ARR(Z_ARR(c));
+    double * vc = zephir_buffer_doubles(&c);
 
-    efree(va);
-    efree(vb);
-    efree(vc);
+    cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, ma, nb, pa, 1.0, va, pa, vb, nb, 0.0, vc, nb);
+
+    zval_ptr_dtor(&c);
 }
 
 /**
@@ -112,63 +96,72 @@ void tensor_dot(zval * return_value, zval * a, zval * b)
  *
  * @param return_value
  * @param a
+ * @param n
  */
-void tensor_inverse(zval * return_value, zval * a)
+void tensor_inverse(zval * return_value, zval * a, zval * n)
 {
-    unsigned int i, j;
-    zval * row;
-    zval rowB, b;
+    zend_long i;
+    zend_long nn = zephir_get_intval(n);
+    zend_long na = 0;
+    int ok_a = 0;
 
-    zend_array * aa = Z_ARR_P(a);
+    double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
 
-    unsigned int n = zend_array_count(aa);
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
 
-    double * va = emalloc(n * n * sizeof(double));
-    int * pivots = emalloc(n * sizeof(int));
+    if (UNEXPECTED(na != nn * nn)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
+    }
 
-    for (i = 0; i < n; ++i) {
-        row = zend_hash_index_find(aa, i);
+    double * w = emalloc(na * sizeof(double));
+    int * pivots = emalloc(nn * sizeof(int));
 
-        for (j = 0; j < n; ++j) {
-            va[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    for (i = 0; i < na; ++i) {
+        w[i] = va[i];
     }
-    
+
     lapack_int status;
 
-    status = LAPACKE_dgetrf(LAPACK_ROW_MAJOR, n, n, va, n, pivots);
+    status = LAPACKE_dgetrf(LAPACK_ROW_MAJOR, nn, nn, w, nn, pivots);
 
     if (status != 0) {
-        efree(va);
+        efree(w);
         efree(pivots);
 
         RETURN_NULL();
     }
 
-    status = LAPACKE_dgetri(LAPACK_ROW_MAJOR, n, va, n, pivots);
+    status = LAPACKE_dgetri(LAPACK_ROW_MAJOR, nn, w, nn, pivots);
 
     if (status != 0) {
-        efree(va);
+        efree(w);
         efree(pivots);
 
         RETURN_NULL();
     }
 
-    array_init_size(&b, n);
+    zval c;
 
-    for (i = 0; i < n; ++i) {
-        array_init_size(&rowB, n);
+    if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na, &c) == FAILURE)) {
+        efree(w);
+        efree(pivots);
 
-        for (j = 0; j < n; ++j) {
-            add_next_index_double(&rowB, va[i * n + j]);
-        }
+        return;
+    }
 
-        add_next_index_zval(&b, &rowB);
+    double * vc = zephir_buffer_doubles(&c);
+
+    for (i = 0; i < na; ++i) {
+        vc[i] = w[i];
     }
 
-    RETVAL_ARR(Z_ARR(b));
+    zval_ptr_dtor(&c);
 
-    efree(va);
+    efree(w);
     efree(pivots);
 }
 
@@ -177,37 +170,45 @@ void tensor_inverse(zval * return_value, zval * a)
  * 
  * @param return_value
  * @param a
+ * @param m
+ * @param n
  */
-void tensor_pseudoinverse(zval * return_value, zval * a)
+void tensor_pseudoinverse(zval * return_value, zval * a, zval * m, zval * n)
 {
-    unsigned int i, j;
-    zval * row;
-    zval b, rowB;
+    zend_long i;
+    zend_long ma = zephir_get_intval(m);
+    zend_long na = zephir_get_intval(n);
+    zend_long nbuf = 0;
+    int ok_a = 0;
 
-    zend_array * aa = Z_ARR_P(a);
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
 
-    unsigned int m = zend_array_count(aa);
-    unsigned int n = zend_array_count(Z_ARR_P(zend_hash_index_find(aa, 0)));
-    unsigned int k = MIN(m, n);
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
 
-    double * va = emalloc(m * n * sizeof(double));
-    double * vu = emalloc(m * m * sizeof(double));
-    double * vs = emalloc(k * sizeof(double));
-    double * vvt = emalloc(n * n * sizeof(double));
-    double * vb = emalloc(n * m * sizeof(double));
+    if (UNEXPECTED(nbuf != ma * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
+    }
 
-    for (i = 0; i < m; ++i) {
-        row = zend_hash_index_find(aa, i);
+    unsigned int k = MIN(ma, na);
 
-        for (j = 0; j < n; ++j) {
-            va[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    double * w = emalloc(nbuf * sizeof(double));
+    double * vu = emalloc(ma * ma * sizeof(double));
+    double * vs = emalloc(k * sizeof(double));
+    double * vvt = emalloc(na * na * sizeof(double));
+    double * vb = emalloc(na * ma * sizeof(double));
+
+    for (i = 0; i < nbuf; ++i) {
+        w[i] = va[i];
     }
 
-    lapack_int status = LAPACKE_dgesdd(LAPACK_ROW_MAJOR, 'A', m, n, va, n, vs, vu, m, vvt, n);
+    lapack_int status = LAPACKE_dgesdd(LAPACK_ROW_MAJOR, 'A', ma, na, w, na, vs, vu, ma, vvt, na);
 
     if (status != 0) {
-        efree(va);
+        efree(w);
         efree(vu);
         efree(vs);
         efree(vvt);
@@ -217,26 +218,32 @@ void tensor_pseudoinverse(zval * return_value, zval * a)
     }
 
     for (i = 0; i < k; ++i) {
-        cblas_dscal(m, 1.0 / vs[i], &vu[i], m);
+        cblas_dscal(ma, 1.0 / vs[i], &vu[i], ma);
     }
 
-    cblas_dgemm(CblasRowMajor, CblasTrans, CblasTrans, n, m, m, 1.0, vvt, n, vu, m, 0.0, vb, m);
+    cblas_dgemm(CblasRowMajor, CblasTrans, CblasTrans, na, ma, ma, 1.0, vvt, na, vu, ma, 0.0, vb, ma);
 
-    array_init_size(&b, n);
+    zval c;
 
-    for (i = 0; i < n; ++i) {
-        array_init_size(&rowB, m);
+    if (UNEXPECTED(tensor_tensorbuffer_create(return_value, na * ma, &c) == FAILURE)) {
+        efree(w);
+        efree(vu);
+        efree(vs);
+        efree(vvt);
+        efree(vb);
 
-        for (j = 0; j < m; ++j) {
-            add_next_index_double(&rowB, vb[i * m + j]);
-        }
+        return;
+    }
 
-        add_next_index_zval(&b, &rowB);
+    double * vc = zephir_buffer_doubles(&c);
+
+    for (i = 0; i < na * ma; ++i) {
+        vc[i] = vb[i];
     }
 
-    RETVAL_ARR(Z_ARR(b));
+    zval_ptr_dtor(&c);
 
-    efree(va);
+    efree(w);
     efree(vu);
     efree(vs);
     efree(vvt);
diff --git a/ext/include/linear_algebra.h b/ext/include/linear_algebra.h
index 10a9d86..f144aec 100644
--- a/ext/include/linear_algebra.h
+++ b/ext/include/linear_algebra.h
@@ -3,11 +3,11 @@
 
 #include <Zend/zend.h>
 
-void tensor_matmul(zval * return_value, zval * a, zval * b);
+void tensor_matmul(zval * return_value, zval * a, zval * b, zval * m, zval * p, zval * n);
 void tensor_dot(zval * return_value, zval * a, zval * b);
 
-void tensor_inverse(zval * return_value, zval * a);
-void tensor_pseudoinverse(zval * return_value, zval * a);
+void tensor_inverse(zval * return_value, zval * a, zval * n);
+void tensor_pseudoinverse(zval * return_value, zval * a, zval * m, zval * n);
 
 void tensor_ref(zval * return_value, zval * a);
 void tensor_cholesky(zval * return_value, zval * a);
diff --git a/ext/include/signal_processing.c b/ext/include/signal_processing.c
index a7c54d6..ac4920f 100644
--- a/ext/include/signal_processing.c
+++ b/ext/include/signal_processing.c
@@ -69,79 +69,77 @@ void tensor_convolve_1d(zval * return_value, zval * a, zval * b, zval * stride)
  * @param a
  * @param b
  * @param stride
+ * @param ma
+ * @param na
+ * @param mb
+ * @param nb
  */
-void tensor_convolve_2d(zval * return_value, zval * a, zval * b, zval * stride)
+void tensor_convolve_2d(zval * return_value, zval * a, zval * b, zval * stride, zval * ma, zval * na, zval * mb, zval * nb)
 {
-    unsigned int i, j, k, l;
-    int x, y;
+    zend_long i, j, k, l;
+    zend_long x, y;
     double sigma;
-    zval * row;
-    zval rowC, c;
+    zend_long nbufa = 0, nbufb = 0;
+    int ok_a = 0, ok_b = 0;
 
-    zend_array * aa = Z_ARR_P(a);
-    zend_array * ab = Z_ARR_P(b);
+    zend_long s = zephir_get_intval(stride);
+    zend_long ma_ = zephir_get_intval(ma);
+    zend_long na_ = zephir_get_intval(na);
+    zend_long mb_ = zephir_get_intval(mb);
+    zend_long nb_ = zephir_get_intval(nb);
 
-    unsigned int s = zephir_get_intval(stride);
+    double * va = tensor_tensorbuffer_doubles(a, &nbufa, &ok_a);
+    double * vb = tensor_tensorbuffer_doubles(b, &nbufb, &ok_b);
 
-    unsigned int ma = zend_array_count(aa);
-    unsigned int na = zend_array_count(Z_ARR_P(zend_hash_index_find(aa, 0)));
-    unsigned int mb = zend_array_count(ab);
-    unsigned int nb = zend_array_count(Z_ARR_P(zend_hash_index_find(ab, 0)));
+    if (UNEXPECTED(!ok_a || !ok_b)) {
+        return;
+    }
 
-    double * va = emalloc(ma * na * sizeof(double));
-    double * vb = emalloc(mb * nb * sizeof(double));
+    if (UNEXPECTED(nbufa != ma_ * na_ || nbufb != mb_ * nb_)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffers must match the given dimensions."));
+        return;
+    }
 
-    for (i = 0; i < ma; ++i) {
-        row = zend_hash_index_find(aa, i);
+    zend_long p = mb_ / 2;
+    zend_long q = nb_ / 2;
 
-        for (j = 0; j < na; ++j) {
-            va[i * na + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
-    }
+    zend_long om = (ma_ + s - 1) / s;
+    zend_long on = (na_ + s - 1) / s;
 
-    for (i = 0; i < mb; ++i) {
-        row = zend_hash_index_find(ab, i);
+    zval c;
 
-        for (j = 0; j < nb; ++j) {
-            vb[i * nb + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    if (UNEXPECTED(tensor_tensorbuffer_create(return_value, om * on, &c) == FAILURE)) {
+        return;
     }
 
-    unsigned int p = mb / 2;
-    unsigned int q = nb / 2;
-
-    array_init_size(&c, (ma + s - 1) / s);
+    double * vc = zephir_buffer_doubles(&c);
 
-    for (i = 0; i < ma; i += s) {
-        array_init_size(&rowC, (na + s - 1) / s);
+    zend_long idx = 0;
 
-        for (j = 0; j < na; j += s) {   
+    for (i = 0; i < ma_; i += s) {
+        for (j = 0; j < na_; j += s) {
             sigma = 0.0;
 
-            for (k = 0; k < mb; ++k) {
+            for (k = 0; k < mb_; ++k) {
                 x = i + p - k;
 
-                if (x < 0 || x >= ma) {
+                if (x < 0 || x >= ma_) {
                     continue;
                 }
 
-                for (l = 0; l < nb; ++l) {
+                for (l = 0; l < nb_; ++l) {
                     y = j + q - l;
 
-                    if (y >= 0 && y < na) {
-                        sigma += va[x * na + y] * vb[k * nb + l];
+                    if (y >= 0 && y < na_) {
+                        sigma += va[x * na_ + y] * vb[k * nb_ + l];
                     }
                 }
             }
 
-            add_next_index_double(&rowC, sigma);
+            vc[idx++] = sigma;
         }
-
-        add_next_index_zval(&c, &rowC);
     }
 
-    RETVAL_ARR(Z_ARR(c));
-
-    efree(va);
-    efree(vb);
+    zval_ptr_dtor(&c);
 }
diff --git a/ext/include/signal_processing.h b/ext/include/signal_processing.h
index 22f1b66..e64e39a 100644
--- a/ext/include/signal_processing.h
+++ b/ext/include/signal_processing.h
@@ -4,6 +4,6 @@
 #include <Zend/zend.h>
 
 void tensor_convolve_1d(zval * return_value, zval * a, zval * b, zval * stride);
-void tensor_convolve_2d(zval * return_value, zval * a, zval * b, zval * stride);
+void tensor_convolve_2d(zval * return_value, zval * a, zval * b, zval * stride, zval * ma, zval * na, zval * mb, zval * nb);
 
 #endif
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 8180c2e..889b64d 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -16,11 +16,11 @@
 #include "kernel/memory.h"
 #include "kernel/operators.h"
 #include "kernel/object.h"
-#include "kernel/string.h"
-#include "kernel/array.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
+#include "kernel/array.h"
 #include "math.h"
+#include "kernel/string.h"
 #include "kernel/math.h"
 #include "ext/spl/spl_array.h"
 #include "include/buffer.h"
@@ -75,11 +75,13 @@ PHP_METHOD(Tensor_Matrix, build)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a_param = NULL, _0;
+	zval *a_param = NULL, _0, _1, _2;
 	zval a;
 
 	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
 	ZEND_PARSE_PARAMETERS_START(0, 1)
 		Z_PARAM_OPTIONAL
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
@@ -94,8 +96,10 @@ PHP_METHOD(Tensor_Matrix, build)
 		zephir_get_arrval(&a, a_param);
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZVAL_BOOL(&_0, 1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &a, &_0);
+	ZVAL_LONG(&_0, 0);
+	ZVAL_LONG(&_1, 0);
+	ZVAL_BOOL(&_2, 1);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &a, &_0, &_1, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -110,11 +114,13 @@ PHP_METHOD(Tensor_Matrix, quick)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a_param = NULL, _0;
+	zval *a_param = NULL, _0, _1, _2;
 	zval a;
 
 	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
 	ZEND_PARSE_PARAMETERS_START(0, 1)
 		Z_PARAM_OPTIONAL
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
@@ -129,8 +135,10 @@ PHP_METHOD(Tensor_Matrix, quick)
 		zephir_get_arrval(&a, a_param);
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZVAL_BOOL(&_0, 0);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &a, &_0);
+	ZVAL_LONG(&_0, 0);
+	ZVAL_LONG(&_1, 0);
+	ZVAL_BOOL(&_2, 0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &a, &_0, &_1, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -145,19 +153,14 @@ PHP_METHOD(Tensor_Matrix, quick)
  */
 PHP_METHOD(Tensor_Matrix, fromTensorBuffer)
 {
-	zend_bool _6;
-	zval rows;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS;
-	zval *a, a_sub, *m_param = NULL, *n_param = NULL, rowBuffer, _0, _1, *_2, _3, *_4, _5;
+	zval *a, a_sub, *m_param = NULL, *n_param = NULL, _0, _1, _2;
 
 	ZVAL_UNDEF(&a_sub);
-	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_3);
-	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&rows);
+	ZVAL_UNDEF(&_2);
 	ZEND_PARSE_PARAMETERS_START(3, 3)
 		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
 		Z_PARAM_LONG(m)
@@ -166,51 +169,11 @@ PHP_METHOD(Tensor_Matrix, fromTensorBuffer)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 3, 0, &a, &m_param, &n_param);
-	ZEPHIR_INIT_VAR(&rows);
-	array_init(&rows);
-	ZVAL_LONG(&_1, n);
-	ZEPHIR_CALL_METHOD(&_0, a, "split", NULL, 0, &_1);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_3);
-		zephir_string_to_char_array(&_3, &_0);
-		_2 = &_3;
-	} else {
-		_2 = &_0;
-	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 86);
-	if (Z_TYPE_P(_2) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _4);
-			zephir_array_append(&rows, &rowBuffer, PH_SEPARATE, "tensor/matrix.zep", 83);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_6 = 1;
-		while (1) {
-			if (_6) {
-				_6 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _2, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_5, _2, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_5)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _2, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_array_append(&rows, &rowBuffer, PH_SEPARATE, "tensor/matrix.zep", 83);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZVAL_BOOL(&_1, 0);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &rows, &_1);
+	ZVAL_LONG(&_0, m);
+	ZVAL_LONG(&_1, n);
+	ZVAL_BOOL(&_2, 0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, a, &_0, &_1, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -253,7 +216,7 @@ PHP_METHOD(Tensor_Matrix, identity)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 100);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 92);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -299,10 +262,10 @@ PHP_METHOD(Tensor_Matrix, identity)
 						ZEPHIR_INIT_NVAR(&_10$$5);
 						ZVAL_DOUBLE(&_10$$5, 0.0);
 					}
-					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 112);
+					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 104);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 115);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 107);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
@@ -442,15 +405,15 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 					ZEPHIR_INIT_NVAR(&_7$$4);
 					if (i == j) {
 						ZEPHIR_OBS_NVAR(&_7$$4);
-						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 169);
+						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 161);
 					} else {
 						ZEPHIR_INIT_NVAR(&_7$$4);
 						ZVAL_DOUBLE(&_7$$4, 0.0);
 					}
-					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 169);
+					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 161);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 172);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 164);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
@@ -507,7 +470,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 191);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 183);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -521,7 +484,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 196);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 188);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -585,7 +548,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 214);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 206);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -599,7 +562,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 219);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 211);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -624,9 +587,9 @@ PHP_METHOD(Tensor_Matrix, rand)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_12$$6);
 			ZVAL_DOUBLE(&_12$$6, zephir_safe_div_zval_long(&_10$$6, max));
-			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 231);
+			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 223);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 234);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 226);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -688,7 +651,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 252);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 244);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -702,7 +665,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 257);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 249);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -726,7 +689,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZEPHIR_CALL_FUNCTION(&_10$$6, "array_pop", &_11, 9, &extras);
 			ZEPHIR_UNREF(&extras);
 			zephir_check_call_status();
-			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 272);
+			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 264);
 		}
 		while (1) {
 			if (!(zephir_fast_count_int(&rowA) < n)) {
@@ -745,20 +708,20 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZVAL_DOUBLE(&_18$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * sin(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 280);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 272);
 			ZVAL_DOUBLE(&_20$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * cos(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 281);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 273);
 		}
 		if (zephir_fast_count_int(&rowA) > n) {
 			ZEPHIR_MAKE_REF(&rowA);
 			ZEPHIR_CALL_FUNCTION(&_21$$8, "array_pop", &_11, 9, &rowA);
 			ZEPHIR_UNREF(&rowA);
 			zephir_check_call_status();
-			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 285);
+			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 277);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 288);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 280);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -829,7 +792,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 307);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 299);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -843,7 +806,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 312);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 304);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -857,7 +820,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_12$$5, "Lambda must be", " greater than or equal to 0, ", &_11$$5, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 3, &_12$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 317);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 309);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -903,9 +866,9 @@ PHP_METHOD(Tensor_Matrix, poisson)
 			}
 			ZEPHIR_INIT_NVAR(&_21$$8);
 			ZVAL_DOUBLE(&_21$$8, (k - 1.0));
-			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 346);
+			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 338);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 349);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 341);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -960,7 +923,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 367);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 359);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -974,7 +937,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 372);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 364);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1001,9 +964,9 @@ PHP_METHOD(Tensor_Matrix, uniform)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_14$$6);
 			ZVAL_DOUBLE(&_14$$6, zephir_safe_div_zval_long(&_12$$6, max));
-			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 384);
+			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 376);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 387);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 379);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -1011,21 +974,23 @@ PHP_METHOD(Tensor_Matrix, uniform)
 }
 
 /**
- * @param array[]|TensorBuffer[] a
+ * @param array[]|TensorBuffer[]|TensorBuffer a
+ * @param int m
+ * @param int n
  * @param bool validate
  * @throws \Tensor\Exceptions\InvalidArgumentException
  */
 PHP_METHOD(Tensor_Matrix, __construct)
 {
-	zend_string *_10$$9;
-	zend_ulong _9$$9;
-	zval _1$$3, _4$$7, _12$$12, _37$$20;
-	zval flat;
+	zend_string *_8$$9;
+	zend_ulong _7$$9;
+	zval _2$$7, _10$$12, _35$$20, _93$$40;
+	zval flat$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_16 = NULL, *_29 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, m;
-	zend_bool validate, _35$$9, _31$$10, _54$$18, _69$$26, _66$$27, _76$$31;
-	zval *a = NULL, a_sub, *validate_param = NULL, i, rowA, valueA, firstRow, n, _2, buffer, _78, _79, _0$$3, _3$$7, _5$$9, *_6$$9, _7$$9, *_8$$9, _34$$9, _11$$12, _13$$11, _19$$11, _14$$13, _15$$13, _17$$13, _18$$13, _20$$15, _21$$15, _22$$15, _23$$15, *_24$$10, _25$$10, *_26$$10, _30$$10, _27$$16, _28$$16, _32$$17, _33$$17, _36$$20, _38$$19, _43$$19, _39$$21, _40$$21, _41$$21, _42$$21, _44$$23, _45$$23, _46$$23, _47$$23, *_48$$18, _49$$18, *_50$$18, _53$$18, _51$$24, _52$$24, _55$$25, _56$$25, *_57$$26, _58$$26, *_59$$26, _68$$26, _60$$28, *_61$$27, _62$$27, *_63$$27, _65$$27, _64$$29, _67$$30, _70$$32, *_71$$31, _72$$31, *_73$$31, _75$$31, _74$$33, _77$$34;
+	zephir_fcall_cache_entry *_14 = NULL, *_27 = NULL;
+	zend_bool validate, _33$$9, _29$$10, _52$$18, _67$$26, _64$$27, _74$$31;
+	zend_long m, n, ZEPHIR_LAST_CALL_STATUS, rows$$3;
+	zval *a = NULL, a_sub, *m_param = NULL, *n_param = NULL, *validate_param = NULL, i, rowA, valueA, firstRow, nHat$$3, _0$$3, buffer$$3, _76$$3, _77$$3, _1$$7, _3$$9, *_4$$9, _5$$9, *_6$$9, _32$$9, _9$$12, _11$$11, _17$$11, _12$$13, _13$$13, _15$$13, _16$$13, _18$$15, _19$$15, _20$$15, _21$$15, *_22$$10, _23$$10, *_24$$10, _28$$10, _25$$16, _26$$16, _30$$17, _31$$17, _34$$20, _36$$19, _41$$19, _37$$21, _38$$21, _39$$21, _40$$21, _42$$23, _43$$23, _44$$23, _45$$23, *_46$$18, _47$$18, *_48$$18, _51$$18, _49$$24, _50$$24, _53$$25, _54$$25, *_55$$26, _56$$26, *_57$$26, _66$$26, _58$$28, *_59$$27, _60$$27, *_61$$27, _63$$27, _62$$29, _65$$30, _68$$32, *_69$$31, _70$$31, *_71$$31, _73$$31, _72$$33, _75$$34, _78$$37, _79$$37, _80$$37, _81$$37, _82$$38, _83$$38, _84$$38, _85$$38, _86$$36, _87$$39, _88$$39, _89$$39, _90$$39, _91$$35, _92$$40;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&a_sub);
@@ -1033,67 +998,81 @@ PHP_METHOD(Tensor_Matrix, __construct)
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&firstRow);
-	ZVAL_UNDEF(&n);
-	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_78);
-	ZVAL_UNDEF(&_79);
+	ZVAL_UNDEF(&nHat$$3);
 	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&_3$$7);
+	ZVAL_UNDEF(&buffer$$3);
+	ZVAL_UNDEF(&_76$$3);
+	ZVAL_UNDEF(&_77$$3);
+	ZVAL_UNDEF(&_1$$7);
+	ZVAL_UNDEF(&_3$$9);
 	ZVAL_UNDEF(&_5$$9);
-	ZVAL_UNDEF(&_7$$9);
-	ZVAL_UNDEF(&_34$$9);
-	ZVAL_UNDEF(&_11$$12);
-	ZVAL_UNDEF(&_13$$11);
-	ZVAL_UNDEF(&_19$$11);
-	ZVAL_UNDEF(&_14$$13);
+	ZVAL_UNDEF(&_32$$9);
+	ZVAL_UNDEF(&_9$$12);
+	ZVAL_UNDEF(&_11$$11);
+	ZVAL_UNDEF(&_17$$11);
+	ZVAL_UNDEF(&_12$$13);
+	ZVAL_UNDEF(&_13$$13);
 	ZVAL_UNDEF(&_15$$13);
-	ZVAL_UNDEF(&_17$$13);
-	ZVAL_UNDEF(&_18$$13);
+	ZVAL_UNDEF(&_16$$13);
+	ZVAL_UNDEF(&_18$$15);
+	ZVAL_UNDEF(&_19$$15);
 	ZVAL_UNDEF(&_20$$15);
 	ZVAL_UNDEF(&_21$$15);
-	ZVAL_UNDEF(&_22$$15);
-	ZVAL_UNDEF(&_23$$15);
-	ZVAL_UNDEF(&_25$$10);
-	ZVAL_UNDEF(&_30$$10);
-	ZVAL_UNDEF(&_27$$16);
-	ZVAL_UNDEF(&_28$$16);
-	ZVAL_UNDEF(&_32$$17);
-	ZVAL_UNDEF(&_33$$17);
-	ZVAL_UNDEF(&_36$$20);
-	ZVAL_UNDEF(&_38$$19);
-	ZVAL_UNDEF(&_43$$19);
+	ZVAL_UNDEF(&_23$$10);
+	ZVAL_UNDEF(&_28$$10);
+	ZVAL_UNDEF(&_25$$16);
+	ZVAL_UNDEF(&_26$$16);
+	ZVAL_UNDEF(&_30$$17);
+	ZVAL_UNDEF(&_31$$17);
+	ZVAL_UNDEF(&_34$$20);
+	ZVAL_UNDEF(&_36$$19);
+	ZVAL_UNDEF(&_41$$19);
+	ZVAL_UNDEF(&_37$$21);
+	ZVAL_UNDEF(&_38$$21);
 	ZVAL_UNDEF(&_39$$21);
 	ZVAL_UNDEF(&_40$$21);
-	ZVAL_UNDEF(&_41$$21);
-	ZVAL_UNDEF(&_42$$21);
+	ZVAL_UNDEF(&_42$$23);
+	ZVAL_UNDEF(&_43$$23);
 	ZVAL_UNDEF(&_44$$23);
 	ZVAL_UNDEF(&_45$$23);
-	ZVAL_UNDEF(&_46$$23);
-	ZVAL_UNDEF(&_47$$23);
-	ZVAL_UNDEF(&_49$$18);
-	ZVAL_UNDEF(&_53$$18);
-	ZVAL_UNDEF(&_51$$24);
-	ZVAL_UNDEF(&_52$$24);
-	ZVAL_UNDEF(&_55$$25);
-	ZVAL_UNDEF(&_56$$25);
-	ZVAL_UNDEF(&_58$$26);
-	ZVAL_UNDEF(&_68$$26);
-	ZVAL_UNDEF(&_60$$28);
-	ZVAL_UNDEF(&_62$$27);
-	ZVAL_UNDEF(&_65$$27);
-	ZVAL_UNDEF(&_64$$29);
-	ZVAL_UNDEF(&_67$$30);
-	ZVAL_UNDEF(&_70$$32);
-	ZVAL_UNDEF(&_72$$31);
-	ZVAL_UNDEF(&_75$$31);
-	ZVAL_UNDEF(&_74$$33);
-	ZVAL_UNDEF(&_77$$34);
-	ZVAL_UNDEF(&flat);
-	ZVAL_UNDEF(&_1$$3);
-	ZVAL_UNDEF(&_4$$7);
-	ZVAL_UNDEF(&_12$$12);
-	ZVAL_UNDEF(&_37$$20);
+	ZVAL_UNDEF(&_47$$18);
+	ZVAL_UNDEF(&_51$$18);
+	ZVAL_UNDEF(&_49$$24);
+	ZVAL_UNDEF(&_50$$24);
+	ZVAL_UNDEF(&_53$$25);
+	ZVAL_UNDEF(&_54$$25);
+	ZVAL_UNDEF(&_56$$26);
+	ZVAL_UNDEF(&_66$$26);
+	ZVAL_UNDEF(&_58$$28);
+	ZVAL_UNDEF(&_60$$27);
+	ZVAL_UNDEF(&_63$$27);
+	ZVAL_UNDEF(&_62$$29);
+	ZVAL_UNDEF(&_65$$30);
+	ZVAL_UNDEF(&_68$$32);
+	ZVAL_UNDEF(&_70$$31);
+	ZVAL_UNDEF(&_73$$31);
+	ZVAL_UNDEF(&_72$$33);
+	ZVAL_UNDEF(&_75$$34);
+	ZVAL_UNDEF(&_78$$37);
+	ZVAL_UNDEF(&_79$$37);
+	ZVAL_UNDEF(&_80$$37);
+	ZVAL_UNDEF(&_81$$37);
+	ZVAL_UNDEF(&_82$$38);
+	ZVAL_UNDEF(&_83$$38);
+	ZVAL_UNDEF(&_84$$38);
+	ZVAL_UNDEF(&_85$$38);
+	ZVAL_UNDEF(&_86$$36);
+	ZVAL_UNDEF(&_87$$39);
+	ZVAL_UNDEF(&_88$$39);
+	ZVAL_UNDEF(&_89$$39);
+	ZVAL_UNDEF(&_90$$39);
+	ZVAL_UNDEF(&_91$$35);
+	ZVAL_UNDEF(&_92$$40);
+	ZVAL_UNDEF(&flat$$3);
+	ZVAL_UNDEF(&_2$$7);
+	ZVAL_UNDEF(&_10$$12);
+	ZVAL_UNDEF(&_35$$20);
+	ZVAL_UNDEF(&_93$$40);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
@@ -1107,456 +1086,523 @@ PHP_METHOD(Tensor_Matrix, __construct)
 		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 
-	ZEND_PARSE_PARAMETERS_START(1, 2)
+	ZEND_PARSE_PARAMETERS_START(1, 4)
 		Z_PARAM_ZVAL(a)
 		Z_PARAM_OPTIONAL
+		Z_PARAM_LONG(m)
+		Z_PARAM_LONG(n)
 		Z_PARAM_BOOL(validate)
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 1, &a, &validate_param);
+	zephir_fetch_params(1, 1, 3, &a, &m_param, &n_param, &validate_param);
 	ZEPHIR_SEPARATE_PARAM(a);
-	if (!validate_param) {
-		validate = 1;
+	if (!m_param) {
+		m = 0;
 	} else {
 		}
-	if (UNEXPECTED(Z_TYPE_P(a) != IS_ARRAY)) {
-		ZEPHIR_INIT_VAR(&_0$$3);
-		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_INIT_VAR(&_1$$3);
-		ZEPHIR_CONCAT_SS(&_1$$3, "Matrix requires an", " array of arrays.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
-		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 404);
-		ZEPHIR_MM_RESTORE();
-		return;
-	}
-	m = zephir_fast_count_int(a);
-	ZEPHIR_INIT_VAR(&flat);
-	array_init(&flat);
-	ZEPHIR_CALL_FUNCTION(&_2, "current", NULL, 27, a);
-	zephir_check_call_status();
-	if (!(zephir_is_true(&_2))) {
-		ZEPHIR_INIT_VAR(&firstRow);
-		array_init(&firstRow);
+	if (!n_param) {
+		n = 0;
 	} else {
-		ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 27, a);
-		zephir_check_call_status();
-	}
-	if (Z_TYPE_P(&firstRow) == IS_OBJECT) {
-		if (UNEXPECTED(!((zephir_instance_of_ev(&firstRow, tensor_tensorbuffer_ce))))) {
-			ZEPHIR_INIT_VAR(&_3$$7);
-			object_init_ex(&_3$$7, tensor_exceptions_invalidargumentexception_ce);
-			ZEPHIR_INIT_VAR(&_4$$7);
-			ZEPHIR_CONCAT_SS(&_4$$7, "Matrix requires an", " array of arrays.");
-			ZEPHIR_CALL_METHOD(NULL, &_3$$7, "__construct", NULL, 3, &_4$$7);
-			zephir_check_call_status();
-			zephir_throw_exception_debug(&_3$$7, "tensor/matrix.zep", 418);
-			ZEPHIR_MM_RESTORE();
-			return;
 		}
-		ZEPHIR_CALL_METHOD(&n, &firstRow, "count", NULL, 0);
-		zephir_check_call_status();
+	if (!validate_param) {
+		validate = 1;
 	} else {
-		ZEPHIR_INIT_NVAR(&n);
-		ZVAL_LONG(&n, zephir_fast_count_int(&firstRow));
-	}
-	if (validate) {
-		ZEPHIR_CALL_FUNCTION(&_5$$9, "array_values", NULL, 26, a);
-		zephir_check_call_status();
-		ZEPHIR_CPY_WRT(a, &_5$$9);
-		if (Z_TYPE_P(a) == IS_STRING) {
-			ZEPHIR_INIT_VAR(&_7$$9);
-			zephir_string_to_char_array(&_7$$9, a);
-			_6$$9 = &_7$$9;
-		} else {
-			_6$$9 = a;
 		}
-		zephir_is_iterable(_6$$9, 0, "tensor/matrix.zep", 457);
-		if (Z_TYPE_P(_6$$9) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_6$$9), _9$$9, _10$$9, _8$$9)
-			{
-				ZEPHIR_INIT_NVAR(&i);
-				if (_10$$9 != NULL) { 
-					ZVAL_STR_COPY(&i, _10$$9);
-				} else {
-					ZVAL_LONG(&i, _9$$9);
-				}
-				ZEPHIR_INIT_NVAR(&rowA);
-				ZVAL_COPY(&rowA, _8$$9);
-				if (Z_TYPE_P(&rowA) == IS_OBJECT) {
-					if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
-						ZEPHIR_INIT_NVAR(&_11$$12);
-						object_init_ex(&_11$$12, tensor_exceptions_invalidargumentexception_ce);
-						ZEPHIR_INIT_NVAR(&_12$$12);
-						ZEPHIR_CONCAT_SS(&_12$$12, "Matrix requires an", " array of arrays.");
-						ZEPHIR_CALL_METHOD(NULL, &_11$$12, "__construct", NULL, 3, &_12$$12);
-						zephir_check_call_status();
-						zephir_throw_exception_debug(&_11$$12, "tensor/matrix.zep", 433);
-						ZEPHIR_MM_RESTORE();
-						return;
-					}
-					ZEPHIR_CALL_METHOD(&_13$$11, &rowA, "count", NULL, 0);
-					zephir_check_call_status();
-					if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_13$$11, &n))) {
-						ZEPHIR_INIT_NVAR(&_14$$13);
-						object_init_ex(&_14$$13, tensor_exceptions_invalidargumentexception_ce);
-						ZEPHIR_CALL_FUNCTION(&_15$$13, "strval", &_16, 4, &n);
-						zephir_check_call_status();
-						ZEPHIR_CALL_METHOD(&_17$$13, &rowA, "count", NULL, 0);
-						zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_18$$13);
-						ZEPHIR_CONCAT_SSVSVSVS(&_18$$13, "The number of", " columns must be equal for all rows, ", &_15$$13, " needed but ", &_17$$13, " given at row offset ", &i, ".");
-						ZEPHIR_CALL_METHOD(NULL, &_14$$13, "__construct", NULL, 3, &_18$$13);
-						zephir_check_call_status();
-						zephir_throw_exception_debug(&_14$$13, "tensor/matrix.zep", 440);
-						ZEPHIR_MM_RESTORE();
-						return;
-					}
-					ZEPHIR_CALL_METHOD(&_19$$11, &rowA, "toArray", NULL, 0);
-					zephir_check_call_status();
-					ZEPHIR_CPY_WRT(&rowA, &_19$$11);
-				} else {
-					if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA)))) {
-						ZEPHIR_INIT_NVAR(&_20$$15);
-						object_init_ex(&_20$$15, tensor_exceptions_invalidargumentexception_ce);
-						ZEPHIR_CALL_FUNCTION(&_21$$15, "strval", &_16, 4, &n);
-						zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_22$$15);
-						ZVAL_LONG(&_22$$15, zephir_fast_count_int(&rowA));
-						ZEPHIR_INIT_NVAR(&_23$$15);
-						ZEPHIR_CONCAT_SSVSVSVS(&_23$$15, "The number of", " columns must be equal for all rows, ", &_21$$15, " needed but ", &_22$$15, " given at row offset ", &i, ".");
-						ZEPHIR_CALL_METHOD(NULL, &_20$$15, "__construct", NULL, 3, &_23$$15);
-						zephir_check_call_status();
-						zephir_throw_exception_debug(&_20$$15, "tensor/matrix.zep", 449);
-						ZEPHIR_MM_RESTORE();
-						return;
-					}
-				}
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_25$$10);
-					zephir_string_to_char_array(&_25$$10, &rowA);
-					_24$$10 = &_25$$10;
-				} else {
-					_24$$10 = &rowA;
-				}
-				zephir_is_iterable(_24$$10, 0, "tensor/matrix.zep", 456);
-				if (Z_TYPE_P(_24$$10) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_24$$10), _26$$10)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _26$$10);
-						ZEPHIR_INIT_NVAR(&_27$$16);
-						ZEPHIR_CALL_FUNCTION(&_28$$16, "is_float", &_29, 2, &valueA);
-						zephir_check_call_status();
-						if (zephir_is_true(&_28$$16)) {
-							ZEPHIR_CPY_WRT(&_27$$16, &valueA);
-						} else {
-							ZEPHIR_INIT_NVAR(&_27$$16);
-							ZVAL_DOUBLE(&_27$$16, zephir_get_doubleval(&valueA));
-						}
-						zephir_array_append(&flat, &_27$$16, PH_SEPARATE, "tensor/matrix.zep", 454);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _24$$10, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_31$$10 = 1;
-					while (1) {
-						if (_31$$10) {
-							_31$$10 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _24$$10, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_30$$10, _24$$10, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_30$$10)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _24$$10, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_32$$17);
-							ZEPHIR_CALL_FUNCTION(&_33$$17, "is_float", &_29, 2, &valueA);
-							zephir_check_call_status();
-							if (zephir_is_true(&_33$$17)) {
-								ZEPHIR_CPY_WRT(&_32$$17, &valueA);
-							} else {
-								ZEPHIR_INIT_NVAR(&_32$$17);
-								ZVAL_DOUBLE(&_32$$17, zephir_get_doubleval(&valueA));
-							}
-							zephir_array_append(&flat, &_32$$17, PH_SEPARATE, "tensor/matrix.zep", 454);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueA);
-			} ZEND_HASH_FOREACH_END();
+	if (UNEXPECTED(Z_TYPE_P(a) == IS_ARRAY)) {
+		rows$$3 = zephir_fast_count_int(a);
+		ZEPHIR_INIT_VAR(&flat$$3);
+		array_init(&flat$$3);
+		ZEPHIR_CALL_FUNCTION(&_0$$3, "current", NULL, 27, a);
+		zephir_check_call_status();
+		if (!(zephir_is_true(&_0$$3))) {
+			ZEPHIR_INIT_VAR(&firstRow);
+			array_init(&firstRow);
 		} else {
-			ZEPHIR_CALL_METHOD(NULL, _6$$9, "rewind", NULL, 0);
+			ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 27, a);
 			zephir_check_call_status();
-			_35$$9 = 1;
-			while (1) {
-				if (_35$$9) {
-					_35$$9 = 0;
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _6$$9, "next", NULL, 0);
-					zephir_check_call_status();
-				}
-				ZEPHIR_CALL_METHOD(&_34$$9, _6$$9, "valid", NULL, 0);
-				zephir_check_call_status();
-				if (!zend_is_true(&_34$$9)) {
-					break;
-				}
-				ZEPHIR_CALL_METHOD(&i, _6$$9, "key", NULL, 0);
-				zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(&rowA, _6$$9, "current", NULL, 0);
+		}
+		if (Z_TYPE_P(&firstRow) == IS_OBJECT) {
+			if (UNEXPECTED(!((zephir_instance_of_ev(&firstRow, tensor_tensorbuffer_ce))))) {
+				ZEPHIR_INIT_VAR(&_1$$7);
+				object_init_ex(&_1$$7, tensor_exceptions_invalidargumentexception_ce);
+				ZEPHIR_INIT_VAR(&_2$$7);
+				ZEPHIR_CONCAT_SS(&_2$$7, "Matrix requires an", " array of arrays.");
+				ZEPHIR_CALL_METHOD(NULL, &_1$$7, "__construct", NULL, 3, &_2$$7);
 				zephir_check_call_status();
+				zephir_throw_exception_debug(&_1$$7, "tensor/matrix.zep", 408);
+				ZEPHIR_MM_RESTORE();
+				return;
+			}
+			ZEPHIR_CALL_METHOD(&nHat$$3, &firstRow, "count", NULL, 0);
+			zephir_check_call_status();
+			ZEPHIR_CPY_WRT(&nHat$$3, &nHat$$3);
+		} else {
+			ZEPHIR_INIT_NVAR(&nHat$$3);
+			ZVAL_LONG(&nHat$$3, zephir_fast_count_int(&firstRow));
+		}
+		if (validate) {
+			ZEPHIR_CALL_FUNCTION(&_3$$9, "array_values", NULL, 26, a);
+			zephir_check_call_status();
+			ZEPHIR_CPY_WRT(a, &_3$$9);
+			if (Z_TYPE_P(a) == IS_STRING) {
+				ZEPHIR_INIT_VAR(&_5$$9);
+				zephir_string_to_char_array(&_5$$9, a);
+				_4$$9 = &_5$$9;
+			} else {
+				_4$$9 = a;
+			}
+			zephir_is_iterable(_4$$9, 0, "tensor/matrix.zep", 447);
+			if (Z_TYPE_P(_4$$9) == IS_ARRAY) {
+				ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_4$$9), _7$$9, _8$$9, _6$$9)
+				{
+					ZEPHIR_INIT_NVAR(&i);
+					if (_8$$9 != NULL) { 
+						ZVAL_STR_COPY(&i, _8$$9);
+					} else {
+						ZVAL_LONG(&i, _7$$9);
+					}
+					ZEPHIR_INIT_NVAR(&rowA);
+					ZVAL_COPY(&rowA, _6$$9);
 					if (Z_TYPE_P(&rowA) == IS_OBJECT) {
 						if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
-							ZEPHIR_INIT_NVAR(&_36$$20);
-							object_init_ex(&_36$$20, tensor_exceptions_invalidargumentexception_ce);
-							ZEPHIR_INIT_NVAR(&_37$$20);
-							ZEPHIR_CONCAT_SS(&_37$$20, "Matrix requires an", " array of arrays.");
-							ZEPHIR_CALL_METHOD(NULL, &_36$$20, "__construct", NULL, 3, &_37$$20);
+							ZEPHIR_INIT_NVAR(&_9$$12);
+							object_init_ex(&_9$$12, tensor_exceptions_invalidargumentexception_ce);
+							ZEPHIR_INIT_NVAR(&_10$$12);
+							ZEPHIR_CONCAT_SS(&_10$$12, "Matrix requires an", " array of arrays.");
+							ZEPHIR_CALL_METHOD(NULL, &_9$$12, "__construct", NULL, 3, &_10$$12);
 							zephir_check_call_status();
-							zephir_throw_exception_debug(&_36$$20, "tensor/matrix.zep", 433);
+							zephir_throw_exception_debug(&_9$$12, "tensor/matrix.zep", 423);
 							ZEPHIR_MM_RESTORE();
 							return;
 						}
-						ZEPHIR_CALL_METHOD(&_38$$19, &rowA, "count", NULL, 0);
+						ZEPHIR_CALL_METHOD(&_11$$11, &rowA, "count", NULL, 0);
 						zephir_check_call_status();
-						if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_38$$19, &n))) {
-							ZEPHIR_INIT_NVAR(&_39$$21);
-							object_init_ex(&_39$$21, tensor_exceptions_invalidargumentexception_ce);
-							ZEPHIR_CALL_FUNCTION(&_40$$21, "strval", &_16, 4, &n);
+						if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_11$$11, &nHat$$3))) {
+							ZEPHIR_INIT_NVAR(&_12$$13);
+							object_init_ex(&_12$$13, tensor_exceptions_invalidargumentexception_ce);
+							ZEPHIR_CALL_FUNCTION(&_13$$13, "strval", &_14, 4, &nHat$$3);
 							zephir_check_call_status();
-							ZEPHIR_CALL_METHOD(&_41$$21, &rowA, "count", NULL, 0);
+							ZEPHIR_CALL_METHOD(&_15$$13, &rowA, "count", NULL, 0);
 							zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_42$$21);
-							ZEPHIR_CONCAT_SSVSVSVS(&_42$$21, "The number of", " columns must be equal for all rows, ", &_40$$21, " needed but ", &_41$$21, " given at row offset ", &i, ".");
-							ZEPHIR_CALL_METHOD(NULL, &_39$$21, "__construct", NULL, 3, &_42$$21);
+							ZEPHIR_INIT_NVAR(&_16$$13);
+							ZEPHIR_CONCAT_SSVSVSVS(&_16$$13, "The number of", " columns must be equal for all rows, ", &_13$$13, " needed but ", &_15$$13, " given at row offset ", &i, ".");
+							ZEPHIR_CALL_METHOD(NULL, &_12$$13, "__construct", NULL, 3, &_16$$13);
 							zephir_check_call_status();
-							zephir_throw_exception_debug(&_39$$21, "tensor/matrix.zep", 440);
+							zephir_throw_exception_debug(&_12$$13, "tensor/matrix.zep", 430);
 							ZEPHIR_MM_RESTORE();
 							return;
 						}
-						ZEPHIR_CALL_METHOD(&_43$$19, &rowA, "toArray", NULL, 0);
+						ZEPHIR_CALL_METHOD(&_17$$11, &rowA, "toArray", NULL, 0);
 						zephir_check_call_status();
-						ZEPHIR_CPY_WRT(&rowA, &_43$$19);
+						ZEPHIR_CPY_WRT(&rowA, &_17$$11);
 					} else {
-						if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA)))) {
-							ZEPHIR_INIT_NVAR(&_44$$23);
-							object_init_ex(&_44$$23, tensor_exceptions_invalidargumentexception_ce);
-							ZEPHIR_CALL_FUNCTION(&_45$$23, "strval", &_16, 4, &n);
+						if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&nHat$$3, zephir_fast_count_int(&rowA)))) {
+							ZEPHIR_INIT_NVAR(&_18$$15);
+							object_init_ex(&_18$$15, tensor_exceptions_invalidargumentexception_ce);
+							ZEPHIR_CALL_FUNCTION(&_19$$15, "strval", &_14, 4, &nHat$$3);
 							zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_46$$23);
-							ZVAL_LONG(&_46$$23, zephir_fast_count_int(&rowA));
-							ZEPHIR_INIT_NVAR(&_47$$23);
-							ZEPHIR_CONCAT_SSVSVSVS(&_47$$23, "The number of", " columns must be equal for all rows, ", &_45$$23, " needed but ", &_46$$23, " given at row offset ", &i, ".");
-							ZEPHIR_CALL_METHOD(NULL, &_44$$23, "__construct", NULL, 3, &_47$$23);
+							ZEPHIR_INIT_NVAR(&_20$$15);
+							ZVAL_LONG(&_20$$15, zephir_fast_count_int(&rowA));
+							ZEPHIR_INIT_NVAR(&_21$$15);
+							ZEPHIR_CONCAT_SSVSVSVS(&_21$$15, "The number of", " columns must be equal for all rows, ", &_19$$15, " needed but ", &_20$$15, " given at row offset ", &i, ".");
+							ZEPHIR_CALL_METHOD(NULL, &_18$$15, "__construct", NULL, 3, &_21$$15);
 							zephir_check_call_status();
-							zephir_throw_exception_debug(&_44$$23, "tensor/matrix.zep", 449);
+							zephir_throw_exception_debug(&_18$$15, "tensor/matrix.zep", 439);
 							ZEPHIR_MM_RESTORE();
 							return;
 						}
 					}
 					if (Z_TYPE_P(&rowA) == IS_STRING) {
-						ZEPHIR_INIT_NVAR(&_49$$18);
-						zephir_string_to_char_array(&_49$$18, &rowA);
-						_48$$18 = &_49$$18;
+						ZEPHIR_INIT_NVAR(&_23$$10);
+						zephir_string_to_char_array(&_23$$10, &rowA);
+						_22$$10 = &_23$$10;
 					} else {
-						_48$$18 = &rowA;
+						_22$$10 = &rowA;
 					}
-					zephir_is_iterable(_48$$18, 0, "tensor/matrix.zep", 456);
-					if (Z_TYPE_P(_48$$18) == IS_ARRAY) {
-						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_48$$18), _50$$18)
+					zephir_is_iterable(_22$$10, 0, "tensor/matrix.zep", 446);
+					if (Z_TYPE_P(_22$$10) == IS_ARRAY) {
+						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_22$$10), _24$$10)
 						{
 							ZEPHIR_INIT_NVAR(&valueA);
-							ZVAL_COPY(&valueA, _50$$18);
-							ZEPHIR_INIT_NVAR(&_51$$24);
-							ZEPHIR_CALL_FUNCTION(&_52$$24, "is_float", &_29, 2, &valueA);
+							ZVAL_COPY(&valueA, _24$$10);
+							ZEPHIR_INIT_NVAR(&_25$$16);
+							ZEPHIR_CALL_FUNCTION(&_26$$16, "is_float", &_27, 2, &valueA);
 							zephir_check_call_status();
-							if (zephir_is_true(&_52$$24)) {
-								ZEPHIR_CPY_WRT(&_51$$24, &valueA);
+							if (zephir_is_true(&_26$$16)) {
+								ZEPHIR_CPY_WRT(&_25$$16, &valueA);
 							} else {
-								ZEPHIR_INIT_NVAR(&_51$$24);
-								ZVAL_DOUBLE(&_51$$24, zephir_get_doubleval(&valueA));
+								ZEPHIR_INIT_NVAR(&_25$$16);
+								ZVAL_DOUBLE(&_25$$16, zephir_get_doubleval(&valueA));
 							}
-							zephir_array_append(&flat, &_51$$24, PH_SEPARATE, "tensor/matrix.zep", 454);
+							zephir_array_append(&flat$$3, &_25$$16, PH_SEPARATE, "tensor/matrix.zep", 444);
 						} ZEND_HASH_FOREACH_END();
 					} else {
-						ZEPHIR_CALL_METHOD(NULL, _48$$18, "rewind", NULL, 0);
+						ZEPHIR_CALL_METHOD(NULL, _22$$10, "rewind", NULL, 0);
 						zephir_check_call_status();
-						_54$$18 = 1;
+						_29$$10 = 1;
 						while (1) {
-							if (_54$$18) {
-								_54$$18 = 0;
+							if (_29$$10) {
+								_29$$10 = 0;
 							} else {
-								ZEPHIR_CALL_METHOD(NULL, _48$$18, "next", NULL, 0);
+								ZEPHIR_CALL_METHOD(NULL, _22$$10, "next", NULL, 0);
 								zephir_check_call_status();
 							}
-							ZEPHIR_CALL_METHOD(&_53$$18, _48$$18, "valid", NULL, 0);
+							ZEPHIR_CALL_METHOD(&_28$$10, _22$$10, "valid", NULL, 0);
 							zephir_check_call_status();
-							if (!zend_is_true(&_53$$18)) {
+							if (!zend_is_true(&_28$$10)) {
 								break;
 							}
-							ZEPHIR_CALL_METHOD(&valueA, _48$$18, "current", NULL, 0);
+							ZEPHIR_CALL_METHOD(&valueA, _22$$10, "current", NULL, 0);
 							zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_55$$25);
-								ZEPHIR_CALL_FUNCTION(&_56$$25, "is_float", &_29, 2, &valueA);
+								ZEPHIR_INIT_NVAR(&_30$$17);
+								ZEPHIR_CALL_FUNCTION(&_31$$17, "is_float", &_27, 2, &valueA);
 								zephir_check_call_status();
-								if (zephir_is_true(&_56$$25)) {
-									ZEPHIR_CPY_WRT(&_55$$25, &valueA);
+								if (zephir_is_true(&_31$$17)) {
+									ZEPHIR_CPY_WRT(&_30$$17, &valueA);
 								} else {
-									ZEPHIR_INIT_NVAR(&_55$$25);
-									ZVAL_DOUBLE(&_55$$25, zephir_get_doubleval(&valueA));
+									ZEPHIR_INIT_NVAR(&_30$$17);
+									ZVAL_DOUBLE(&_30$$17, zephir_get_doubleval(&valueA));
 								}
-								zephir_array_append(&flat, &_55$$25, PH_SEPARATE, "tensor/matrix.zep", 454);
+								zephir_array_append(&flat$$3, &_30$$17, PH_SEPARATE, "tensor/matrix.zep", 444);
 						}
 					}
 					ZEPHIR_INIT_NVAR(&valueA);
-			}
-		}
-		ZEPHIR_INIT_NVAR(&rowA);
-		ZEPHIR_INIT_NVAR(&i);
-	} else {
-		if (Z_TYPE_P(a) == IS_STRING) {
-			ZEPHIR_INIT_VAR(&_58$$26);
-			zephir_string_to_char_array(&_58$$26, a);
-			_57$$26 = &_58$$26;
-		} else {
-			_57$$26 = a;
-		}
-		zephir_is_iterable(_57$$26, 0, "tensor/matrix.zep", 467);
-		if (Z_TYPE_P(_57$$26) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_57$$26), _59$$26)
-			{
-				ZEPHIR_INIT_NVAR(&rowA);
-				ZVAL_COPY(&rowA, _59$$26);
-				if (Z_TYPE_P(&rowA) == IS_OBJECT) {
-					ZEPHIR_CALL_METHOD(&_60$$28, &rowA, "toArray", NULL, 0);
+				} ZEND_HASH_FOREACH_END();
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _4$$9, "rewind", NULL, 0);
+				zephir_check_call_status();
+				_33$$9 = 1;
+				while (1) {
+					if (_33$$9) {
+						_33$$9 = 0;
+					} else {
+						ZEPHIR_CALL_METHOD(NULL, _4$$9, "next", NULL, 0);
+						zephir_check_call_status();
+					}
+					ZEPHIR_CALL_METHOD(&_32$$9, _4$$9, "valid", NULL, 0);
 					zephir_check_call_status();
-					ZEPHIR_CPY_WRT(&rowA, &_60$$28);
-				}
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_62$$27);
-					zephir_string_to_char_array(&_62$$27, &rowA);
-					_61$$27 = &_62$$27;
-				} else {
-					_61$$27 = &rowA;
-				}
-				zephir_is_iterable(_61$$27, 0, "tensor/matrix.zep", 466);
-				if (Z_TYPE_P(_61$$27) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_61$$27), _63$$27)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _63$$27);
-						ZEPHIR_INIT_NVAR(&_64$$29);
-						ZVAL_DOUBLE(&_64$$29, zephir_get_doubleval(&valueA));
-						zephir_array_append(&flat, &_64$$29, PH_SEPARATE, "tensor/matrix.zep", 464);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _61$$27, "rewind", NULL, 0);
+					if (!zend_is_true(&_32$$9)) {
+						break;
+					}
+					ZEPHIR_CALL_METHOD(&i, _4$$9, "key", NULL, 0);
 					zephir_check_call_status();
-					_66$$27 = 1;
-					while (1) {
-						if (_66$$27) {
-							_66$$27 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _61$$27, "next", NULL, 0);
+					ZEPHIR_CALL_METHOD(&rowA, _4$$9, "current", NULL, 0);
+					zephir_check_call_status();
+						if (Z_TYPE_P(&rowA) == IS_OBJECT) {
+							if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
+								ZEPHIR_INIT_NVAR(&_34$$20);
+								object_init_ex(&_34$$20, tensor_exceptions_invalidargumentexception_ce);
+								ZEPHIR_INIT_NVAR(&_35$$20);
+								ZEPHIR_CONCAT_SS(&_35$$20, "Matrix requires an", " array of arrays.");
+								ZEPHIR_CALL_METHOD(NULL, &_34$$20, "__construct", NULL, 3, &_35$$20);
+								zephir_check_call_status();
+								zephir_throw_exception_debug(&_34$$20, "tensor/matrix.zep", 423);
+								ZEPHIR_MM_RESTORE();
+								return;
+							}
+							ZEPHIR_CALL_METHOD(&_36$$19, &rowA, "count", NULL, 0);
 							zephir_check_call_status();
+							if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_36$$19, &nHat$$3))) {
+								ZEPHIR_INIT_NVAR(&_37$$21);
+								object_init_ex(&_37$$21, tensor_exceptions_invalidargumentexception_ce);
+								ZEPHIR_CALL_FUNCTION(&_38$$21, "strval", &_14, 4, &nHat$$3);
+								zephir_check_call_status();
+								ZEPHIR_CALL_METHOD(&_39$$21, &rowA, "count", NULL, 0);
+								zephir_check_call_status();
+								ZEPHIR_INIT_NVAR(&_40$$21);
+								ZEPHIR_CONCAT_SSVSVSVS(&_40$$21, "The number of", " columns must be equal for all rows, ", &_38$$21, " needed but ", &_39$$21, " given at row offset ", &i, ".");
+								ZEPHIR_CALL_METHOD(NULL, &_37$$21, "__construct", NULL, 3, &_40$$21);
+								zephir_check_call_status();
+								zephir_throw_exception_debug(&_37$$21, "tensor/matrix.zep", 430);
+								ZEPHIR_MM_RESTORE();
+								return;
+							}
+							ZEPHIR_CALL_METHOD(&_41$$19, &rowA, "toArray", NULL, 0);
+							zephir_check_call_status();
+							ZEPHIR_CPY_WRT(&rowA, &_41$$19);
+						} else {
+							if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&nHat$$3, zephir_fast_count_int(&rowA)))) {
+								ZEPHIR_INIT_NVAR(&_42$$23);
+								object_init_ex(&_42$$23, tensor_exceptions_invalidargumentexception_ce);
+								ZEPHIR_CALL_FUNCTION(&_43$$23, "strval", &_14, 4, &nHat$$3);
+								zephir_check_call_status();
+								ZEPHIR_INIT_NVAR(&_44$$23);
+								ZVAL_LONG(&_44$$23, zephir_fast_count_int(&rowA));
+								ZEPHIR_INIT_NVAR(&_45$$23);
+								ZEPHIR_CONCAT_SSVSVSVS(&_45$$23, "The number of", " columns must be equal for all rows, ", &_43$$23, " needed but ", &_44$$23, " given at row offset ", &i, ".");
+								ZEPHIR_CALL_METHOD(NULL, &_42$$23, "__construct", NULL, 3, &_45$$23);
+								zephir_check_call_status();
+								zephir_throw_exception_debug(&_42$$23, "tensor/matrix.zep", 439);
+								ZEPHIR_MM_RESTORE();
+								return;
+							}
 						}
-						ZEPHIR_CALL_METHOD(&_65$$27, _61$$27, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_65$$27)) {
-							break;
+						if (Z_TYPE_P(&rowA) == IS_STRING) {
+							ZEPHIR_INIT_NVAR(&_47$$18);
+							zephir_string_to_char_array(&_47$$18, &rowA);
+							_46$$18 = &_47$$18;
+						} else {
+							_46$$18 = &rowA;
 						}
-						ZEPHIR_CALL_METHOD(&valueA, _61$$27, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_67$$30);
-							ZVAL_DOUBLE(&_67$$30, zephir_get_doubleval(&valueA));
-							zephir_array_append(&flat, &_67$$30, PH_SEPARATE, "tensor/matrix.zep", 464);
-					}
+						zephir_is_iterable(_46$$18, 0, "tensor/matrix.zep", 446);
+						if (Z_TYPE_P(_46$$18) == IS_ARRAY) {
+							ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_46$$18), _48$$18)
+							{
+								ZEPHIR_INIT_NVAR(&valueA);
+								ZVAL_COPY(&valueA, _48$$18);
+								ZEPHIR_INIT_NVAR(&_49$$24);
+								ZEPHIR_CALL_FUNCTION(&_50$$24, "is_float", &_27, 2, &valueA);
+								zephir_check_call_status();
+								if (zephir_is_true(&_50$$24)) {
+									ZEPHIR_CPY_WRT(&_49$$24, &valueA);
+								} else {
+									ZEPHIR_INIT_NVAR(&_49$$24);
+									ZVAL_DOUBLE(&_49$$24, zephir_get_doubleval(&valueA));
+								}
+								zephir_array_append(&flat$$3, &_49$$24, PH_SEPARATE, "tensor/matrix.zep", 444);
+							} ZEND_HASH_FOREACH_END();
+						} else {
+							ZEPHIR_CALL_METHOD(NULL, _46$$18, "rewind", NULL, 0);
+							zephir_check_call_status();
+							_52$$18 = 1;
+							while (1) {
+								if (_52$$18) {
+									_52$$18 = 0;
+								} else {
+									ZEPHIR_CALL_METHOD(NULL, _46$$18, "next", NULL, 0);
+									zephir_check_call_status();
+								}
+								ZEPHIR_CALL_METHOD(&_51$$18, _46$$18, "valid", NULL, 0);
+								zephir_check_call_status();
+								if (!zend_is_true(&_51$$18)) {
+									break;
+								}
+								ZEPHIR_CALL_METHOD(&valueA, _46$$18, "current", NULL, 0);
+								zephir_check_call_status();
+									ZEPHIR_INIT_NVAR(&_53$$25);
+									ZEPHIR_CALL_FUNCTION(&_54$$25, "is_float", &_27, 2, &valueA);
+									zephir_check_call_status();
+									if (zephir_is_true(&_54$$25)) {
+										ZEPHIR_CPY_WRT(&_53$$25, &valueA);
+									} else {
+										ZEPHIR_INIT_NVAR(&_53$$25);
+										ZVAL_DOUBLE(&_53$$25, zephir_get_doubleval(&valueA));
+									}
+									zephir_array_append(&flat$$3, &_53$$25, PH_SEPARATE, "tensor/matrix.zep", 444);
+							}
+						}
+						ZEPHIR_INIT_NVAR(&valueA);
 				}
-				ZEPHIR_INIT_NVAR(&valueA);
-			} ZEND_HASH_FOREACH_END();
+			}
+			ZEPHIR_INIT_NVAR(&rowA);
+			ZEPHIR_INIT_NVAR(&i);
 		} else {
-			ZEPHIR_CALL_METHOD(NULL, _57$$26, "rewind", NULL, 0);
-			zephir_check_call_status();
-			_69$$26 = 1;
-			while (1) {
-				if (_69$$26) {
-					_69$$26 = 0;
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _57$$26, "next", NULL, 0);
-					zephir_check_call_status();
-				}
-				ZEPHIR_CALL_METHOD(&_68$$26, _57$$26, "valid", NULL, 0);
-				zephir_check_call_status();
-				if (!zend_is_true(&_68$$26)) {
-					break;
-				}
-				ZEPHIR_CALL_METHOD(&rowA, _57$$26, "current", NULL, 0);
-				zephir_check_call_status();
+			if (Z_TYPE_P(a) == IS_STRING) {
+				ZEPHIR_INIT_VAR(&_56$$26);
+				zephir_string_to_char_array(&_56$$26, a);
+				_55$$26 = &_56$$26;
+			} else {
+				_55$$26 = a;
+			}
+			zephir_is_iterable(_55$$26, 0, "tensor/matrix.zep", 457);
+			if (Z_TYPE_P(_55$$26) == IS_ARRAY) {
+				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_55$$26), _57$$26)
+				{
+					ZEPHIR_INIT_NVAR(&rowA);
+					ZVAL_COPY(&rowA, _57$$26);
 					if (Z_TYPE_P(&rowA) == IS_OBJECT) {
-						ZEPHIR_CALL_METHOD(&_70$$32, &rowA, "toArray", NULL, 0);
+						ZEPHIR_CALL_METHOD(&_58$$28, &rowA, "toArray", NULL, 0);
 						zephir_check_call_status();
-						ZEPHIR_CPY_WRT(&rowA, &_70$$32);
+						ZEPHIR_CPY_WRT(&rowA, &_58$$28);
 					}
 					if (Z_TYPE_P(&rowA) == IS_STRING) {
-						ZEPHIR_INIT_NVAR(&_72$$31);
-						zephir_string_to_char_array(&_72$$31, &rowA);
-						_71$$31 = &_72$$31;
+						ZEPHIR_INIT_NVAR(&_60$$27);
+						zephir_string_to_char_array(&_60$$27, &rowA);
+						_59$$27 = &_60$$27;
 					} else {
-						_71$$31 = &rowA;
+						_59$$27 = &rowA;
 					}
-					zephir_is_iterable(_71$$31, 0, "tensor/matrix.zep", 466);
-					if (Z_TYPE_P(_71$$31) == IS_ARRAY) {
-						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_71$$31), _73$$31)
+					zephir_is_iterable(_59$$27, 0, "tensor/matrix.zep", 456);
+					if (Z_TYPE_P(_59$$27) == IS_ARRAY) {
+						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_59$$27), _61$$27)
 						{
 							ZEPHIR_INIT_NVAR(&valueA);
-							ZVAL_COPY(&valueA, _73$$31);
-							ZEPHIR_INIT_NVAR(&_74$$33);
-							ZVAL_DOUBLE(&_74$$33, zephir_get_doubleval(&valueA));
-							zephir_array_append(&flat, &_74$$33, PH_SEPARATE, "tensor/matrix.zep", 464);
+							ZVAL_COPY(&valueA, _61$$27);
+							ZEPHIR_INIT_NVAR(&_62$$29);
+							ZVAL_DOUBLE(&_62$$29, zephir_get_doubleval(&valueA));
+							zephir_array_append(&flat$$3, &_62$$29, PH_SEPARATE, "tensor/matrix.zep", 454);
 						} ZEND_HASH_FOREACH_END();
 					} else {
-						ZEPHIR_CALL_METHOD(NULL, _71$$31, "rewind", NULL, 0);
+						ZEPHIR_CALL_METHOD(NULL, _59$$27, "rewind", NULL, 0);
 						zephir_check_call_status();
-						_76$$31 = 1;
+						_64$$27 = 1;
 						while (1) {
-							if (_76$$31) {
-								_76$$31 = 0;
+							if (_64$$27) {
+								_64$$27 = 0;
 							} else {
-								ZEPHIR_CALL_METHOD(NULL, _71$$31, "next", NULL, 0);
+								ZEPHIR_CALL_METHOD(NULL, _59$$27, "next", NULL, 0);
 								zephir_check_call_status();
 							}
-							ZEPHIR_CALL_METHOD(&_75$$31, _71$$31, "valid", NULL, 0);
+							ZEPHIR_CALL_METHOD(&_63$$27, _59$$27, "valid", NULL, 0);
 							zephir_check_call_status();
-							if (!zend_is_true(&_75$$31)) {
+							if (!zend_is_true(&_63$$27)) {
 								break;
 							}
-							ZEPHIR_CALL_METHOD(&valueA, _71$$31, "current", NULL, 0);
+							ZEPHIR_CALL_METHOD(&valueA, _59$$27, "current", NULL, 0);
 							zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_77$$34);
-								ZVAL_DOUBLE(&_77$$34, zephir_get_doubleval(&valueA));
-								zephir_array_append(&flat, &_77$$34, PH_SEPARATE, "tensor/matrix.zep", 464);
+								ZEPHIR_INIT_NVAR(&_65$$30);
+								ZVAL_DOUBLE(&_65$$30, zephir_get_doubleval(&valueA));
+								zephir_array_append(&flat$$3, &_65$$30, PH_SEPARATE, "tensor/matrix.zep", 454);
 						}
 					}
 					ZEPHIR_INIT_NVAR(&valueA);
+				} ZEND_HASH_FOREACH_END();
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _55$$26, "rewind", NULL, 0);
+				zephir_check_call_status();
+				_67$$26 = 1;
+				while (1) {
+					if (_67$$26) {
+						_67$$26 = 0;
+					} else {
+						ZEPHIR_CALL_METHOD(NULL, _55$$26, "next", NULL, 0);
+						zephir_check_call_status();
+					}
+					ZEPHIR_CALL_METHOD(&_66$$26, _55$$26, "valid", NULL, 0);
+					zephir_check_call_status();
+					if (!zend_is_true(&_66$$26)) {
+						break;
+					}
+					ZEPHIR_CALL_METHOD(&rowA, _55$$26, "current", NULL, 0);
+					zephir_check_call_status();
+						if (Z_TYPE_P(&rowA) == IS_OBJECT) {
+							ZEPHIR_CALL_METHOD(&_68$$32, &rowA, "toArray", NULL, 0);
+							zephir_check_call_status();
+							ZEPHIR_CPY_WRT(&rowA, &_68$$32);
+						}
+						if (Z_TYPE_P(&rowA) == IS_STRING) {
+							ZEPHIR_INIT_NVAR(&_70$$31);
+							zephir_string_to_char_array(&_70$$31, &rowA);
+							_69$$31 = &_70$$31;
+						} else {
+							_69$$31 = &rowA;
+						}
+						zephir_is_iterable(_69$$31, 0, "tensor/matrix.zep", 456);
+						if (Z_TYPE_P(_69$$31) == IS_ARRAY) {
+							ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_69$$31), _71$$31)
+							{
+								ZEPHIR_INIT_NVAR(&valueA);
+								ZVAL_COPY(&valueA, _71$$31);
+								ZEPHIR_INIT_NVAR(&_72$$33);
+								ZVAL_DOUBLE(&_72$$33, zephir_get_doubleval(&valueA));
+								zephir_array_append(&flat$$3, &_72$$33, PH_SEPARATE, "tensor/matrix.zep", 454);
+							} ZEND_HASH_FOREACH_END();
+						} else {
+							ZEPHIR_CALL_METHOD(NULL, _69$$31, "rewind", NULL, 0);
+							zephir_check_call_status();
+							_74$$31 = 1;
+							while (1) {
+								if (_74$$31) {
+									_74$$31 = 0;
+								} else {
+									ZEPHIR_CALL_METHOD(NULL, _69$$31, "next", NULL, 0);
+									zephir_check_call_status();
+								}
+								ZEPHIR_CALL_METHOD(&_73$$31, _69$$31, "valid", NULL, 0);
+								zephir_check_call_status();
+								if (!zend_is_true(&_73$$31)) {
+									break;
+								}
+								ZEPHIR_CALL_METHOD(&valueA, _69$$31, "current", NULL, 0);
+								zephir_check_call_status();
+									ZEPHIR_INIT_NVAR(&_75$$34);
+									ZVAL_DOUBLE(&_75$$34, zephir_get_doubleval(&valueA));
+									zephir_array_append(&flat$$3, &_75$$34, PH_SEPARATE, "tensor/matrix.zep", 454);
+							}
+						}
+						ZEPHIR_INIT_NVAR(&valueA);
+				}
 			}
+			ZEPHIR_INIT_NVAR(&rowA);
 		}
-		ZEPHIR_INIT_NVAR(&rowA);
+		ZEPHIR_INIT_VAR(&buffer$$3);
+		tensor_buffer_from_array(&buffer$$3, &flat$$3);
+		ZEPHIR_INIT_VAR(&_76$$3);
+		object_init_ex(&_76$$3, tensor_tensorbuffer_ce);
+		ZEPHIR_CALL_METHOD(NULL, &_76$$3, "__construct", NULL, 14, &buffer$$3);
+		zephir_check_call_status();
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_76$$3);
+		ZVAL_UNDEF(&_77$$3);
+		ZVAL_LONG(&_77$$3, rows$$3);
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_77$$3);
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &nHat$$3);
+	} else if (zephir_instance_of_ev(a, tensor_tensorbuffer_ce)) {
+		if (UNEXPECTED(validate)) {
+			if (UNEXPECTED(m < 1)) {
+				ZEPHIR_INIT_VAR(&_78$$37);
+				object_init_ex(&_78$$37, tensor_exceptions_invalidargumentexception_ce);
+				ZVAL_LONG(&_79$$37, m);
+				ZEPHIR_CALL_FUNCTION(&_80$$37, "strval", &_14, 4, &_79$$37);
+				zephir_check_call_status();
+				ZEPHIR_INIT_VAR(&_81$$37);
+				ZEPHIR_CONCAT_SSVS(&_81$$37, "The number of rows must be", " greater than 0, ", &_80$$37, " given.");
+				ZEPHIR_CALL_METHOD(NULL, &_78$$37, "__construct", NULL, 3, &_81$$37);
+				zephir_check_call_status();
+				zephir_throw_exception_debug(&_78$$37, "tensor/matrix.zep", 468);
+				ZEPHIR_MM_RESTORE();
+				return;
+			}
+			if (UNEXPECTED(n < 1)) {
+				ZEPHIR_INIT_VAR(&_82$$38);
+				object_init_ex(&_82$$38, tensor_exceptions_invalidargumentexception_ce);
+				ZVAL_LONG(&_83$$38, n);
+				ZEPHIR_CALL_FUNCTION(&_84$$38, "strval", &_14, 4, &_83$$38);
+				zephir_check_call_status();
+				ZEPHIR_INIT_VAR(&_85$$38);
+				ZEPHIR_CONCAT_SSVS(&_85$$38, "The number of columns must be", " greater than 0, ", &_84$$38, " given.");
+				ZEPHIR_CALL_METHOD(NULL, &_82$$38, "__construct", NULL, 3, &_85$$38);
+				zephir_check_call_status();
+				zephir_throw_exception_debug(&_82$$38, "tensor/matrix.zep", 473);
+				ZEPHIR_MM_RESTORE();
+				return;
+			}
+			ZEPHIR_CALL_METHOD(&_86$$36, a, "count", NULL, 0);
+			zephir_check_call_status();
+			if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&_86$$36, (m * n)))) {
+				ZEPHIR_INIT_VAR(&_87$$39);
+				object_init_ex(&_87$$39, tensor_exceptions_invalidargumentexception_ce);
+				ZEPHIR_CALL_METHOD(&_88$$39, a, "count", NULL, 0);
+				zephir_check_call_status();
+				ZEPHIR_CALL_FUNCTION(&_89$$39, "strval", &_14, 4, &_88$$39);
+				zephir_check_call_status();
+				ZEPHIR_INIT_VAR(&_90$$39);
+				ZEPHIR_CONCAT_SSVS(&_90$$39, "The number of elements", " in the buffer must equal m times n, ", &_89$$39, " given.");
+				ZEPHIR_CALL_METHOD(NULL, &_87$$39, "__construct", NULL, 3, &_90$$39);
+				zephir_check_call_status();
+				zephir_throw_exception_debug(&_87$$39, "tensor/matrix.zep", 479);
+				ZEPHIR_MM_RESTORE();
+				return;
+			}
+		}
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, a);
+		ZVAL_UNDEF(&_91$$35);
+		ZVAL_LONG(&_91$$35, m);
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_91$$35);
+		ZVAL_UNDEF(&_91$$35);
+		ZVAL_LONG(&_91$$35, n);
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_91$$35);
+	} else {
+		ZEPHIR_INIT_VAR(&_92$$40);
+		object_init_ex(&_92$$40, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_93$$40);
+		ZEPHIR_CONCAT_SS(&_93$$40, "Matrix requires an array", " or TensorBuffer object.");
+		ZEPHIR_CALL_METHOD(NULL, &_92$$40, "__construct", NULL, 3, &_93$$40);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_92$$40, "tensor/matrix.zep", 488);
+		ZEPHIR_MM_RESTORE();
+		return;
 	}
-	ZEPHIR_INIT_VAR(&buffer);
-	tensor_buffer_from_array(&buffer, &flat);
-	ZEPHIR_INIT_VAR(&_78);
-	object_init_ex(&_78, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, &_78, "__construct", NULL, 14, &buffer);
-	zephir_check_call_status();
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_78);
-	ZVAL_UNDEF(&_79);
-	ZVAL_LONG(&_79, m);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_79);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &n);
 	ZEPHIR_MM_RESTORE();
 }
 
@@ -1758,7 +1804,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Row offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 547);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 563);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1828,7 +1874,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Column offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 564);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 580);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1892,7 +1938,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 580);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 596);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1987,7 +2033,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 615);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 631);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -1995,7 +2041,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 612);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 628);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -2017,7 +2063,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 612);
+				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 628);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -2116,7 +2162,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 651);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 667);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -2124,7 +2170,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_CE_STATIC(&_7$$4, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 648);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 664);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -2146,7 +2192,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			zephir_check_call_status();
 				ZEPHIR_CALL_CE_STATIC(&_11$$5, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 648);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 664);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -2218,7 +2264,7 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 670);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 686);
 		}
 	}
 	RETURN_CTOR(&b);
@@ -2270,7 +2316,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 695);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 711);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -2278,7 +2324,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			ZVAL_COPY(&columnBuffer, _4);
 			ZEPHIR_CALL_CE_STATIC(&_5$$4, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 692);
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 708);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -2300,7 +2346,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			zephir_check_call_status();
 				ZEPHIR_CALL_CE_STATIC(&_9$$5, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 692);
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 708);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&columnBuffer);
@@ -2470,7 +2516,7 @@ PHP_METHOD(Tensor_Matrix, reduce)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 752);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 768);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -2483,7 +2529,7 @@ PHP_METHOD(Tensor_Matrix, reduce)
 			} else {
 				_6$$3 = &rowBuffer;
 			}
-			zephir_is_iterable(_6$$3, 0, "tensor/matrix.zep", 750);
+			zephir_is_iterable(_6$$3, 0, "tensor/matrix.zep", 766);
 			if (Z_TYPE_P(_6$$3) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6$$3), _8$$3)
 				{
@@ -2543,7 +2589,7 @@ PHP_METHOD(Tensor_Matrix, reduce)
 				} else {
 					_15$$6 = &rowBuffer;
 				}
-				zephir_is_iterable(_15$$6, 0, "tensor/matrix.zep", 750);
+				zephir_is_iterable(_15$$6, 0, "tensor/matrix.zep", 766);
 				if (Z_TYPE_P(_15$$6) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$6), _17$$6)
 					{
@@ -2590,55 +2636,46 @@ PHP_METHOD(Tensor_Matrix, reduce)
  */
 PHP_METHOD(Tensor_Matrix, transpose)
 {
-	zend_bool _1;
-	zval _0, _4$$3, _5$$3, _6$$3;
-	zval b;
+	zval col, cols, _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0, _2, _3;
-	zephir_fcall_cache_entry *_7 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&col);
+	ZVAL_UNDEF(&cols);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	_3 = (zephir_get_numberval(&_0) - 1);
-	_2 = 0;
-	_1 = 0;
-	if (_2 <= _3) {
-		while (1) {
-			if (_1) {
-				_2++;
-				if (!(_2 <= _3)) {
-					break;
-				}
-			} else {
-				_1 = 1;
-			}
-			i = _2;
-			zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZVAL_LONG(&_5$$3, i);
-			ZEPHIR_CALL_FUNCTION(&_6$$3, "array_column", &_7, 28, &_4$$3, &_5$$3);
-			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 767);
-		}
+	ZEPHIR_CALL_METHOD(&cols, this_ptr, "asColumnBuffers", NULL, 0);
+	zephir_check_call_status();
+	if (UNEXPECTED(zephir_fast_count_int(&cols) < 1)) {
+		ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0);
+		zephir_check_call_status();
+		RETURN_MM();
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
+	zephir_memory_observe(&col);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 786);
+	ZVAL_LONG(&_1, 1);
+	ZEPHIR_CALL_FUNCTION(&_2, "array_slice", NULL, 28, &cols, &_1);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_0, &col, "concat", NULL, 0, &_2);
+	zephir_check_call_status();
+	ZEPHIR_CPY_WRT(&col, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &col, &_1, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2651,8 +2688,8 @@ PHP_METHOD(Tensor_Matrix, transpose)
  */
 PHP_METHOD(Tensor_Matrix, inverse)
 {
-	zval _6$$4, _9$$5;
-	zval _0, _4, result, _7, _1$$3, _2$$3, _3$$3, _5$$4, _8$$5;
+	zval _6$$4, _10$$5;
+	zval _0, _4, result, _7, _8, _11, _12, _1$$3, _2$$3, _3$$3, _5$$4, _9$$5;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -2661,17 +2698,24 @@ PHP_METHOD(Tensor_Matrix, inverse)
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_12);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_8$$5);
-	ZVAL_UNDEF(&_6$$4);
 	ZVAL_UNDEF(&_9$$5);
+	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_10$$5);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
@@ -2686,7 +2730,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 783);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 803);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2699,25 +2743,28 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 29, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 788);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 808);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	tensor_inverse(&result, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_inverse(&result, &_7, &_8);
 	if (Z_TYPE_P(&result) == IS_NULL) {
-		ZEPHIR_INIT_VAR(&_8$$5);
-		object_init_ex(&_8$$5, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_9$$5);
-		ZEPHIR_CONCAT_SS(&_9$$5, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_8$$5, "__construct", NULL, 29, &_9$$5);
+		object_init_ex(&_9$$5, tensor_exceptions_runtimeexception_ce);
+		ZEPHIR_INIT_VAR(&_10$$5);
+		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
+		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 29, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_8$$5, "tensor/matrix.zep", 795);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 815);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &result);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_11, &_12);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2729,38 +2776,54 @@ PHP_METHOD(Tensor_Matrix, inverse)
  */
 PHP_METHOD(Tensor_Matrix, pseudoinverse)
 {
-	zval _2$$3;
-	zval result, _0, _1$$3;
+	zval _4$$3;
+	zval result, _0, _1, _2, _5, _6, _3$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1$$3);
-	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	tensor_pseudoinverse(&result, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_pseudoinverse(&result, &_0, &_1, &_2);
 	if (Z_TYPE_P(&result) == IS_NULL) {
-		ZEPHIR_INIT_VAR(&_1$$3);
-		object_init_ex(&_1$$3, tensor_exceptions_runtimeexception_ce);
-		ZEPHIR_INIT_VAR(&_2$$3);
-		ZEPHIR_CONCAT_SS(&_2$$3, "Failed to compute the pseudoinverse", " of the matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 29, &_2$$3);
+		ZEPHIR_INIT_VAR(&_3$$3);
+		object_init_ex(&_3$$3, tensor_exceptions_runtimeexception_ce);
+		ZEPHIR_INIT_VAR(&_4$$3);
+		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
+		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 29, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 812);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 832);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &result);
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_5, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2803,7 +2866,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 828);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 848);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2889,7 +2952,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 	ZEPHIR_CPY_WRT(&a, &_3);
 	pivots = 0;
 	epsilon =  (0.00000001);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 883);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 903);
 	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _4)
 	{
 		ZEPHIR_INIT_NVAR(&rowA);
@@ -2902,7 +2965,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 		} else {
 			_5$$3 = &rowA;
 		}
-		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 881);
+		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 901);
 		if (Z_TYPE_P(_5$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$3), _7$$3)
 			{
@@ -2987,21 +3050,22 @@ PHP_METHOD(Tensor_Matrix, fullRank)
  */
 PHP_METHOD(Tensor_Matrix, symmetric)
 {
-	zend_bool _2, _7$$4;
-	zval _0, rowA, _1, _5$$4, _6$$4, _10$$5, _11$$5, _12$$5, _13$$5;
+	zend_bool _2, _6$$4;
+	zval _0, _1, _5$$4, _9$$5, _10$$5, _11$$5, _12$$5, _13$$5, _14$$5, _15$$5;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0, j = 0, _3, _4, _8$$4, _9$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0, j = 0, _3, _4, _7$$4, _8$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_9$$5);
 	ZVAL_UNDEF(&_10$$5);
 	ZVAL_UNDEF(&_11$$5);
 	ZVAL_UNDEF(&_12$$5);
 	ZVAL_UNDEF(&_13$$5);
+	ZVAL_UNDEF(&_14$$5);
+	ZVAL_UNDEF(&_15$$5);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
@@ -3009,10 +3073,10 @@ PHP_METHOD(Tensor_Matrix, symmetric)
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("n", 1, 1);
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -3037,31 +3101,31 @@ PHP_METHOD(Tensor_Matrix, symmetric)
 				_2 = 1;
 			}
 			i = _3;
-			zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&rowA);
-			zephir_array_fetch_long(&rowA, &_5$$4, i, PH_NOISY, "tensor/matrix.zep", 912);
-			zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			_9$$4 = (zephir_get_numberval(&_6$$4) - 1);
-			_8$$4 = (i + 1);
-			_7$$4 = 0;
-			if (_8$$4 <= _9$$4) {
+			zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+			_8$$4 = (zephir_get_numberval(&_5$$4) - 1);
+			_7$$4 = (i + 1);
+			_6$$4 = 0;
+			if (_7$$4 <= _8$$4) {
 				while (1) {
-					if (_7$$4) {
-						_8$$4++;
-						if (!(_8$$4 <= _9$$4)) {
+					if (_6$$4) {
+						_7$$4++;
+						if (!(_7$$4 <= _8$$4)) {
 							break;
 						}
 					} else {
-						_7$$4 = 1;
+						_6$$4 = 1;
 					}
-					j = _8$$4;
-					ZEPHIR_OBS_NVAR(&_10$$5);
-					zephir_array_fetch_long(&_10$$5, &rowA, j, PH_NOISY, "tensor/matrix.zep", 915);
-					zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-					ZEPHIR_OBS_NVAR(&_12$$5);
-					zephir_array_fetch_long(&_12$$5, &_11$$5, j, PH_NOISY, "tensor/matrix.zep", 915);
-					ZEPHIR_OBS_NVAR(&_13$$5);
-					zephir_array_fetch_long(&_13$$5, &_12$$5, i, PH_NOISY, "tensor/matrix.zep", 915);
+					j = _7$$4;
+					zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+					zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+					ZVAL_LONG(&_12$$5, ((i * (zend_long) zephir_get_numberval(&_11$$5)) + j));
+					ZEPHIR_CALL_METHOD(&_10$$5, &_9$$5, "get", NULL, 0, &_12$$5);
+					zephir_check_call_status();
+					zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+					zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+					ZVAL_LONG(&_15$$5, ((j * (zend_long) zephir_get_numberval(&_14$$5)) + i));
+					ZEPHIR_CALL_METHOD(&_13$$5, &_12$$5, "get", NULL, 0, &_15$$5);
+					zephir_check_call_status();
 					if (!ZEPHIR_IS_EQUAL(&_10$$5, &_13$$5)) {
 						RETURN_MM_BOOL(0);
 					}
@@ -3084,15 +3148,20 @@ PHP_METHOD(Tensor_Matrix, matmul)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, result, _8, _9, _10, _11, _12, _13, _14, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&_14);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -3101,12 +3170,16 @@ PHP_METHOD(Tensor_Matrix, matmul)
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -3130,16 +3203,22 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_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/matrix.zep", 936);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 952);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&_8);
-	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_12, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_matmul(&result, &_8, &_9, &_10, &_11, &_12);
+	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_14, b, "n", NULL, 0);
 	zephir_check_call_status();
-	tensor_matmul(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_8);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_13, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3198,7 +3277,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements 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", 954);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 972);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3225,8 +3304,8 @@ PHP_METHOD(Tensor_Matrix, convolve)
 	zval _6$$3;
 	zend_bool _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long stride, ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, *stride_param = NULL, _0, _1, _3, _4, _11, _12, _13, _14, _5$$3, _7$$4, _8$$4, _9$$4, _10$$4;
+	zend_long stride, ZEPHIR_LAST_CALL_STATUS, outM, outN;
+	zval *b, b_sub, *stride_param = NULL, _0, _1, _3, _4, result, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _5$$3, _7$$4, _8$$4, _9$$4, _10$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -3234,10 +3313,20 @@ PHP_METHOD(Tensor_Matrix, convolve)
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_12);
 	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_16);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
+	ZVAL_UNDEF(&_21);
+	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_23);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_7$$4);
 	ZVAL_UNDEF(&_8$$4);
@@ -3286,7 +3375,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 3, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 972);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 990);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3300,17 +3389,36 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 3, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 977);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 995);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&_11);
-	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_13, b, "asArray", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_12, b, _zephir_prop_2, 0, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_14, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_15, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_16, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZVAL_LONG(&_14, stride);
-	tensor_convolve_2d(&_11, &_12, &_13, &_14);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_11);
+	ZVAL_LONG(&_17, stride);
+	tensor_convolve_2d(&result, &_11, &_12, &_17, &_13, &_14, &_15, &_16);
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_19, ((zephir_get_numberval(&_18) + stride) - 1));
+	ZVAL_LONG(&_20, stride);
+	ZEPHIR_CALL_FUNCTION(&_21, "intdiv", NULL, 18, &_19, &_20);
+	zephir_check_call_status();
+	outM = zephir_get_intval(&_21);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_20, ((zephir_get_numberval(&_19) + stride) - 1));
+	ZVAL_LONG(&_22, stride);
+	ZEPHIR_CALL_FUNCTION(&_23, "intdiv", NULL, 18, &_20, &_22);
+	zephir_check_call_status();
+	outN = zephir_get_intval(&_23);
+	ZVAL_LONG(&_20, outM);
+	ZVAL_LONG(&_22, outN);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_20, &_22);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3617,7 +3725,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1116);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1139);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3688,7 +3796,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1149);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1172);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3760,7 +3868,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1183);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1206);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3832,7 +3940,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1217);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1240);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3904,7 +4012,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1251);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1274);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3976,7 +4084,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1285);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1308);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4048,7 +4156,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1319);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1342);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4120,7 +4228,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1353);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1376);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4192,7 +4300,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1387);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1410);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4264,7 +4372,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1421);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1444);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4336,7 +4444,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1455);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1478);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4408,7 +4516,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1489);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1512);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4566,12 +4674,12 @@ PHP_METHOD(Tensor_Matrix, expm1)
  */
 PHP_METHOD(Tensor_Matrix, log)
 {
-	zend_bool _16, _12$$4, _23$$7;
-	zval rowB, b;
+	zend_bool _14;
+	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_10 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *base_param = NULL, _0$$3, rowA, valueA, _1, *_2, _3, *_4, _15, *_5$$4, _6$$4, *_7$$4, _11$$4, _8$$5, _9$$5, _13$$6, _14$$6, *_17$$7, _18$$7, *_19$$7, _22$$7, _20$$8, _21$$8, _24$$9, _25$$9;
+	zephir_fcall_cache_entry *_9 = NULL, *_11 = NULL, *_12 = NULL, *_17 = NULL, *_19 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
+	zval *base_param = NULL, _0$$3, rowA, valueA, _1, _2, _3, *_4, _5, *_6, _13, _7$$4, _8$$5, _10$$5, _15$$6, _16$$7, _18$$7;
 	double base;
 	zval *this_ptr = getThis();
 
@@ -4579,26 +4687,25 @@ PHP_METHOD(Tensor_Matrix, log)
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
-	ZVAL_UNDEF(&_15);
-	ZVAL_UNDEF(&_6$$4);
-	ZVAL_UNDEF(&_11$$4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&_7$$4);
 	ZVAL_UNDEF(&_8$$5);
-	ZVAL_UNDEF(&_9$$5);
-	ZVAL_UNDEF(&_13$$6);
-	ZVAL_UNDEF(&_14$$6);
+	ZVAL_UNDEF(&_10$$5);
+	ZVAL_UNDEF(&_15$$6);
+	ZVAL_UNDEF(&_16$$7);
 	ZVAL_UNDEF(&_18$$7);
-	ZVAL_UNDEF(&_22$$7);
-	ZVAL_UNDEF(&_20$$8);
-	ZVAL_UNDEF(&_21$$8);
-	ZVAL_UNDEF(&_24$$9);
-	ZVAL_UNDEF(&_25$$9);
-	ZVAL_UNDEF(&rowB);
 	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(0, 1)
 		Z_PARAM_OPTIONAL
@@ -4619,135 +4726,80 @@ PHP_METHOD(Tensor_Matrix, log)
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	ZEPHIR_INIT_VAR(&rowB);
-	array_init(&rowB);
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_3);
-		zephir_string_to_char_array(&_3, &_1);
-		_2 = &_3;
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_2, &_1, "split", NULL, 0, &_3);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_2) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_5);
+		zephir_string_to_char_array(&_5, &_2);
+		_4 = &_5;
 	} else {
-		_2 = &_1;
+		_4 = &_2;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 1580);
-	if (Z_TYPE_P(_2) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 1608);
+	if (Z_TYPE_P(_4) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _4);
-			ZEPHIR_INIT_NVAR(&rowB);
-			array_init(&rowB);
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_6$$4);
-				zephir_string_to_char_array(&_6$$4, &rowA);
-				_5$$4 = &_6$$4;
-			} else {
-				_5$$4 = &rowA;
-			}
-			zephir_is_iterable(_5$$4, 0, "tensor/matrix.zep", 1577);
-			if (Z_TYPE_P(_5$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$4), _7$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _7$$4);
-					ZVAL_DOUBLE(&_8$$5, base);
-					ZEPHIR_CALL_FUNCTION(&_9$$5, "log", &_10, 8, &valueA, &_8$$5);
-					zephir_check_call_status();
-					zephir_array_append(&rowB, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 1574);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _5$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_12$$4 = 1;
-				while (1) {
-					if (_12$$4) {
-						_12$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _5$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_11$$4, _5$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_11$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _5$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZVAL_DOUBLE(&_13$$6, base);
-						ZEPHIR_CALL_FUNCTION(&_14$$6, "log", &_10, 8, &valueA, &_13$$6);
-						zephir_check_call_status();
-						zephir_array_append(&rowB, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 1574);
+			ZVAL_COPY(&rowA, _6);
+			i = 0;
+			while (1) {
+				zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+				if (!(ZEPHIR_GT_LONG(&_7$$4, i))) {
+					break;
 				}
+				ZVAL_LONG(&_8$$5, i);
+				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_9, 0, &_8$$5);
+				zephir_check_call_status();
+				ZVAL_DOUBLE(&_8$$5, base);
+				ZEPHIR_CALL_FUNCTION(&_10$$5, "log", &_11, 8, &valueA, &_8$$5);
+				zephir_check_call_status();
+				ZVAL_LONG(&_8$$5, i);
+				ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_12, 0, &_8$$5, &_10$$5);
+				zephir_check_call_status();
+				i++;
 			}
-			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1577);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1605);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_16 = 1;
+		_14 = 1;
 		while (1) {
-			if (_16) {
-				_16 = 0;
+			if (_14) {
+				_14 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _2, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _4, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_15, _2, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_13, _4, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
+			if (!zend_is_true(&_13)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _2, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowB);
-				array_init(&rowB);
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_18$$7);
-					zephir_string_to_char_array(&_18$$7, &rowA);
-					_17$$7 = &_18$$7;
-				} else {
-					_17$$7 = &rowA;
-				}
-				zephir_is_iterable(_17$$7, 0, "tensor/matrix.zep", 1577);
-				if (Z_TYPE_P(_17$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$7), _19$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _19$$7);
-						ZVAL_DOUBLE(&_20$$8, base);
-						ZEPHIR_CALL_FUNCTION(&_21$$8, "log", &_10, 8, &valueA, &_20$$8);
-						zephir_check_call_status();
-						zephir_array_append(&rowB, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 1574);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _17$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_23$$7 = 1;
-					while (1) {
-						if (_23$$7) {
-							_23$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _17$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_22$$7, _17$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_22$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _17$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZVAL_DOUBLE(&_24$$9, base);
-							ZEPHIR_CALL_FUNCTION(&_25$$9, "log", &_10, 8, &valueA, &_24$$9);
-							zephir_check_call_status();
-							zephir_array_append(&rowB, &_25$$9, PH_SEPARATE, "tensor/matrix.zep", 1574);
+			ZEPHIR_CALL_METHOD(&rowA, _4, "current", NULL, 0);
+			zephir_check_call_status();
+				i = 0;
+				while (1) {
+					zephir_read_property_cached(&_15$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+					if (!(ZEPHIR_GT_LONG(&_15$$6, i))) {
+						break;
 					}
+					ZVAL_LONG(&_16$$7, i);
+					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_17, 0, &_16$$7);
+					zephir_check_call_status();
+					ZVAL_DOUBLE(&_16$$7, base);
+					ZEPHIR_CALL_FUNCTION(&_18$$7, "log", &_11, 8, &valueA, &_16$$7);
+					zephir_check_call_status();
+					ZVAL_LONG(&_16$$7, i);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_19, 0, &_16$$7, &_18$$7);
+					zephir_check_call_status();
+					i++;
 				}
-				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1577);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1605);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -4970,27 +5022,81 @@ PHP_METHOD(Tensor_Matrix, deg2rad)
  */
 PHP_METHOD(Tensor_Matrix, sum)
 {
-	zval _0, _1, _2;
+	zend_bool _8;
+	zval b;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _6$$3, _9$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
+	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_9$$4);
+	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_INIT_VAR(&_1);
-	ZVAL_STRING(&_1, "array_sum");
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, &_1, &_0);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
+	} else {
+		_3 = &_1;
+	}
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1716);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
+		{
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _5);
+			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1713);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_8 = 1;
+		while (1) {
+			if (_8) {
+				_8 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_7)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
+				zephir_check_call_status();
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1713);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&rowBuffer);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5002,27 +5108,81 @@ PHP_METHOD(Tensor_Matrix, sum)
  */
 PHP_METHOD(Tensor_Matrix, product)
 {
-	zval _0, _1, _2;
+	zend_bool _8;
+	zval b;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _6$$3, _9$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
+	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_9$$4);
+	ZVAL_UNDEF(&b);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_INIT_VAR(&_1);
-	ZVAL_STRING(&_1, "array_product");
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, &_1, &_0);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
+	} else {
+		_3 = &_1;
+	}
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1734);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
+		{
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _5);
+			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1731);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_8 = 1;
+		while (1) {
+			if (_8) {
+				_8 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_7)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
+				zephir_check_call_status();
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1731);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&rowBuffer);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5034,27 +5194,81 @@ PHP_METHOD(Tensor_Matrix, product)
  */
 PHP_METHOD(Tensor_Matrix, min)
 {
-	zval _0, _1, _2;
+	zend_bool _8;
+	zval b;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _6$$3, _9$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
+	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_9$$4);
+	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_INIT_VAR(&_1);
-	ZVAL_STRING(&_1, "min");
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, &_1, &_0);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
+	} else {
+		_3 = &_1;
+	}
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1752);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
+		{
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _5);
+			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1749);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_8 = 1;
+		while (1) {
+			if (_8) {
+				_8 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_7)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
+				zephir_check_call_status();
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1749);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&rowBuffer);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5066,27 +5280,81 @@ PHP_METHOD(Tensor_Matrix, min)
  */
 PHP_METHOD(Tensor_Matrix, max)
 {
-	zval _0, _1, _2;
+	zend_bool _8;
+	zval b;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _6$$3, _9$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
+	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_9$$4);
+	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_INIT_VAR(&_1);
-	ZVAL_STRING(&_1, "max");
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, &_1, &_0);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &_2);
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
+	} else {
+		_3 = &_1;
+	}
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1770);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
+		{
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _5);
+			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1767);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_8 = 1;
+		while (1) {
+			if (_8) {
+				_8 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_7)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
+				zephir_check_call_status();
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1767);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&rowBuffer);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5127,28 +5395,33 @@ PHP_METHOD(Tensor_Matrix, mean)
  */
 PHP_METHOD(Tensor_Matrix, median)
 {
-	zend_bool odd, _12;
+	zend_bool odd, _15;
 	zval b;
-	zval rowA, median, _0, _1, _2, _3, *_4, _5, *_6, _11, _8$$5, _9$$5, _10$$5, _13$$8, _14$$8, _15$$8;
+	zval rowBuffer, median, _0, _1, _2, _3, _4, _5, *_6, _7, *_8, _14, _9$$4, _10$$5, _11$$5, _12$$5, _13$$5, _16$$7, _17$$8, _18$$8, _19$$8, _20$$8;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_7 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, mid;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&median);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_8$$5);
-	ZVAL_UNDEF(&_9$$5);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_9$$4);
 	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_13$$8);
-	ZVAL_UNDEF(&_14$$8);
-	ZVAL_UNDEF(&_15$$8);
+	ZVAL_UNDEF(&_11$$5);
+	ZVAL_UNDEF(&_12$$5);
+	ZVAL_UNDEF(&_13$$5);
+	ZVAL_UNDEF(&_16$$7);
+	ZVAL_UNDEF(&_17$$8);
+	ZVAL_UNDEF(&_18$$8);
+	ZVAL_UNDEF(&_19$$8);
+	ZVAL_UNDEF(&_20$$8);
 	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
@@ -5171,77 +5444,82 @@ PHP_METHOD(Tensor_Matrix, median)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 	odd = zephir_safe_mod_zval_long(&_1, 2) == 1;
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_3) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_5);
-		zephir_string_to_char_array(&_5, &_3);
-		_4 = &_5;
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_4, &_3, "split", NULL, 0, &_5);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_4) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_7);
+		zephir_string_to_char_array(&_7, &_4);
+		_6 = &_7;
 	} else {
-		_4 = &_3;
+		_6 = &_4;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 1749);
-	if (Z_TYPE_P(_4) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1809);
+	if (Z_TYPE_P(_6) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _6);
-			ZEPHIR_MAKE_REF(&rowA);
-			ZEPHIR_CALL_FUNCTION(NULL, "sort", &_7, 19, &rowA);
-			ZEPHIR_UNREF(&rowA);
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _8);
+			ZEPHIR_CALL_METHOD(NULL, &rowBuffer, "sort", NULL, 0);
 			zephir_check_call_status();
 			if (odd) {
-				ZEPHIR_OBS_NVAR(&median);
-				zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1741);
+				ZVAL_LONG(&_9$$4, mid);
+				ZEPHIR_CALL_METHOD(&median, &rowBuffer, "get", NULL, 0, &_9$$4);
+				zephir_check_call_status();
 			} else {
-				ZEPHIR_OBS_NVAR(&_8$$5);
-				zephir_array_fetch_long(&_8$$5, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1743);
-				ZEPHIR_OBS_NVAR(&_9$$5);
-				zephir_array_fetch_long(&_9$$5, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1743);
-				ZEPHIR_INIT_NVAR(&_10$$5);
-				zephir_add_function(&_10$$5, &_8$$5, &_9$$5);
+				ZVAL_LONG(&_11$$5, (mid - 1));
+				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "get", NULL, 0, &_11$$5);
+				zephir_check_call_status();
+				ZVAL_LONG(&_11$$5, mid);
+				ZEPHIR_CALL_METHOD(&_12$$5, &rowBuffer, "get", NULL, 0, &_11$$5);
+				zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_13$$5);
+				zephir_add_function(&_13$$5, &_10$$5, &_12$$5);
 				ZEPHIR_INIT_NVAR(&median);
-				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_10$$5, 2.0));
+				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1746);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1806);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_12 = 1;
+		_15 = 1;
 		while (1) {
-			if (_12) {
-				_12 = 0;
+			if (_15) {
+				_15 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _4, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _6, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_11, _4, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_14, _6, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_11)) {
+			if (!zend_is_true(&_14)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _4, "current", NULL, 0);
+			ZEPHIR_CALL_METHOD(&rowBuffer, _6, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_MAKE_REF(&rowA);
-				ZEPHIR_CALL_FUNCTION(NULL, "sort", &_7, 19, &rowA);
-				ZEPHIR_UNREF(&rowA);
+				ZEPHIR_CALL_METHOD(NULL, &rowBuffer, "sort", NULL, 0);
 				zephir_check_call_status();
 				if (odd) {
-					ZEPHIR_OBS_NVAR(&median);
-					zephir_array_fetch_long(&median, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1741);
+					ZVAL_LONG(&_16$$7, mid);
+					ZEPHIR_CALL_METHOD(&median, &rowBuffer, "get", NULL, 0, &_16$$7);
+					zephir_check_call_status();
 				} else {
-					ZEPHIR_OBS_NVAR(&_13$$8);
-					zephir_array_fetch_long(&_13$$8, &rowA, (mid - 1), PH_NOISY, "tensor/matrix.zep", 1743);
-					ZEPHIR_OBS_NVAR(&_14$$8);
-					zephir_array_fetch_long(&_14$$8, &rowA, mid, PH_NOISY, "tensor/matrix.zep", 1743);
-					ZEPHIR_INIT_NVAR(&_15$$8);
-					zephir_add_function(&_15$$8, &_13$$8, &_14$$8);
+					ZVAL_LONG(&_18$$8, (mid - 1));
+					ZEPHIR_CALL_METHOD(&_17$$8, &rowBuffer, "get", NULL, 0, &_18$$8);
+					zephir_check_call_status();
+					ZVAL_LONG(&_18$$8, mid);
+					ZEPHIR_CALL_METHOD(&_19$$8, &rowBuffer, "get", NULL, 0, &_18$$8);
+					zephir_check_call_status();
+					ZEPHIR_INIT_NVAR(&_20$$8);
+					zephir_add_function(&_20$$8, &_17$$8, &_19$$8);
 					ZEPHIR_INIT_NVAR(&median);
-					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_15$$8, 2.0));
+					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1746);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1806);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
+	ZEPHIR_INIT_NVAR(&rowBuffer);
 	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -5257,37 +5535,42 @@ PHP_METHOD(Tensor_Matrix, median)
 PHP_METHOD(Tensor_Matrix, quantile)
 {
 	zval b;
-	zend_bool _0, _19;
+	zend_bool _0, _22;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_10 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, xHat;
-	zval *q_param = NULL, rowA, _5, _6, *_7, _8, *_9, _18, _1$$3, _2$$3, _3$$3, _4$$3, _11$$4, _15$$4, _16$$4, _17$$4, _12$$5, _13$$5, _14$$5, _20$$6, _24$$6, _25$$6, _26$$6, _21$$7, _22$$7, _23$$7;
+	zval *q_param = NULL, rowBuffer, _5, _6, _7, _8, *_9, _10, *_11, _21, _1$$3, _2$$3, _3$$3, _4$$3, _12$$4, _17$$4, _18$$4, _19$$4, _20$$4, _13$$5, _14$$5, _15$$5, _16$$5, _23$$6, _28$$6, _29$$6, _30$$6, _31$$6, _24$$7, _25$$7, _26$$7, _27$$7;
 	double q, t = 0, x, remainder;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_5);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_21);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_11$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
+	ZVAL_UNDEF(&_12$$4);
 	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_12$$5);
+	ZVAL_UNDEF(&_18$$4);
+	ZVAL_UNDEF(&_19$$4);
+	ZVAL_UNDEF(&_20$$4);
 	ZVAL_UNDEF(&_13$$5);
 	ZVAL_UNDEF(&_14$$5);
-	ZVAL_UNDEF(&_20$$6);
-	ZVAL_UNDEF(&_24$$6);
-	ZVAL_UNDEF(&_25$$6);
-	ZVAL_UNDEF(&_26$$6);
-	ZVAL_UNDEF(&_21$$7);
-	ZVAL_UNDEF(&_22$$7);
-	ZVAL_UNDEF(&_23$$7);
+	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_16$$5);
+	ZVAL_UNDEF(&_23$$6);
+	ZVAL_UNDEF(&_28$$6);
+	ZVAL_UNDEF(&_29$$6);
+	ZVAL_UNDEF(&_30$$6);
+	ZVAL_UNDEF(&_31$$6);
+	ZVAL_UNDEF(&_24$$7);
+	ZVAL_UNDEF(&_25$$7);
+	ZVAL_UNDEF(&_26$$7);
+	ZVAL_UNDEF(&_27$$7);
 	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
@@ -5319,7 +5602,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1763);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1823);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5330,85 +5613,90 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	xHat = (int) x;
 	remainder =  ((x -  (double) xHat));
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_7, &_6, "split", NULL, 0, &_8);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_7) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_10);
+		zephir_string_to_char_array(&_10, &_7);
+		_9 = &_10;
 	} else {
-		_7 = &_6;
+		_9 = &_7;
 	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 1791);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_7), _9)
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1851);
+	if (Z_TYPE_P(_9) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _9);
-			ZEPHIR_MAKE_REF(&rowA);
-			ZEPHIR_CALL_FUNCTION(NULL, "sort", &_10, 19, &rowA);
-			ZEPHIR_UNREF(&rowA);
-			zephir_check_call_status();
-			zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			if (ZEPHIR_LE_LONG(&_11$$4, xHat)) {
-				ZEPHIR_OBS_NVAR(&_12$$5);
-				zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-				zephir_array_fetch_long(&_12$$5, &rowA, (zephir_get_numberval(&_13$$5) - 1), PH_NOISY, "tensor/matrix.zep", 1781);
-				ZEPHIR_INIT_NVAR(&_14$$5);
-				ZVAL_DOUBLE(&_14$$5, zephir_get_doubleval(&_12$$5));
-				zephir_array_append(&b, &_14$$5, PH_SEPARATE, "tensor/matrix.zep", 1781);
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _11);
+			ZEPHIR_CALL_METHOD(NULL, &rowBuffer, "sort", NULL, 0);
+			zephir_check_call_status();
+			zephir_read_property_cached(&_12$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			if (ZEPHIR_LE_LONG(&_12$$4, xHat)) {
+				zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+				ZVAL_LONG(&_15$$5, (zephir_get_numberval(&_14$$5) - 1));
+				ZEPHIR_CALL_METHOD(&_13$$5, &rowBuffer, "get", NULL, 0, &_15$$5);
+				zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_16$$5);
+				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1841);
 				continue;
 			}
-			ZEPHIR_OBS_NVAR(&_15$$4);
-			zephir_array_fetch_long(&_15$$4, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1786);
-			t =  (zephir_get_doubleval(&_15$$4));
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch_long(&_16$$4, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1788);
-			ZEPHIR_INIT_NVAR(&_17$$4);
-			ZVAL_DOUBLE(&_17$$4, (t + (remainder * (zephir_get_numberval(&_16$$4) - t))));
-			zephir_array_append(&b, &_17$$4, PH_SEPARATE, "tensor/matrix.zep", 1788);
+			ZVAL_LONG(&_18$$4, (xHat - 1));
+			ZEPHIR_CALL_METHOD(&_17$$4, &rowBuffer, "get", NULL, 0, &_18$$4);
+			zephir_check_call_status();
+			t =  (zephir_get_doubleval(&_17$$4));
+			ZVAL_LONG(&_18$$4, xHat);
+			ZEPHIR_CALL_METHOD(&_19$$4, &rowBuffer, "get", NULL, 0, &_18$$4);
+			zephir_check_call_status();
+			ZEPHIR_INIT_NVAR(&_20$$4);
+			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1848);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_19 = 1;
+		_22 = 1;
 		while (1) {
-			if (_19) {
-				_19 = 0;
+			if (_22) {
+				_22 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_18, _7, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_21, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_18)) {
+			if (!zend_is_true(&_21)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _7, "current", NULL, 0);
+			ZEPHIR_CALL_METHOD(&rowBuffer, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_MAKE_REF(&rowA);
-				ZEPHIR_CALL_FUNCTION(NULL, "sort", &_10, 19, &rowA);
-				ZEPHIR_UNREF(&rowA);
+				ZEPHIR_CALL_METHOD(NULL, &rowBuffer, "sort", NULL, 0);
 				zephir_check_call_status();
-				zephir_read_property_cached(&_20$$6, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-				if (ZEPHIR_LE_LONG(&_20$$6, xHat)) {
-					ZEPHIR_OBS_NVAR(&_21$$7);
-					zephir_read_property_cached(&_22$$7, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-					zephir_array_fetch_long(&_21$$7, &rowA, (zephir_get_numberval(&_22$$7) - 1), PH_NOISY, "tensor/matrix.zep", 1781);
-					ZEPHIR_INIT_NVAR(&_23$$7);
-					ZVAL_DOUBLE(&_23$$7, zephir_get_doubleval(&_21$$7));
-					zephir_array_append(&b, &_23$$7, PH_SEPARATE, "tensor/matrix.zep", 1781);
+				zephir_read_property_cached(&_23$$6, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+				if (ZEPHIR_LE_LONG(&_23$$6, xHat)) {
+					zephir_read_property_cached(&_25$$7, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+					ZVAL_LONG(&_26$$7, (zephir_get_numberval(&_25$$7) - 1));
+					ZEPHIR_CALL_METHOD(&_24$$7, &rowBuffer, "get", NULL, 0, &_26$$7);
+					zephir_check_call_status();
+					ZEPHIR_INIT_NVAR(&_27$$7);
+					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1841);
 					continue;
 				}
-				ZEPHIR_OBS_NVAR(&_24$$6);
-				zephir_array_fetch_long(&_24$$6, &rowA, (xHat - 1), PH_NOISY, "tensor/matrix.zep", 1786);
-				t =  (zephir_get_doubleval(&_24$$6));
-				ZEPHIR_OBS_NVAR(&_25$$6);
-				zephir_array_fetch_long(&_25$$6, &rowA, xHat, PH_NOISY, "tensor/matrix.zep", 1788);
-				ZEPHIR_INIT_NVAR(&_26$$6);
-				ZVAL_DOUBLE(&_26$$6, (t + (remainder * (zephir_get_numberval(&_25$$6) - t))));
-				zephir_array_append(&b, &_26$$6, PH_SEPARATE, "tensor/matrix.zep", 1788);
+				ZVAL_LONG(&_29$$6, (xHat - 1));
+				ZEPHIR_CALL_METHOD(&_28$$6, &rowBuffer, "get", NULL, 0, &_29$$6);
+				zephir_check_call_status();
+				t =  (zephir_get_doubleval(&_28$$6));
+				ZVAL_LONG(&_29$$6, xHat);
+				ZEPHIR_CALL_METHOD(&_30$$6, &rowBuffer, "get", NULL, 0, &_29$$6);
+				zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_31$$6);
+				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1848);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
+	ZEPHIR_INIT_NVAR(&rowBuffer);
 	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -5480,7 +5768,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1807);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1867);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5500,7 +5788,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 3, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1813);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1873);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5589,7 +5877,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 3, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1838);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1898);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5617,11 +5905,12 @@ PHP_METHOD(Tensor_Matrix, covariance)
  */
 PHP_METHOD(Tensor_Matrix, round)
 {
-	zend_bool _19, _15$$5, _26$$8;
-	zval b, rowB;
+	zend_bool _18;
+	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *precision_param = NULL, _0$$3, _1$$4, _2$$4, _3$$4, _4$$4, rowA, valueA, _5, *_6, _7, *_8, _18, *_9$$5, _10$$5, *_11$$5, _14$$5, _12$$6, _13$$6, _16$$7, _17$$7, *_20$$8, _21$$8, *_22$$8, _25$$8, _23$$9, _24$$9, _27$$10, _28$$10;
-	zend_long precision, ZEPHIR_LAST_CALL_STATUS;
+	zephir_fcall_cache_entry *_13 = NULL, *_16 = NULL, *_21 = NULL, *_24 = NULL;
+	zval *precision_param = NULL, _0$$3, _1$$4, _2$$4, _3$$4, _4$$4, rowA, valueA, _5, _6, _7, *_8, _9, *_10, _17, _11$$5, _12$$6, _14$$6, _15$$6, _19$$7, _20$$8, _22$$8, _23$$8;
+	zend_long precision, ZEPHIR_LAST_CALL_STATUS, i = 0;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
@@ -5632,26 +5921,27 @@ PHP_METHOD(Tensor_Matrix, round)
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
 	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_14$$5);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_11$$5);
 	ZVAL_UNDEF(&_12$$6);
-	ZVAL_UNDEF(&_13$$6);
-	ZVAL_UNDEF(&_16$$7);
-	ZVAL_UNDEF(&_17$$7);
-	ZVAL_UNDEF(&_21$$8);
-	ZVAL_UNDEF(&_25$$8);
-	ZVAL_UNDEF(&_23$$9);
-	ZVAL_UNDEF(&_24$$9);
-	ZVAL_UNDEF(&_27$$10);
-	ZVAL_UNDEF(&_28$$10);
+	ZVAL_UNDEF(&_14$$6);
+	ZVAL_UNDEF(&_15$$6);
+	ZVAL_UNDEF(&_19$$7);
+	ZVAL_UNDEF(&_20$$8);
+	ZVAL_UNDEF(&_22$$8);
+	ZVAL_UNDEF(&_23$$8);
 	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&rowB);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(0, 1)
 		Z_PARAM_OPTIONAL
@@ -5681,139 +5971,84 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_4$$4, "Decimal precision cannot", " be less than 0, ", &_3$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_4$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$4, "tensor/matrix.zep", 1864);
+		zephir_throw_exception_debug(&_1$$4, "tensor/matrix.zep", 1924);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	ZEPHIR_INIT_VAR(&rowB);
-	array_init(&rowB);
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_5) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_7);
-		zephir_string_to_char_array(&_7, &_5);
-		_6 = &_7;
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_6, &_5, "split", NULL, 0, &_7);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_6) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_9);
+		zephir_string_to_char_array(&_9, &_6);
+		_8 = &_9;
 	} else {
-		_6 = &_5;
+		_8 = &_6;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1882);
-	if (Z_TYPE_P(_6) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
+	zephir_is_iterable(_8, 0, "tensor/matrix.zep", 1947);
+	if (Z_TYPE_P(_8) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_8), _10)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _8);
-			ZEPHIR_INIT_NVAR(&rowB);
-			array_init(&rowB);
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_10$$5);
-				zephir_string_to_char_array(&_10$$5, &rowA);
-				_9$$5 = &_10$$5;
-			} else {
-				_9$$5 = &rowA;
-			}
-			zephir_is_iterable(_9$$5, 0, "tensor/matrix.zep", 1879);
-			if (Z_TYPE_P(_9$$5) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9$$5), _11$$5)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _11$$5);
-					ZEPHIR_INIT_NVAR(&_12$$6);
-					ZVAL_LONG(&_13$$6, precision);
-					zephir_round(&_12$$6, &valueA, &_13$$6, NULL);
-					zephir_array_append(&rowB, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 1876);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9$$5, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_15$$5 = 1;
-				while (1) {
-					if (_15$$5) {
-						_15$$5 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _9$$5, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_14$$5, _9$$5, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_14$$5)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _9$$5, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_16$$7);
-						ZVAL_LONG(&_17$$7, precision);
-						zephir_round(&_16$$7, &valueA, &_17$$7, NULL);
-						zephir_array_append(&rowB, &_16$$7, PH_SEPARATE, "tensor/matrix.zep", 1876);
+			ZVAL_COPY(&rowA, _10);
+			i = 0;
+			while (1) {
+				zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+				if (!(ZEPHIR_GT_LONG(&_11$$5, i))) {
+					break;
 				}
+				ZVAL_LONG(&_12$$6, i);
+				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_13, 0, &_12$$6);
+				zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_14$$6);
+				ZVAL_LONG(&_12$$6, precision);
+				zephir_round(&_14$$6, &valueA, &_12$$6, NULL);
+				ZVAL_LONG(&_15$$6, i);
+				ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_16, 0, &_15$$6, &_14$$6);
+				zephir_check_call_status();
+				i++;
 			}
-			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1879);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1944);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _8, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_19 = 1;
+		_18 = 1;
 		while (1) {
-			if (_19) {
-				_19 = 0;
+			if (_18) {
+				_18 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _6, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _8, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_18, _6, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_17, _8, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_18)) {
+			if (!zend_is_true(&_17)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _6, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowB);
-				array_init(&rowB);
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_21$$8);
-					zephir_string_to_char_array(&_21$$8, &rowA);
-					_20$$8 = &_21$$8;
-				} else {
-					_20$$8 = &rowA;
-				}
-				zephir_is_iterable(_20$$8, 0, "tensor/matrix.zep", 1879);
-				if (Z_TYPE_P(_20$$8) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_20$$8), _22$$8)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _22$$8);
-						ZEPHIR_INIT_NVAR(&_23$$9);
-						ZVAL_LONG(&_24$$9, precision);
-						zephir_round(&_23$$9, &valueA, &_24$$9, NULL);
-						zephir_array_append(&rowB, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 1876);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _20$$8, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_26$$8 = 1;
-					while (1) {
-						if (_26$$8) {
-							_26$$8 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _20$$8, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_25$$8, _20$$8, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_25$$8)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _20$$8, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_27$$10);
-							ZVAL_LONG(&_28$$10, precision);
-							zephir_round(&_27$$10, &valueA, &_28$$10, NULL);
-							zephir_array_append(&rowB, &_27$$10, PH_SEPARATE, "tensor/matrix.zep", 1876);
+			ZEPHIR_CALL_METHOD(&rowA, _8, "current", NULL, 0);
+			zephir_check_call_status();
+				i = 0;
+				while (1) {
+					zephir_read_property_cached(&_19$$7, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+					if (!(ZEPHIR_GT_LONG(&_19$$7, i))) {
+						break;
 					}
+					ZVAL_LONG(&_20$$8, i);
+					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_21, 0, &_20$$8);
+					zephir_check_call_status();
+					ZEPHIR_INIT_NVAR(&_22$$8);
+					ZVAL_LONG(&_20$$8, precision);
+					zephir_round(&_22$$8, &valueA, &_20$$8, NULL);
+					ZVAL_LONG(&_23$$8, i);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_24, 0, &_23$$8, &_22$$8);
+					zephir_check_call_status();
+					i++;
 				}
-				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1879);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1944);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5879,12 +6114,13 @@ PHP_METHOD(Tensor_Matrix, ceil)
  */
 PHP_METHOD(Tensor_Matrix, clip)
 {
-	zend_bool _16, _12$$4, _23$$11;
-	zval b, rowB;
+	zend_bool _18;
+	zval b;
 	zval _1$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *min_param = NULL, *max_param = NULL, _0$$3, rowA, valueA, _2, *_3, _4, *_5, _15, *_6$$4, _7$$4, *_8$$4, _11$$4, _9$$6, _10$$7, _13$$9, _14$$10, *_17$$11, _18$$11, *_19$$11, _22$$11, _20$$13, _21$$14, _24$$16, _25$$17;
+	zephir_fcall_cache_entry *_10 = NULL, *_13 = NULL, *_16 = NULL, *_21 = NULL, *_24 = NULL, *_27 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
+	zval *min_param = NULL, *max_param = NULL, _0$$3, rowA, valueA, _2, _3, _4, *_5, _6, *_7, _17, _8$$4, _9$$5, _11$$6, _12$$6, _14$$7, _15$$7, _19$$8, _20$$9, _22$$10, _23$$10, _25$$11, _26$$11;
 	double min, max;
 	zval *this_ptr = getThis();
 
@@ -5892,27 +6128,32 @@ PHP_METHOD(Tensor_Matrix, clip)
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_15);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_11$$4);
-	ZVAL_UNDEF(&_9$$6);
-	ZVAL_UNDEF(&_10$$7);
-	ZVAL_UNDEF(&_13$$9);
-	ZVAL_UNDEF(&_14$$10);
-	ZVAL_UNDEF(&_18$$11);
-	ZVAL_UNDEF(&_22$$11);
-	ZVAL_UNDEF(&_20$$13);
-	ZVAL_UNDEF(&_21$$14);
-	ZVAL_UNDEF(&_24$$16);
-	ZVAL_UNDEF(&_25$$17);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_8$$4);
+	ZVAL_UNDEF(&_9$$5);
+	ZVAL_UNDEF(&_11$$6);
+	ZVAL_UNDEF(&_12$$6);
+	ZVAL_UNDEF(&_14$$7);
+	ZVAL_UNDEF(&_15$$7);
+	ZVAL_UNDEF(&_19$$8);
+	ZVAL_UNDEF(&_20$$9);
+	ZVAL_UNDEF(&_22$$10);
+	ZVAL_UNDEF(&_23$$10);
+	ZVAL_UNDEF(&_25$$11);
+	ZVAL_UNDEF(&_26$$11);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&rowB);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(2, 2)
 		Z_PARAM_ZVAL(min_param)
@@ -5930,175 +6171,104 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1918);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1983);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	ZEPHIR_INIT_VAR(&rowB);
-	array_init(&rowB);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_2) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_2);
-		_3 = &_4;
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_3, &_2, "split", NULL, 0, &_4);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_3) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_6);
+		zephir_string_to_char_array(&_6, &_3);
+		_5 = &_6;
 	} else {
-		_3 = &_2;
+		_5 = &_3;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1948);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
+	zephir_is_iterable(_5, 0, "tensor/matrix.zep", 2020);
+	if (Z_TYPE_P(_5) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5), _7)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _5);
-			ZEPHIR_INIT_NVAR(&rowB);
-			array_init(&rowB);
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_7$$4);
-				zephir_string_to_char_array(&_7$$4, &rowA);
-				_6$$4 = &_7$$4;
-			} else {
-				_6$$4 = &rowA;
-			}
-			zephir_is_iterable(_6$$4, 0, "tensor/matrix.zep", 1945);
-			if (Z_TYPE_P(_6$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6$$4), _8$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _8$$4);
-					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-						ZEPHIR_INIT_NVAR(&_9$$6);
-						ZVAL_DOUBLE(&_9$$6, max);
-						zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/matrix.zep", 1931);
-						continue;
-					}
-					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-						ZEPHIR_INIT_NVAR(&_10$$7);
-						ZVAL_DOUBLE(&_10$$7, min);
-						zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1937);
-						continue;
-					}
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1942);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _6$$4, "rewind", NULL, 0);
+			ZVAL_COPY(&rowA, _7);
+			i = 0;
+			while (1) {
+				zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+				if (!(ZEPHIR_GT_LONG(&_8$$4, i))) {
+					break;
+				}
+				ZVAL_LONG(&_9$$5, i);
+				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_10, 0, &_9$$5);
 				zephir_check_call_status();
-				_12$$4 = 1;
-				while (1) {
-					if (_12$$4) {
-						_12$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _6$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_11$$4, _6$$4, "valid", NULL, 0);
+				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
+					ZVAL_LONG(&_11$$6, i);
+					ZVAL_DOUBLE(&_12$$6, max);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_13, 0, &_11$$6, &_12$$6);
 					zephir_check_call_status();
-					if (!zend_is_true(&_11$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _6$$4, "current", NULL, 0);
+					i++;
+					continue;
+				}
+				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
+					ZVAL_LONG(&_14$$7, i);
+					ZVAL_DOUBLE(&_15$$7, min);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_16, 0, &_14$$7, &_15$$7);
 					zephir_check_call_status();
-						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-							ZEPHIR_INIT_NVAR(&_13$$9);
-							ZVAL_DOUBLE(&_13$$9, max);
-							zephir_array_append(&rowB, &_13$$9, PH_SEPARATE, "tensor/matrix.zep", 1931);
-							continue;
-						}
-						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-							ZEPHIR_INIT_NVAR(&_14$$10);
-							ZVAL_DOUBLE(&_14$$10, min);
-							zephir_array_append(&rowB, &_14$$10, PH_SEPARATE, "tensor/matrix.zep", 1937);
-							continue;
-						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1942);
+					i++;
+					continue;
 				}
+				i++;
 			}
-			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1945);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2017);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _5, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_16 = 1;
+		_18 = 1;
 		while (1) {
-			if (_16) {
-				_16 = 0;
+			if (_18) {
+				_18 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _5, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_15, _3, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_17, _5, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
+			if (!zend_is_true(&_17)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _3, "current", NULL, 0);
+			ZEPHIR_CALL_METHOD(&rowA, _5, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowB);
-				array_init(&rowB);
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_18$$11);
-					zephir_string_to_char_array(&_18$$11, &rowA);
-					_17$$11 = &_18$$11;
-				} else {
-					_17$$11 = &rowA;
-				}
-				zephir_is_iterable(_17$$11, 0, "tensor/matrix.zep", 1945);
-				if (Z_TYPE_P(_17$$11) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$11), _19$$11)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _19$$11);
-						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-							ZEPHIR_INIT_NVAR(&_20$$13);
-							ZVAL_DOUBLE(&_20$$13, max);
-							zephir_array_append(&rowB, &_20$$13, PH_SEPARATE, "tensor/matrix.zep", 1931);
-							continue;
-						}
-						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-							ZEPHIR_INIT_NVAR(&_21$$14);
-							ZVAL_DOUBLE(&_21$$14, min);
-							zephir_array_append(&rowB, &_21$$14, PH_SEPARATE, "tensor/matrix.zep", 1937);
-							continue;
-						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1942);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _17$$11, "rewind", NULL, 0);
+				i = 0;
+				while (1) {
+					zephir_read_property_cached(&_19$$8, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+					if (!(ZEPHIR_GT_LONG(&_19$$8, i))) {
+						break;
+					}
+					ZVAL_LONG(&_20$$9, i);
+					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_21, 0, &_20$$9);
 					zephir_check_call_status();
-					_23$$11 = 1;
-					while (1) {
-						if (_23$$11) {
-							_23$$11 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _17$$11, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_22$$11, _17$$11, "valid", NULL, 0);
+					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
+						ZVAL_LONG(&_22$$10, i);
+						ZVAL_DOUBLE(&_23$$10, max);
+						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_24, 0, &_22$$10, &_23$$10);
 						zephir_check_call_status();
-						if (!zend_is_true(&_22$$11)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _17$$11, "current", NULL, 0);
+						i++;
+						continue;
+					}
+					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
+						ZVAL_LONG(&_25$$11, i);
+						ZVAL_DOUBLE(&_26$$11, min);
+						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_27, 0, &_25$$11, &_26$$11);
 						zephir_check_call_status();
-							if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-								ZEPHIR_INIT_NVAR(&_24$$16);
-								ZVAL_DOUBLE(&_24$$16, max);
-								zephir_array_append(&rowB, &_24$$16, PH_SEPARATE, "tensor/matrix.zep", 1931);
-								continue;
-							}
-							if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-								ZEPHIR_INIT_NVAR(&_25$$17);
-								ZVAL_DOUBLE(&_25$$17, min);
-								zephir_array_append(&rowB, &_25$$17, PH_SEPARATE, "tensor/matrix.zep", 1937);
-								continue;
-							}
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1942);
+						i++;
+						continue;
 					}
+					i++;
 				}
-				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1945);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2017);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6115,33 +6285,39 @@ PHP_METHOD(Tensor_Matrix, clip)
  */
 PHP_METHOD(Tensor_Matrix, clipLower)
 {
-	zend_bool _12, _9$$3, _18$$8;
-	zval b, rowB;
+	zend_bool _13;
+	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *min_param = NULL, rowA, valueA, _0, *_1, _2, *_3, _11, *_4$$3, _5$$3, *_6$$3, _8$$3, _7$$5, _10$$7, *_13$$8, _14$$8, *_15$$8, _17$$8, _16$$10, _19$$12;
+	zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL, *_16 = NULL, *_19 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
+	zval *min_param = NULL, rowA, valueA, _0, _1, _2, *_3, _4, *_5, _12, _6$$3, _7$$4, _9$$5, _10$$5, _14$$6, _15$$7, _17$$8, _18$$8;
 	double min;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$3);
-	ZVAL_UNDEF(&_7$$5);
-	ZVAL_UNDEF(&_10$$7);
-	ZVAL_UNDEF(&_14$$8);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&_9$$5);
+	ZVAL_UNDEF(&_10$$5);
+	ZVAL_UNDEF(&_14$$6);
+	ZVAL_UNDEF(&_15$$7);
 	ZVAL_UNDEF(&_17$$8);
-	ZVAL_UNDEF(&_16$$10);
-	ZVAL_UNDEF(&_19$$12);
+	ZVAL_UNDEF(&_18$$8);
 	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&rowB);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(min_param)
@@ -6152,145 +6328,78 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 	min = zephir_get_doubleval(min_param);
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	ZEPHIR_INIT_VAR(&rowB);
-	array_init(&rowB);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
 	} else {
-		_1 = &_0;
+		_3 = &_1;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 1980);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2053);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&rowB);
-			array_init(&rowB);
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_5$$3);
-				zephir_string_to_char_array(&_5$$3, &rowA);
-				_4$$3 = &_5$$3;
-			} else {
-				_4$$3 = &rowA;
-			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 1977);
-			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _6$$3);
-					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-						ZEPHIR_INIT_NVAR(&_7$$5);
-						ZVAL_DOUBLE(&_7$$5, min);
-						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 1969);
-						continue;
-					}
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1974);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
+			ZVAL_COPY(&rowA, _5);
+			i = 0;
+			while (1) {
+				zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+				if (!(ZEPHIR_GT_LONG(&_6$$3, i))) {
+					break;
+				}
+				ZVAL_LONG(&_7$$4, i);
+				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_8, 0, &_7$$4);
 				zephir_check_call_status();
-				_9$$3 = 1;
-				while (1) {
-					if (_9$$3) {
-						_9$$3 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _4$$3, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_8$$3, _4$$3, "valid", NULL, 0);
+				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
+					ZVAL_LONG(&_9$$5, i);
+					ZVAL_DOUBLE(&_10$$5, min);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_11, 0, &_9$$5, &_10$$5);
 					zephir_check_call_status();
-					if (!zend_is_true(&_8$$3)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _4$$3, "current", NULL, 0);
-					zephir_check_call_status();
-						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-							ZEPHIR_INIT_NVAR(&_10$$7);
-							ZVAL_DOUBLE(&_10$$7, min);
-							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 1969);
-							continue;
-						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1974);
 				}
+				i++;
 			}
-			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1977);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2050);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_12 = 1;
+		_13 = 1;
 		while (1) {
-			if (_12) {
-				_12 = 0;
+			if (_13) {
+				_13 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_11, _1, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_12, _3, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_11)) {
+			if (!zend_is_true(&_12)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowB);
-				array_init(&rowB);
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_14$$8);
-					zephir_string_to_char_array(&_14$$8, &rowA);
-					_13$$8 = &_14$$8;
-				} else {
-					_13$$8 = &rowA;
-				}
-				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 1977);
-				if (Z_TYPE_P(_13$$8) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_13$$8), _15$$8)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _15$$8);
-						if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-							ZEPHIR_INIT_NVAR(&_16$$10);
-							ZVAL_DOUBLE(&_16$$10, min);
-							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 1969);
-							continue;
-						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1974);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _13$$8, "rewind", NULL, 0);
+			ZEPHIR_CALL_METHOD(&rowA, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				i = 0;
+				while (1) {
+					zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+					if (!(ZEPHIR_GT_LONG(&_14$$6, i))) {
+						break;
+					}
+					ZVAL_LONG(&_15$$7, i);
+					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_16, 0, &_15$$7);
 					zephir_check_call_status();
-					_18$$8 = 1;
-					while (1) {
-						if (_18$$8) {
-							_18$$8 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _13$$8, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_17$$8, _13$$8, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_17$$8)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _13$$8, "current", NULL, 0);
+					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
+						ZVAL_LONG(&_17$$8, i);
+						ZVAL_DOUBLE(&_18$$8, min);
+						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_19, 0, &_17$$8, &_18$$8);
 						zephir_check_call_status();
-							if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-								ZEPHIR_INIT_NVAR(&_19$$12);
-								ZVAL_DOUBLE(&_19$$12, min);
-								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 1969);
-								continue;
-							}
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 1974);
 					}
+					i++;
 				}
-				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 1977);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2050);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6307,33 +6416,39 @@ PHP_METHOD(Tensor_Matrix, clipLower)
  */
 PHP_METHOD(Tensor_Matrix, clipUpper)
 {
-	zend_bool _12, _9$$3, _18$$8;
-	zval b, rowB;
+	zend_bool _13;
+	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *max_param = NULL, rowA, valueA, _0, *_1, _2, *_3, _11, *_4$$3, _5$$3, *_6$$3, _8$$3, _7$$5, _10$$7, *_13$$8, _14$$8, *_15$$8, _17$$8, _16$$10, _19$$12;
+	zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL, *_16 = NULL, *_19 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
+	zval *max_param = NULL, rowA, valueA, _0, _1, _2, *_3, _4, *_5, _12, _6$$3, _7$$4, _9$$5, _10$$5, _14$$6, _15$$7, _17$$8, _18$$8;
 	double max;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$3);
-	ZVAL_UNDEF(&_7$$5);
-	ZVAL_UNDEF(&_10$$7);
-	ZVAL_UNDEF(&_14$$8);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&_9$$5);
+	ZVAL_UNDEF(&_10$$5);
+	ZVAL_UNDEF(&_14$$6);
+	ZVAL_UNDEF(&_15$$7);
 	ZVAL_UNDEF(&_17$$8);
-	ZVAL_UNDEF(&_16$$10);
-	ZVAL_UNDEF(&_19$$12);
+	ZVAL_UNDEF(&_18$$8);
 	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&rowB);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(max_param)
@@ -6344,145 +6459,78 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 	max = zephir_get_doubleval(max_param);
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	ZEPHIR_INIT_VAR(&rowB);
-	array_init(&rowB);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
 	} else {
-		_1 = &_0;
+		_3 = &_1;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 2012);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2086);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&rowB);
-			array_init(&rowB);
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_5$$3);
-				zephir_string_to_char_array(&_5$$3, &rowA);
-				_4$$3 = &_5$$3;
-			} else {
-				_4$$3 = &rowA;
-			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 2009);
-			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _6$$3);
-					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-						ZEPHIR_INIT_NVAR(&_7$$5);
-						ZVAL_DOUBLE(&_7$$5, max);
-						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 2001);
-						continue;
-					}
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2006);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
+			ZVAL_COPY(&rowA, _5);
+			i = 0;
+			while (1) {
+				zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+				if (!(ZEPHIR_GT_LONG(&_6$$3, i))) {
+					break;
+				}
+				ZVAL_LONG(&_7$$4, i);
+				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_8, 0, &_7$$4);
 				zephir_check_call_status();
-				_9$$3 = 1;
-				while (1) {
-					if (_9$$3) {
-						_9$$3 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _4$$3, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_8$$3, _4$$3, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_8$$3)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _4$$3, "current", NULL, 0);
+				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
+					ZVAL_LONG(&_9$$5, i);
+					ZVAL_DOUBLE(&_10$$5, max);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_11, 0, &_9$$5, &_10$$5);
 					zephir_check_call_status();
-						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-							ZEPHIR_INIT_NVAR(&_10$$7);
-							ZVAL_DOUBLE(&_10$$7, max);
-							zephir_array_append(&rowB, &_10$$7, PH_SEPARATE, "tensor/matrix.zep", 2001);
-							continue;
-						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2006);
 				}
+				i++;
 			}
-			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2009);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2083);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_12 = 1;
+		_13 = 1;
 		while (1) {
-			if (_12) {
-				_12 = 0;
+			if (_13) {
+				_13 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_11, _1, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_12, _3, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_11)) {
+			if (!zend_is_true(&_12)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowB);
-				array_init(&rowB);
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_14$$8);
-					zephir_string_to_char_array(&_14$$8, &rowA);
-					_13$$8 = &_14$$8;
-				} else {
-					_13$$8 = &rowA;
-				}
-				zephir_is_iterable(_13$$8, 0, "tensor/matrix.zep", 2009);
-				if (Z_TYPE_P(_13$$8) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_13$$8), _15$$8)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _15$$8);
-						if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-							ZEPHIR_INIT_NVAR(&_16$$10);
-							ZVAL_DOUBLE(&_16$$10, max);
-							zephir_array_append(&rowB, &_16$$10, PH_SEPARATE, "tensor/matrix.zep", 2001);
-							continue;
-						}
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2006);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _13$$8, "rewind", NULL, 0);
+			ZEPHIR_CALL_METHOD(&rowA, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				i = 0;
+				while (1) {
+					zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+					if (!(ZEPHIR_GT_LONG(&_14$$6, i))) {
+						break;
+					}
+					ZVAL_LONG(&_15$$7, i);
+					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_16, 0, &_15$$7);
 					zephir_check_call_status();
-					_18$$8 = 1;
-					while (1) {
-						if (_18$$8) {
-							_18$$8 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _13$$8, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_17$$8, _13$$8, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_17$$8)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _13$$8, "current", NULL, 0);
+					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
+						ZVAL_LONG(&_17$$8, i);
+						ZVAL_DOUBLE(&_18$$8, max);
+						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_19, 0, &_17$$8, &_18$$8);
 						zephir_check_call_status();
-							if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-								ZEPHIR_INIT_NVAR(&_19$$12);
-								ZVAL_DOUBLE(&_19$$12, max);
-								zephir_array_append(&rowB, &_19$$12, PH_SEPARATE, "tensor/matrix.zep", 2001);
-								continue;
-							}
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2006);
 					}
+					i++;
 				}
-				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2009);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2083);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6498,208 +6546,143 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
  */
 PHP_METHOD(Tensor_Matrix, sign)
 {
-	zend_bool _16, _11$$3, _24$$12;
-	zval b, rowB;
-	zval rowA, valueA, _0, *_1, _2, *_3, _15, *_4$$3, _5$$3, *_6$$3, _10$$3, _7$$5, _8$$6, _9$$7, _12$$9, _13$$10, _14$$11, *_17$$12, _18$$12, *_19$$12, _23$$12, _20$$14, _21$$15, _22$$16, _25$$18, _26$$19, _27$$20;
+	zend_bool _19;
+	zval b;
+	zval rowA, valueA, _0, _1, _2, *_3, _4, *_5, _18, _6$$3, _7$$4, _9$$5, _10$$5, _12$$6, _13$$6, _15$$7, _16$$7, _20$$8, _21$$9, _23$$10, _24$$10, _26$$11, _27$$11, _29$$12, _30$$12;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL, *_14 = NULL, *_17 = NULL, *_22 = NULL, *_25 = NULL, *_28 = NULL, *_31 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_15);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_10$$3);
-	ZVAL_UNDEF(&_7$$5);
-	ZVAL_UNDEF(&_8$$6);
-	ZVAL_UNDEF(&_9$$7);
-	ZVAL_UNDEF(&_12$$9);
-	ZVAL_UNDEF(&_13$$10);
-	ZVAL_UNDEF(&_14$$11);
-	ZVAL_UNDEF(&_18$$12);
-	ZVAL_UNDEF(&_23$$12);
-	ZVAL_UNDEF(&_20$$14);
-	ZVAL_UNDEF(&_21$$15);
-	ZVAL_UNDEF(&_22$$16);
-	ZVAL_UNDEF(&_25$$18);
-	ZVAL_UNDEF(&_26$$19);
-	ZVAL_UNDEF(&_27$$20);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&_9$$5);
+	ZVAL_UNDEF(&_10$$5);
+	ZVAL_UNDEF(&_12$$6);
+	ZVAL_UNDEF(&_13$$6);
+	ZVAL_UNDEF(&_15$$7);
+	ZVAL_UNDEF(&_16$$7);
+	ZVAL_UNDEF(&_20$$8);
+	ZVAL_UNDEF(&_21$$9);
+	ZVAL_UNDEF(&_23$$10);
+	ZVAL_UNDEF(&_24$$10);
+	ZVAL_UNDEF(&_26$$11);
+	ZVAL_UNDEF(&_27$$11);
+	ZVAL_UNDEF(&_29$$12);
+	ZVAL_UNDEF(&_30$$12);
 	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&rowB);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	ZEPHIR_INIT_VAR(&rowB);
-	array_init(&rowB);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
 	} else {
-		_1 = &_0;
+		_3 = &_1;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 2043);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2122);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&rowB);
-			array_init(&rowB);
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_5$$3);
-				zephir_string_to_char_array(&_5$$3, &rowA);
-				_4$$3 = &_5$$3;
-			} else {
-				_4$$3 = &rowA;
-			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 2040);
-			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _6$$3);
-					if (ZEPHIR_GT_LONG(&valueA, 0)) {
-						ZEPHIR_INIT_NVAR(&_7$$5);
-						ZVAL_DOUBLE(&_7$$5, 1.0);
-						zephir_array_append(&rowB, &_7$$5, PH_SEPARATE, "tensor/matrix.zep", 2032);
-					} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
-						ZEPHIR_INIT_NVAR(&_8$$6);
-						ZVAL_DOUBLE(&_8$$6, -1.0);
-						zephir_array_append(&rowB, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 2034);
-					} else {
-						ZEPHIR_INIT_NVAR(&_9$$7);
-						ZVAL_DOUBLE(&_9$$7, 0.0);
-						zephir_array_append(&rowB, &_9$$7, PH_SEPARATE, "tensor/matrix.zep", 2036);
-					}
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
+			ZVAL_COPY(&rowA, _5);
+			i = 0;
+			while (1) {
+				zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+				if (!(ZEPHIR_GT_LONG(&_6$$3, i))) {
+					break;
+				}
+				ZVAL_LONG(&_7$$4, i);
+				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_8, 0, &_7$$4);
 				zephir_check_call_status();
-				_11$$3 = 1;
-				while (1) {
-					if (_11$$3) {
-						_11$$3 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _4$$3, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_10$$3, _4$$3, "valid", NULL, 0);
+				if (ZEPHIR_GT_LONG(&valueA, 0)) {
+					ZVAL_LONG(&_9$$5, i);
+					ZVAL_DOUBLE(&_10$$5, 1.0);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_11, 0, &_9$$5, &_10$$5);
 					zephir_check_call_status();
-					if (!zend_is_true(&_10$$3)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _4$$3, "current", NULL, 0);
+				} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
+					ZVAL_LONG(&_12$$6, i);
+					ZVAL_DOUBLE(&_13$$6, -1.0);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_14, 0, &_12$$6, &_13$$6);
+					zephir_check_call_status();
+				} else {
+					ZVAL_LONG(&_15$$7, i);
+					ZVAL_DOUBLE(&_16$$7, 0.0);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_17, 0, &_15$$7, &_16$$7);
 					zephir_check_call_status();
-						if (ZEPHIR_GT_LONG(&valueA, 0)) {
-							ZEPHIR_INIT_NVAR(&_12$$9);
-							ZVAL_DOUBLE(&_12$$9, 1.0);
-							zephir_array_append(&rowB, &_12$$9, PH_SEPARATE, "tensor/matrix.zep", 2032);
-						} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
-							ZEPHIR_INIT_NVAR(&_13$$10);
-							ZVAL_DOUBLE(&_13$$10, -1.0);
-							zephir_array_append(&rowB, &_13$$10, PH_SEPARATE, "tensor/matrix.zep", 2034);
-						} else {
-							ZEPHIR_INIT_NVAR(&_14$$11);
-							ZVAL_DOUBLE(&_14$$11, 0.0);
-							zephir_array_append(&rowB, &_14$$11, PH_SEPARATE, "tensor/matrix.zep", 2036);
-						}
 				}
+				i++;
 			}
-			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2040);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2119);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_16 = 1;
+		_19 = 1;
 		while (1) {
-			if (_16) {
-				_16 = 0;
+			if (_19) {
+				_19 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_15, _1, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_18, _3, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
+			if (!zend_is_true(&_18)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowB);
-				array_init(&rowB);
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_18$$12);
-					zephir_string_to_char_array(&_18$$12, &rowA);
-					_17$$12 = &_18$$12;
-				} else {
-					_17$$12 = &rowA;
-				}
-				zephir_is_iterable(_17$$12, 0, "tensor/matrix.zep", 2040);
-				if (Z_TYPE_P(_17$$12) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$12), _19$$12)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _19$$12);
-						if (ZEPHIR_GT_LONG(&valueA, 0)) {
-							ZEPHIR_INIT_NVAR(&_20$$14);
-							ZVAL_DOUBLE(&_20$$14, 1.0);
-							zephir_array_append(&rowB, &_20$$14, PH_SEPARATE, "tensor/matrix.zep", 2032);
-						} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
-							ZEPHIR_INIT_NVAR(&_21$$15);
-							ZVAL_DOUBLE(&_21$$15, -1.0);
-							zephir_array_append(&rowB, &_21$$15, PH_SEPARATE, "tensor/matrix.zep", 2034);
-						} else {
-							ZEPHIR_INIT_NVAR(&_22$$16);
-							ZVAL_DOUBLE(&_22$$16, 0.0);
-							zephir_array_append(&rowB, &_22$$16, PH_SEPARATE, "tensor/matrix.zep", 2036);
-						}
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _17$$12, "rewind", NULL, 0);
+			ZEPHIR_CALL_METHOD(&rowA, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				i = 0;
+				while (1) {
+					zephir_read_property_cached(&_20$$8, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+					if (!(ZEPHIR_GT_LONG(&_20$$8, i))) {
+						break;
+					}
+					ZVAL_LONG(&_21$$9, i);
+					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_22, 0, &_21$$9);
 					zephir_check_call_status();
-					_24$$12 = 1;
-					while (1) {
-						if (_24$$12) {
-							_24$$12 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _17$$12, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_23$$12, _17$$12, "valid", NULL, 0);
+					if (ZEPHIR_GT_LONG(&valueA, 0)) {
+						ZVAL_LONG(&_23$$10, i);
+						ZVAL_DOUBLE(&_24$$10, 1.0);
+						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_25, 0, &_23$$10, &_24$$10);
 						zephir_check_call_status();
-						if (!zend_is_true(&_23$$12)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _17$$12, "current", NULL, 0);
+					} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
+						ZVAL_LONG(&_26$$11, i);
+						ZVAL_DOUBLE(&_27$$11, -1.0);
+						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_28, 0, &_26$$11, &_27$$11);
+						zephir_check_call_status();
+					} else {
+						ZVAL_LONG(&_29$$12, i);
+						ZVAL_DOUBLE(&_30$$12, 0.0);
+						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_31, 0, &_29$$12, &_30$$12);
 						zephir_check_call_status();
-							if (ZEPHIR_GT_LONG(&valueA, 0)) {
-								ZEPHIR_INIT_NVAR(&_25$$18);
-								ZVAL_DOUBLE(&_25$$18, 1.0);
-								zephir_array_append(&rowB, &_25$$18, PH_SEPARATE, "tensor/matrix.zep", 2032);
-							} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
-								ZEPHIR_INIT_NVAR(&_26$$19);
-								ZVAL_DOUBLE(&_26$$19, -1.0);
-								zephir_array_append(&rowB, &_26$$19, PH_SEPARATE, "tensor/matrix.zep", 2034);
-							} else {
-								ZEPHIR_INIT_NVAR(&_27$$20);
-								ZVAL_DOUBLE(&_27$$20, 0.0);
-								zephir_array_append(&rowB, &_27$$20, PH_SEPARATE, "tensor/matrix.zep", 2036);
-							}
 					}
+					i++;
 				}
-				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2040);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2119);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6715,152 +6698,107 @@ PHP_METHOD(Tensor_Matrix, sign)
  */
 PHP_METHOD(Tensor_Matrix, negate)
 {
-	zend_bool _10, _8$$3, _15$$6;
-	zval b, rowB;
-	zval rowA, valueA, _0, *_1, _2, *_3, _9, *_4$$3, _5$$3, *_6$$3, _7$$3, *_11$$6, _12$$6, *_13$$6, _14$$6;
+	zend_bool _11;
+	zval b;
+	zval rowA, valueA, _0, _1, _2, *_3, _4, *_5, _10, _6$$3, _7$$4, _12$$5, _13$$6;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zephir_fcall_cache_entry *_8 = NULL, *_9 = NULL, *_14 = NULL, *_15 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_9);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_7$$3);
-	ZVAL_UNDEF(&_12$$6);
-	ZVAL_UNDEF(&_14$$6);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&_12$$5);
+	ZVAL_UNDEF(&_13$$6);
 	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&rowB);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	ZEPHIR_INIT_VAR(&rowB);
-	array_init(&rowB);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
 	} else {
-		_1 = &_0;
+		_3 = &_1;
 	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 2068);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2152);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&rowB);
-			array_init(&rowB);
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_5$$3);
-				zephir_string_to_char_array(&_5$$3, &rowA);
-				_4$$3 = &_5$$3;
-			} else {
-				_4$$3 = &rowA;
-			}
-			zephir_is_iterable(_4$$3, 0, "tensor/matrix.zep", 2065);
-			if (Z_TYPE_P(_4$$3) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4$$3), _6$$3)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _6$$3);
-					zephir_negate(&valueA);
-					zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2062);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _4$$3, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_8$$3 = 1;
-				while (1) {
-					if (_8$$3) {
-						_8$$3 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _4$$3, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_7$$3, _4$$3, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_7$$3)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _4$$3, "current", NULL, 0);
-					zephir_check_call_status();
-						zephir_negate(&valueA);
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2062);
+			ZVAL_COPY(&rowA, _5);
+			i = 0;
+			while (1) {
+				zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+				if (!(ZEPHIR_GT_LONG(&_6$$3, i))) {
+					break;
 				}
+				ZVAL_LONG(&_7$$4, i);
+				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_8, 0, &_7$$4);
+				zephir_check_call_status();
+				zephir_negate(&valueA);
+				ZVAL_LONG(&_7$$4, i);
+				ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_9, 0, &_7$$4, &valueA);
+				zephir_check_call_status();
+				i++;
 			}
-			ZEPHIR_INIT_NVAR(&valueA);
-			zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2065);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2149);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_10 = 1;
+		_11 = 1;
 		while (1) {
-			if (_10) {
-				_10 = 0;
+			if (_11) {
+				_11 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_9, _1, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_10, _3, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_9)) {
+			if (!zend_is_true(&_10)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowB);
-				array_init(&rowB);
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_12$$6);
-					zephir_string_to_char_array(&_12$$6, &rowA);
-					_11$$6 = &_12$$6;
-				} else {
-					_11$$6 = &rowA;
-				}
-				zephir_is_iterable(_11$$6, 0, "tensor/matrix.zep", 2065);
-				if (Z_TYPE_P(_11$$6) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_11$$6), _13$$6)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _13$$6);
-						zephir_negate(&valueA);
-						zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2062);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _11$$6, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_15$$6 = 1;
-					while (1) {
-						if (_15$$6) {
-							_15$$6 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _11$$6, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_14$$6, _11$$6, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_14$$6)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _11$$6, "current", NULL, 0);
-						zephir_check_call_status();
-							zephir_negate(&valueA);
-							zephir_array_append(&rowB, &valueA, PH_SEPARATE, "tensor/matrix.zep", 2062);
+			ZEPHIR_CALL_METHOD(&rowA, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				i = 0;
+				while (1) {
+					zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+					if (!(ZEPHIR_GT_LONG(&_12$$5, i))) {
+						break;
 					}
+					ZVAL_LONG(&_13$$6, i);
+					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_14, 0, &_13$$6);
+					zephir_check_call_status();
+					zephir_negate(&valueA);
+					ZVAL_LONG(&_13$$6, i);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_15, 0, &_13$$6, &valueA);
+					zephir_check_call_status();
+					i++;
 				}
-				ZEPHIR_INIT_NVAR(&valueA);
-				zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/matrix.zep", 2065);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2149);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6879,22 +6817,27 @@ PHP_METHOD(Tensor_Matrix, negate)
 PHP_METHOD(Tensor_Matrix, augmentAbove)
 {
 	zval _6$$3, _8$$3, _9$$3;
+	zval _11;
 	zend_bool _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _2, _3, _10, _11, _12, _4$$3, _5$$3, _7$$3;
+	zval *b, b_sub, _0, _2, _3, buffer, _10, _12, _13, _14, _15, _4$$3, _5$$3, _7$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&buffer);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_15);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_7$$3);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_8$$3);
 	ZVAL_UNDEF(&_9$$3);
@@ -6938,16 +6881,25 @@ 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", 2083);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2167);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&_10);
-	ZEPHIR_CALL_METHOD(&_11, b, "asArray", NULL, 0);
+	zephir_read_property_cached(&_10, b, _zephir_prop_2, 0, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_INIT_VAR(&_11);
+	zephir_create_array(&_11, 1, 0);
+	zephir_memory_observe(&_12);
+	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC);
+	zephir_array_fast_append(&_11, &_12);
+	ZEPHIR_CALL_METHOD(&buffer, &_10, "concat", NULL, 0, &_11);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_13, b, "m", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_fast_array_merge(&_10, &_11, &_12);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_10);
+	zephir_read_property_cached(&_14, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_INIT_VAR(&_15);
+	zephir_add_function(&_15, &_13, &_14);
+	zephir_read_property_cached(&_14, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &buffer, &_15, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6962,22 +6914,27 @@ PHP_METHOD(Tensor_Matrix, augmentAbove)
 PHP_METHOD(Tensor_Matrix, augmentBelow)
 {
 	zval _6$$3, _8$$3, _9$$3;
+	zval _11;
 	zend_bool _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _2, _3, _10, _11, _12, _4$$3, _5$$3, _7$$3;
+	zval *b, b_sub, _0, _2, _3, buffer, _10, _12, _13, _14, _15, _4$$3, _5$$3, _7$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&buffer);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_15);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_7$$3);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_8$$3);
 	ZVAL_UNDEF(&_9$$3);
@@ -7021,16 +6978,25 @@ 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", 2101);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2187);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&_10);
-	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_12, b, "asArray", NULL, 0);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_INIT_VAR(&_11);
+	zephir_create_array(&_11, 1, 0);
+	zephir_memory_observe(&_12);
+	zephir_read_property_cached(&_12, b, _zephir_prop_2, 0, PH_NOISY_CC);
+	zephir_array_fast_append(&_11, &_12);
+	ZEPHIR_CALL_METHOD(&buffer, &_10, "concat", NULL, 0, &_11);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_14, b, "m", NULL, 0);
 	zephir_check_call_status();
-	zephir_fast_array_merge(&_10, &_11, &_12);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_10);
+	ZEPHIR_INIT_VAR(&_15);
+	zephir_add_function(&_15, &_13, &_14);
+	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &buffer, &_15, &_13);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7045,34 +7011,49 @@ PHP_METHOD(Tensor_Matrix, augmentBelow)
 PHP_METHOD(Tensor_Matrix, augmentLeft)
 {
 	zval _6$$3, _8$$3, _9$$3;
-	zend_bool _1;
+	zval c, _22$$4;
+	zend_bool _1, _11;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _2, _3, _10, _11, _12, _13, _4$$3, _5$$3, _7$$3;
+	zephir_fcall_cache_entry *_16 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _12, _13;
+	zval *b, b_sub, _0, _2, _3, i, bufferB, bufferA, _10, _4$$3, _5$$3, _7$$3, _14$$4, _15$$4, _17$$4, _18$$4, _19$$4, _20$$4, _21$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&i);
+	ZVAL_UNDEF(&bufferB);
+	ZVAL_UNDEF(&bufferA);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_12);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_7$$3);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
+	ZVAL_UNDEF(&_19$$4);
+	ZVAL_UNDEF(&_20$$4);
+	ZVAL_UNDEF(&_21$$4);
+	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_22$$4);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_8$$3);
 	ZVAL_UNDEF(&_9$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -7101,60 +7082,110 @@ 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", 2119);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2207);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&_10, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_INIT_VAR(&_12);
-	ZVAL_STRING(&_12, "array_merge");
-	ZEPHIR_CALL_FUNCTION(&_13, "array_map", NULL, 15, &_12, &_10, &_11);
-	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_13);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
-/**
- * Attach matrix b to the left of this matrix.
- *
- * @param \Tensor\Matrix b
+	ZEPHIR_INIT_VAR(&c);
+	array_init(&c);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	_13 = (zephir_get_numberval(&_10) - 1);
+	_12 = 0;
+	_11 = 0;
+	if (_12 <= _13) {
+		while (1) {
+			if (_11) {
+				_12++;
+				if (!(_12 <= _13)) {
+					break;
+				}
+			} else {
+				_11 = 1;
+			}
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _12);
+			zephir_read_property_cached(&_14$$4, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_15$$4, b, "n", &_16, 0);
+			zephir_check_call_status();
+			ZEPHIR_INIT_NVAR(&_17$$4);
+			mul_function(&_17$$4, &i, &_15$$4);
+			ZEPHIR_CALL_METHOD(&_15$$4, b, "n", &_16, 0);
+			zephir_check_call_status();
+			ZEPHIR_CALL_METHOD(&bufferB, &_14$$4, "slice", NULL, 0, &_17$$4, &_15$$4);
+			zephir_check_call_status();
+			zephir_read_property_cached(&_18$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_19$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_20$$4);
+			mul_function(&_20$$4, &i, &_19$$4);
+			zephir_read_property_cached(&_19$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&bufferA, &_18$$4, "slice", NULL, 0, &_20$$4, &_19$$4);
+			zephir_check_call_status();
+			ZEPHIR_INIT_NVAR(&_22$$4);
+			zephir_create_array(&_22$$4, 1, 0);
+			zephir_array_fast_append(&_22$$4, &bufferA);
+			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
+			zephir_check_call_status();
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2221);
+		}
+	}
+	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Attach matrix b to the left of this matrix.
+ *
+ * @param \Tensor\Matrix b
  * @throws \Tensor\Exceptions\DimensionalityMismatch
  * @return self
  */
 PHP_METHOD(Tensor_Matrix, augmentRight)
 {
 	zval _6$$3, _8$$3, _9$$3;
-	zend_bool _1;
+	zval c, _22$$4;
+	zend_bool _1, _11;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _2, _3, _10, _11, _12, _13, _4$$3, _5$$3, _7$$3;
+	zephir_fcall_cache_entry *_19 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _12, _13;
+	zval *b, b_sub, _0, _2, _3, i, bufferA, bufferB, _10, _4$$3, _5$$3, _7$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _20$$4, _21$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&i);
+	ZVAL_UNDEF(&bufferA);
+	ZVAL_UNDEF(&bufferB);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_12);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_7$$3);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
+	ZVAL_UNDEF(&_20$$4);
+	ZVAL_UNDEF(&_21$$4);
+	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_22$$4);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_8$$3);
 	ZVAL_UNDEF(&_9$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -7183,18 +7214,53 @@ 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", 2137);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2239);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_11, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	ZEPHIR_INIT_VAR(&_12);
-	ZVAL_STRING(&_12, "array_merge");
-	ZEPHIR_CALL_FUNCTION(&_13, "array_map", NULL, 15, &_12, &_10, &_11);
-	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_13);
+	ZEPHIR_INIT_VAR(&c);
+	array_init(&c);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	_13 = (zephir_get_numberval(&_10) - 1);
+	_12 = 0;
+	_11 = 0;
+	if (_12 <= _13) {
+		while (1) {
+			if (_11) {
+				_12++;
+				if (!(_12 <= _13)) {
+					break;
+				}
+			} else {
+				_11 = 1;
+			}
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _12);
+			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&bufferA, &_14$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			zephir_read_property_cached(&_17$$4, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_18$$4, b, "n", &_19, 0);
+			zephir_check_call_status();
+			ZEPHIR_INIT_NVAR(&_20$$4);
+			mul_function(&_20$$4, &i, &_18$$4);
+			ZEPHIR_CALL_METHOD(&_18$$4, b, "n", &_19, 0);
+			zephir_check_call_status();
+			ZEPHIR_CALL_METHOD(&bufferB, &_17$$4, "slice", NULL, 0, &_20$$4, &_18$$4);
+			zephir_check_call_status();
+			ZEPHIR_INIT_NVAR(&_22$$4);
+			zephir_create_array(&_22$$4, 1, 0);
+			zephir_array_fast_append(&_22$$4, &bufferB);
+			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
+			zephir_check_call_status();
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2253);
+		}
+	}
+	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7209,29 +7275,44 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
  */
 PHP_METHOD(Tensor_Matrix, repeat)
 {
-	zend_bool _7$$3;
-	zval b, temp;
+	zend_bool _9$$3;
+	zval bigRows;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *m_param = NULL, *n_param = NULL, rowA, _10, _11, _0$$3, *_1$$3, _2$$3, *_3$$3, _6$$3, _4$$4, _5$$4, _8$$6, _9$$6;
+	zval *m_param = NULL, *n_param = NULL, rowA, _18, _0$$3, _1$$3, _2$$3, *_3$$3, _4$$3, *_5$$3, _8$$3, _6$$4, _7$$4, _10$$5, _11$$5, flat$$6, _12$$6, _13$$6, _14$$6, _15$$6, _16$$6, _17$$6;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_18);
 	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_8$$6);
-	ZVAL_UNDEF(&_9$$6);
-	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&temp);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_8$$3);
+	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&_10$$5);
+	ZVAL_UNDEF(&_11$$5);
+	ZVAL_UNDEF(&flat$$6);
+	ZVAL_UNDEF(&_12$$6);
+	ZVAL_UNDEF(&_13$$6);
+	ZVAL_UNDEF(&_14$$6);
+	ZVAL_UNDEF(&_15$$6);
+	ZVAL_UNDEF(&_16$$6);
+	ZVAL_UNDEF(&_17$$6);
+	ZVAL_UNDEF(&bigRows);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(2, 2)
 		Z_PARAM_LONG(m)
@@ -7240,90 +7321,81 @@ PHP_METHOD(Tensor_Matrix, repeat)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 2, 0, &m_param, &n_param);
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	ZEPHIR_INIT_VAR(&temp);
-	array_init(&temp);
+	ZEPHIR_INIT_VAR(&bigRows);
+	array_init(&bigRows);
 	if (n > 0) {
 		zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-		if (Z_TYPE_P(&_0$$3) == IS_STRING) {
-			ZEPHIR_INIT_VAR(&_2$$3);
-			zephir_string_to_char_array(&_2$$3, &_0$$3);
-			_1$$3 = &_2$$3;
+		zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+		ZEPHIR_CALL_METHOD(&_1$$3, &_0$$3, "split", NULL, 0, &_2$$3);
+		zephir_check_call_status();
+		if (Z_TYPE_P(&_1$$3) == IS_STRING) {
+			ZEPHIR_INIT_VAR(&_4$$3);
+			zephir_string_to_char_array(&_4$$3, &_1$$3);
+			_3$$3 = &_4$$3;
 		} else {
-			_1$$3 = &_0$$3;
+			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_1$$3, 0, "tensor/matrix.zep", 2167);
-		if (Z_TYPE_P(_1$$3) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1$$3), _3$$3)
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2277);
+		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
 				ZEPHIR_INIT_NVAR(&rowA);
-				ZVAL_COPY(&rowA, _3$$3);
-				ZEPHIR_INIT_NVAR(&temp);
-				array_init(&temp);
-				while (1) {
-					if (!(zephir_fast_count_int(&temp) <= n)) {
-						break;
-					}
-					zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2162);
-				}
-				ZEPHIR_INIT_NVAR(&_4$$4);
-				ZEPHIR_INIT_NVAR(&_5$$4);
-				ZVAL_STRING(&_5$$4, "array_merge");
-				ZEPHIR_CALL_USER_FUNC_ARRAY(&_4$$4, &_5$$4, &temp);
+				ZVAL_COPY(&rowA, _5$$3);
+				ZVAL_LONG(&_7$$4, (n + 1));
+				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/matrix.zep", 2165);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2275);
 			} ZEND_HASH_FOREACH_END();
 		} else {
-			ZEPHIR_CALL_METHOD(NULL, _1$$3, "rewind", NULL, 0);
+			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
 			zephir_check_call_status();
-			_7$$3 = 1;
+			_9$$3 = 1;
 			while (1) {
-				if (_7$$3) {
-					_7$$3 = 0;
+				if (_9$$3) {
+					_9$$3 = 0;
 				} else {
-					ZEPHIR_CALL_METHOD(NULL, _1$$3, "next", NULL, 0);
+					ZEPHIR_CALL_METHOD(NULL, _3$$3, "next", NULL, 0);
 					zephir_check_call_status();
 				}
-				ZEPHIR_CALL_METHOD(&_6$$3, _1$$3, "valid", NULL, 0);
+				ZEPHIR_CALL_METHOD(&_8$$3, _3$$3, "valid", NULL, 0);
 				zephir_check_call_status();
-				if (!zend_is_true(&_6$$3)) {
+				if (!zend_is_true(&_8$$3)) {
 					break;
 				}
-				ZEPHIR_CALL_METHOD(&rowA, _1$$3, "current", NULL, 0);
+				ZEPHIR_CALL_METHOD(&rowA, _3$$3, "current", NULL, 0);
 				zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&temp);
-					array_init(&temp);
-					while (1) {
-						if (!(zephir_fast_count_int(&temp) <= n)) {
-							break;
-						}
-						zephir_array_append(&temp, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2162);
-					}
-					ZEPHIR_INIT_NVAR(&_8$$6);
-					ZEPHIR_INIT_NVAR(&_9$$6);
-					ZVAL_STRING(&_9$$6, "array_merge");
-					ZEPHIR_CALL_USER_FUNC_ARRAY(&_8$$6, &_9$$6, &temp);
+					ZVAL_LONG(&_11$$5, (n + 1));
+					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&b, &_8$$6, PH_SEPARATE, "tensor/matrix.zep", 2165);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2275);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
-	ZEPHIR_INIT_NVAR(&temp);
-	array_init(&temp);
-	while (1) {
-		if (!(zephir_fast_count_int(&temp) <= m)) {
-			break;
-		}
-		zephir_array_append(&temp, &b, PH_SEPARATE, "tensor/matrix.zep", 2172);
+	if (zephir_fast_count_int(&bigRows) > 0) {
+		zephir_memory_observe(&flat$$6);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2280);
+		ZVAL_LONG(&_13$$6, 1);
+		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 28, &bigRows, &_13$$6);
+		zephir_check_call_status();
+		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "concat", NULL, 0, &_14$$6);
+		zephir_check_call_status();
+		ZEPHIR_CPY_WRT(&flat$$6, &_12$$6);
+		ZVAL_LONG(&_13$$6, (m + 1));
+		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "repeat", NULL, 0, &_13$$6);
+		zephir_check_call_status();
+		ZEPHIR_CPY_WRT(&flat$$6, &_12$$6);
+		zephir_read_property_cached(&_13$$6, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+		zephir_read_property_cached(&_15$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+		ZVAL_LONG(&_16$$6, (zephir_get_numberval(&_13$$6) * ((m + 1))));
+		ZVAL_LONG(&_17$$6, (zephir_get_numberval(&_15$$6) * ((n + 1))));
+		ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &flat$$6, &_16$$6, &_17$$6);
+		zephir_check_call_status();
+		RETURN_MM();
 	}
-	ZEPHIR_INIT_VAR(&_10);
-	ZEPHIR_INIT_VAR(&_11);
-	ZVAL_STRING(&_11, "array_merge");
-	ZEPHIR_CALL_USER_FUNC_ARRAY(&_10, &_11, &temp);
-	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_10);
+	ZEPHIR_INIT_VAR(&_18);
+	array_init(&_18);
+	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_18);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7337,38 +7409,35 @@ PHP_METHOD(Tensor_Matrix, repeat)
  */
 PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -7391,71 +7460,17 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2189);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2303);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2200);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2197);
-			tensor_multiply(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2197);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2197);
-				tensor_multiply(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2197);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_multiply(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7469,38 +7484,35 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
  */
 PHP_METHOD(Tensor_Matrix, divideMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -7523,71 +7535,17 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2214);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2322);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2225);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2222);
-			tensor_divide(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2222);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2222);
-				tensor_divide(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2222);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_divide(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7601,38 +7559,35 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
  */
 PHP_METHOD(Tensor_Matrix, addMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -7655,71 +7610,17 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2239);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2341);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2250);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2247);
-			tensor_add(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2247);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2247);
-				tensor_add(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2247);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_add(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7733,38 +7634,35 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
  */
 PHP_METHOD(Tensor_Matrix, subtractMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -7787,71 +7685,17 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2264);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2360);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2275);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2272);
-			tensor_subtract(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2272);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2272);
-				tensor_subtract(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2272);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_subtract(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7866,38 +7710,35 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
  */
 PHP_METHOD(Tensor_Matrix, powMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -7920,71 +7761,17 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2290);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2380);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2301);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2298);
-			tensor_pow(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2298);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2298);
-				tensor_pow(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2298);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_pow(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7999,38 +7786,35 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
  */
 PHP_METHOD(Tensor_Matrix, modMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -8053,71 +7837,17 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2316);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2400);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2327);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2324);
-			tensor_mod(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2324);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2324);
-				tensor_mod(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2324);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_mod(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8132,38 +7862,35 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
  */
 PHP_METHOD(Tensor_Matrix, equalMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -8186,71 +7913,17 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2342);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2420);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2353);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2350);
-			tensor_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2350);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2350);
-				tensor_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2350);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_equal(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8264,38 +7937,35 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
  */
 PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -8318,71 +7988,17 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2367);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2439);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2378);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2375);
-			tensor_not_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2375);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2375);
-				tensor_not_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2375);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_not_equal(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8397,38 +8013,35 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
  */
 PHP_METHOD(Tensor_Matrix, greaterMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -8451,71 +8064,17 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2393);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2459);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2404);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2401);
-			tensor_greater(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2401);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2401);
-				tensor_greater(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2401);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_greater(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8530,38 +8089,35 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
  */
 PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -8584,71 +8140,17 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2419);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2479);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2430);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2427);
-			tensor_greater_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2427);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2427);
-				tensor_greater_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2427);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_greater_equal(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8662,38 +8164,35 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
  */
 PHP_METHOD(Tensor_Matrix, lessMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -8716,71 +8215,17 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2444);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2498);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2455);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2452);
-			tensor_less(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2452);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2452);
-				tensor_less(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2452);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_less(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8794,38 +8239,35 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
  */
 PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 {
-	zend_bool _16;
-	zend_string *_11;
-	zend_ulong _10;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, _6, *_7, _8, *_9, _15, _2$$3, _3$$3, _4$$3, _5$$3, _12$$4, _13$$4, _14$$4, _17$$5, _18$$5, _19$$5;
+	zval *b, b_sub, _0, _1, result, _6, _7, _8, _9, _2$$3, _3$$3, _4$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&c);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -8848,71 +8290,17 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2469);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2517);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_6, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_8);
-		zephir_string_to_char_array(&_8, &_6);
-		_7 = &_8;
-	} else {
-		_7 = &_6;
-	}
-	zephir_is_iterable(_7, 0, "tensor/matrix.zep", 2480);
-	if (Z_TYPE_P(_7) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_7), _10, _11, _9)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_11 != NULL) { 
-				ZVAL_STR_COPY(&i, _11);
-			} else {
-				ZVAL_LONG(&i, _10);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _9);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_14$$4);
-			zephir_array_fetch(&_14$$4, &_13$$4, &i, PH_NOISY, "tensor/matrix.zep", 2477);
-			tensor_less_equal(&_12$$4, &_14$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2477);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _7, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_16 = 1;
-		while (1) {
-			if (_16) {
-				_16 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _7, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_15, _7, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_15)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _7, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _7, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_17$$5);
-				zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_19$$5);
-				zephir_array_fetch(&_19$$5, &_18$$5, &i, PH_NOISY, "tensor/matrix.zep", 2477);
-				tensor_less_equal(&_17$$5, &_19$$5, &rowB);
-				zephir_array_append(&c, &_17$$5, PH_SEPARATE, "tensor/matrix.zep", 2477);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	tensor_less_equal(&result, &_6, &_7);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8927,37 +8315,42 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 PHP_METHOD(Tensor_Matrix, multiplyVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -8982,56 +8375,42 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2495);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2537);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2508);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_multiply(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2505);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_multiply(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2505);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_multiply(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2547);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -9047,37 +8426,42 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 PHP_METHOD(Tensor_Matrix, divideVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -9102,56 +8486,42 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2523);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2565);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2536);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_divide(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2533);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_divide(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2533);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_divide(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2575);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -9167,37 +8537,42 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 PHP_METHOD(Tensor_Matrix, addVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -9222,56 +8597,42 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2551);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2593);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2564);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_add(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2561);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_add(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2561);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_add(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2603);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -9287,37 +8648,42 @@ PHP_METHOD(Tensor_Matrix, addVector)
 PHP_METHOD(Tensor_Matrix, subtractVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -9342,56 +8708,42 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2579);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2621);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2592);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_subtract(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2589);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_subtract(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2589);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_subtract(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2631);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -9407,37 +8759,42 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 PHP_METHOD(Tensor_Matrix, powVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -9462,56 +8819,42 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2607);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2649);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2620);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_pow(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2617);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_pow(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2617);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_pow(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2659);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -9527,37 +8870,42 @@ PHP_METHOD(Tensor_Matrix, powVector)
 PHP_METHOD(Tensor_Matrix, modVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -9582,56 +8930,42 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2635);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2677);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2648);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_mod(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2645);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_mod(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2645);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_mod(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2687);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -9648,37 +8982,42 @@ PHP_METHOD(Tensor_Matrix, modVector)
 PHP_METHOD(Tensor_Matrix, equalVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -9703,56 +9042,42 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2664);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2706);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2677);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2674);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2674);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_equal(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2716);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -9768,37 +9093,42 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 PHP_METHOD(Tensor_Matrix, notEqualVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
+	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -9823,56 +9153,42 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2692);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2734);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2705);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_not_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2702);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_not_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2702);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_not_equal(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2744);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -9888,37 +9204,42 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 PHP_METHOD(Tensor_Matrix, greaterVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -9943,56 +9264,42 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2720);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2762);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2733);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_greater(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2730);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_greater(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2730);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_greater(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2772);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -10008,37 +9315,42 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -10063,56 +9375,42 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2748);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2790);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2761);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_greater_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2758);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_greater_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2758);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_greater_equal(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2800);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -10128,37 +9426,42 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 PHP_METHOD(Tensor_Matrix, lessVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -10183,56 +9486,42 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2776);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2818);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2789);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_less(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2786);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_less(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2786);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_less(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2828);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -10249,37 +9538,42 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 PHP_METHOD(Tensor_Matrix, lessEqualVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _14;
+	zend_bool _9;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowA, bHat, _8, *_9, _10, *_11, _13, _2$$3, _3$$3, _5$$3, _12$$4, _15$$5;
+	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_13$$4);
+	ZVAL_UNDEF(&_14$$4);
+	ZVAL_UNDEF(&_15$$4);
+	ZVAL_UNDEF(&_16$$4);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -10304,56 +9598,42 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2805);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2847);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&c);
 	array_init(&c);
-	ZEPHIR_CALL_METHOD(&bHat, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2818);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			tensor_less_equal(&_12$$4, &rowA, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2815);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	_11 = (zephir_get_numberval(&_8) - 1);
+	_10 = 0;
+	_9 = 0;
+	if (_10 <= _11) {
 		while (1) {
-			if (_14) {
-				_14 = 0;
+			if (_9) {
+				_10++;
+				if (!(_10 <= _11)) {
+					break;
+				}
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
+				_9 = 1;
 			}
-			ZEPHIR_CALL_METHOD(&_13, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$5);
-				tensor_less_equal(&_15$$5, &rowA, &bHat);
-				zephir_array_append(&c, &_15$$5, PH_SEPARATE, "tensor/matrix.zep", 2815);
+			ZEPHIR_INIT_NVAR(&i);
+			ZVAL_LONG(&i, _10);
+			ZEPHIR_INIT_NVAR(&_12$$4);
+			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_16$$4);
+			mul_function(&_16$$4, &i, &_15$$4);
+			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
+			zephir_check_call_status();
+			tensor_less_equal(&_12$$4, &_14$$4, &bHat);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2857);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -10369,13 +9649,13 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -10385,28 +9665,36 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -10430,7 +9718,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2833);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2875);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10445,7 +9733,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2844);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2886);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10459,37 +9747,45 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2841);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_multiply_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2841);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2883);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2841);
-				tensor_multiply_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2841);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_multiply_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2883);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10509,13 +9805,13 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 PHP_METHOD(Tensor_Matrix, divideColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -10525,28 +9821,36 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -10570,7 +9874,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2859);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2901);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10585,7 +9889,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2870);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2912);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10599,37 +9903,45 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2867);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_divide_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2867);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2909);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2867);
-				tensor_divide_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2867);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_divide_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2909);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10649,13 +9961,13 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 PHP_METHOD(Tensor_Matrix, addColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -10665,28 +9977,36 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -10710,7 +10030,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2885);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2927);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10725,7 +10045,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2896);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2938);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10739,37 +10059,45 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2893);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_add_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2893);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2935);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2893);
-				tensor_add_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2893);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_add_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2935);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10789,13 +10117,13 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -10805,28 +10133,36 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -10850,7 +10186,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2911);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2953);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10865,7 +10201,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2922);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2964);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10879,37 +10215,45 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2919);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_subtract_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2919);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2961);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2919);
-				tensor_subtract_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2919);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_subtract_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2961);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10929,13 +10273,13 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 PHP_METHOD(Tensor_Matrix, powColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -10945,28 +10289,36 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -10990,7 +10342,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2937);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2979);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11005,7 +10357,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2948);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2990);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11019,37 +10371,45 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2945);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_pow_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2945);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2987);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2945);
-				tensor_pow_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2945);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_pow_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2987);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11069,13 +10429,13 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 PHP_METHOD(Tensor_Matrix, modColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -11085,28 +10445,36 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -11130,7 +10498,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2963);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3005);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11145,7 +10513,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2974);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3016);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11159,37 +10527,45 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2971);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_mod_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2971);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3013);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2971);
-				tensor_mod_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2971);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_mod_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3013);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11209,13 +10585,13 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 PHP_METHOD(Tensor_Matrix, equalColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -11225,28 +10601,36 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -11270,7 +10654,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2989);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3031);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11285,7 +10669,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3000);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3042);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11299,37 +10683,45 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 2997);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2997);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3039);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 2997);
-				tensor_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 2997);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_equal_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3039);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11349,13 +10741,13 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -11365,28 +10757,36 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -11410,7 +10810,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3015);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3057);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11425,7 +10825,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3026);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3068);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11439,37 +10839,45 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3023);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_not_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3023);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3065);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3023);
-				tensor_not_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3023);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_not_equal_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3065);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11489,13 +10897,13 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -11505,28 +10913,36 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -11550,7 +10966,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3041);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3083);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11565,7 +10981,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3052);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3094);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11579,37 +10995,45 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3049);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_greater_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3049);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3091);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3049);
-				tensor_greater_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3049);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_greater_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3091);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11629,13 +11053,13 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -11645,28 +11069,36 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -11690,7 +11122,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3067);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3109);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11705,7 +11137,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3078);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3120);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11719,37 +11151,45 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3075);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_greater_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3075);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3117);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3075);
-				tensor_greater_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3075);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_greater_equal_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3117);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11769,13 +11209,13 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 PHP_METHOD(Tensor_Matrix, lessColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -11785,28 +11225,36 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -11830,7 +11278,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3093);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3135);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11845,7 +11293,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3104);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3146);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11859,37 +11307,45 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3101);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_less_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3101);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3143);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3101);
-				tensor_less_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3101);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_less_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3143);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11909,13 +11365,13 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _18;
+	zend_bool _20;
 	zend_string *_13;
 	zend_ulong _12;
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _17, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _19$$5, _20$$5, _21$$5;
+	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -11925,28 +11381,36 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	ZVAL_UNDEF(&valueB);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_14$$4);
 	ZVAL_UNDEF(&_15$$4);
 	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_20$$5);
+	ZVAL_UNDEF(&_17$$4);
+	ZVAL_UNDEF(&_18$$4);
 	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_22$$5);
+	ZVAL_UNDEF(&_23$$5);
+	ZVAL_UNDEF(&_24$$5);
+	ZVAL_UNDEF(&_25$$5);
 	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\columnvector")))
@@ -11970,7 +11434,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3119);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3161);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11985,7 +11449,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3130);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3172);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11999,37 +11463,45 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 			ZVAL_COPY(&valueB, _11);
 			ZEPHIR_INIT_NVAR(&_14$$4);
 			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_OBS_NVAR(&_16$$4);
-			zephir_array_fetch(&_16$$4, &_15$$4, &i, PH_NOISY, "tensor/matrix.zep", 3127);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_INIT_NVAR(&_18$$4);
+			mul_function(&_18$$4, &i, &_17$$4);
+			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
+			zephir_check_call_status();
 			tensor_less_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3127);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3169);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_20 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_20) {
+				_20 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _9, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_19)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
 			zephir_check_call_status();
 			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_19$$5);
-				zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_OBS_NVAR(&_21$$5);
-				zephir_array_fetch(&_21$$5, &_20$$5, &i, PH_NOISY, "tensor/matrix.zep", 3127);
-				tensor_less_equal_scalar(&_19$$5, &_21$$5, &valueB);
-				zephir_array_append(&c, &_19$$5, PH_SEPARATE, "tensor/matrix.zep", 3127);
+				ZEPHIR_INIT_NVAR(&_21$$5);
+				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_INIT_NVAR(&_25$$5);
+				mul_function(&_25$$5, &i, &_24$$5);
+				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
+				zephir_check_call_status();
+				tensor_less_equal_scalar(&_21$$5, &_23$$5, &valueB);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3169);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -12047,27 +11519,29 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
  */
 PHP_METHOD(Tensor_Matrix, multiplyScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12076,53 +11550,13 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3149);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_multiply_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3146);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_multiply_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3146);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_multiply_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12135,27 +11569,29 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
  */
 PHP_METHOD(Tensor_Matrix, divideScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12164,53 +11600,13 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3168);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_divide_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3165);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_divide_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3165);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_divide_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12223,27 +11619,29 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
  */
 PHP_METHOD(Tensor_Matrix, addScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12252,53 +11650,13 @@ PHP_METHOD(Tensor_Matrix, addScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3187);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_add_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3184);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_add_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3184);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_add_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12311,27 +11669,29 @@ PHP_METHOD(Tensor_Matrix, addScalar)
  */
 PHP_METHOD(Tensor_Matrix, subtractScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12340,53 +11700,13 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3206);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_subtract_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3203);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_subtract_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3203);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_subtract_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12399,27 +11719,29 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
  */
 PHP_METHOD(Tensor_Matrix, powScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12428,53 +11750,13 @@ PHP_METHOD(Tensor_Matrix, powScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3225);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_pow_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3222);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_pow_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3222);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_pow_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12487,27 +11769,29 @@ PHP_METHOD(Tensor_Matrix, powScalar)
  */
 PHP_METHOD(Tensor_Matrix, modScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12516,53 +11800,13 @@ PHP_METHOD(Tensor_Matrix, modScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3244);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_mod_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3241);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_mod_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3241);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_mod_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12575,27 +11819,29 @@ PHP_METHOD(Tensor_Matrix, modScalar)
  */
 PHP_METHOD(Tensor_Matrix, equalScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12604,53 +11850,13 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3263);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3260);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3260);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_equal_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12663,27 +11869,29 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
  */
 PHP_METHOD(Tensor_Matrix, notEqualScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12692,53 +11900,13 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3282);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_not_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3279);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_not_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3279);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_not_equal_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12751,27 +11919,29 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
  */
 PHP_METHOD(Tensor_Matrix, greaterScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12780,53 +11950,13 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3301);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_greater_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3298);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_greater_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3298);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_greater_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12840,27 +11970,29 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
  */
 PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12869,53 +12001,13 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3321);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_greater_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3318);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_greater_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3318);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_greater_equal_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -12928,27 +12020,29 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
  */
 PHP_METHOD(Tensor_Matrix, lessScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -12957,53 +12051,13 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3340);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_less_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3337);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_less_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3337);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_less_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -13017,27 +12071,29 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
  */
 PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 {
-	zend_bool _7;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b_param = NULL, rowA, _0, *_1, _2, *_3, _6, _4$$3, _5$$3, _8$$4, _9$$4;
+	zval *b_param = NULL, result, _0, _1, _2, _3;
 	double b;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&c);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(b_param)
@@ -13046,53 +12102,13 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (Z_TYPE_P(&_0) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &_0);
-		_1 = &_2;
-	} else {
-		_1 = &_0;
-	}
-	zephir_is_iterable(_1, 0, "tensor/matrix.zep", 3360);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			ZVAL_DOUBLE(&_5$$3, b);
-			tensor_less_equal_scalar(&_4$$3, &rowA, &_5$$3);
-			zephir_array_append(&c, &_4$$3, PH_SEPARATE, "tensor/matrix.zep", 3357);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_7 = 1;
-		while (1) {
-			if (_7) {
-				_7 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_6, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_6)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_8$$4);
-				ZVAL_DOUBLE(&_9$$4, b);
-				tensor_less_equal_scalar(&_8$$4, &rowA, &_9$$4);
-				zephir_array_append(&c, &_8$$4, PH_SEPARATE, "tensor/matrix.zep", 3357);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZVAL_DOUBLE(&_1, b);
+	tensor_less_equal_scalar(&result, &_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -13129,7 +12145,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3378);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3348);
 	return;
 }
 
@@ -13141,22 +12157,30 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
  */
 PHP_METHOD(Tensor_Matrix, offsetExists)
 {
-	zval *index, index_sub, _0;
+	zend_bool _0;
+	zval *index, index_sub, _1;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&index_sub);
-	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	RETURN_BOOL(zephir_array_isset_value(&_0, index));
+	if (Z_TYPE_P(index) != IS_LONG) {
+		RETURN_BOOL(0);
+	}
+	_0 = ZEPHIR_GE_LONG(index, 0);
+	if (_0) {
+		zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+		_0 = ZEPHIR_LT(index, &_1);
+	}
+	RETURN_BOOL(_0);
 }
 
 /**
@@ -13172,7 +12196,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3398);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3372);
 	return;
 }
 
@@ -13185,21 +12209,36 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
  */
 PHP_METHOD(Tensor_Matrix, offsetGet)
 {
-	zval _2, _3;
+	zval _6$$4, _7$$4;
+	zend_bool _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *index, index_sub, row, _0, _1;
+	zval *index, index_sub, _0$$3, _1$$3, _2$$3, _4, _8, _9, _10, _11, _5$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&index_sub);
-	ZVAL_UNDEF(&row);
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_7$$4);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -13208,23 +12247,46 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &index);
-	zephir_memory_observe(&row);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	if (EXPECTED(zephir_array_isset_fetch(&row, &_0, index, 0))) {
-		ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "quick", NULL, 0, &row);
+	if (UNEXPECTED(Z_TYPE_P(index) != IS_LONG)) {
+		ZEPHIR_INIT_VAR(&_0$$3);
+		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_1$$3);
+		zephir_gettype(&_1$$3, index);
+		ZEPHIR_INIT_VAR(&_2$$3);
+		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_2$$3);
 		zephir_check_call_status();
-		RETURN_MM();
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3386);
+		ZEPHIR_MM_RESTORE();
+		return;
 	}
-	ZEPHIR_INIT_VAR(&_1);
-	object_init_ex(&_1, tensor_exceptions_invalidargumentexception_ce);
-	zephir_cast_to_string(&_2, index);
-	ZEPHIR_INIT_VAR(&_3);
-	ZEPHIR_CONCAT_SSVS(&_3, "Element not found at", " offset ", &_2, ".");
-	ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 3, &_3);
+	_3 = ZEPHIR_LT_LONG(index, 0);
+	if (!(_3)) {
+		zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+		_3 = ZEPHIR_GE(index, &_4);
+	}
+	if (UNEXPECTED(_3)) {
+		ZEPHIR_INIT_VAR(&_5$$4);
+		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
+		zephir_cast_to_string(&_6$$4, index);
+		ZEPHIR_INIT_VAR(&_7$$4);
+		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_7$$4);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3391);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_INIT_VAR(&_11);
+	mul_function(&_11, index, &_10);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, &_8, "slice", NULL, 0, &_11, &_10);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_1, "tensor/matrix.zep", 3417);
-	ZEPHIR_MM_RESTORE();
-	return;
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_9);
+	zephir_check_call_status();
+	RETURN_MM();
 }
 
 /**
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index e2d2e09..e740eb3 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -222,6 +222,8 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_matrix___construct, 0, 0, 1)
 	ZEND_ARG_INFO(0, a)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, m, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, n, IS_LONG, 0, "0")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
 ZEND_END_ARG_INFO()
 
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index f48d61f..72bb5d6 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -939,6 +939,17 @@ PHP_METHOD(Tensor_Vector, asArray)
 	RETURN_MM();
 }
 
+/**
+ * Return the underlying TensorBuffer of the vector.
+ *
+ * @return \Tensor\TensorBuffer
+ */
+PHP_METHOD(Tensor_Vector, asTensorBuffer)
+{
+
+	RETURN_MEMBER(getThis(), "a");
+}
+
 /**
  * Return this vector as a row matrix.
  *
@@ -1012,7 +1023,7 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 	} else {
 		_1 = &aHat;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 405);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 415);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -1021,7 +1032,7 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 			ZEPHIR_INIT_NVAR(&_4$$3);
 			zephir_create_array(&_4$$3, 1, 0);
 			zephir_array_fast_append(&_4$$3, &valueA);
-			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/vector.zep", 402);
+			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/vector.zep", 412);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -1044,7 +1055,7 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 				ZEPHIR_INIT_NVAR(&_7$$4);
 				zephir_create_array(&_7$$4, 1, 0);
 				zephir_array_fast_append(&_7$$4, &valueA);
-				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 402);
+				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 412);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -1110,7 +1121,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_SS(&_2$$3, "The number of rows", " and/or columns cannot be less than 0.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 420);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 430);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1127,7 +1138,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_VSSVS(&_7$$4, &_6$$4, " elements", " are needed but vector only has ", &_5$$4, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 427);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 437);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1150,10 +1161,10 @@ PHP_METHOD(Tensor_Vector, reshape)
 			ZVAL_LONG(&_10$$6, i);
 			ZEPHIR_CALL_METHOD(&_9$$6, &_8$$6, "get", NULL, 0, &_10$$6);
 			zephir_check_call_status();
-			zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/vector.zep", 439);
+			zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/vector.zep", 449);
 			i++;
 		}
-		zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/vector.zep", 444);
+		zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/vector.zep", 454);
 	}
 	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &b);
 	zephir_check_call_status();
@@ -1331,7 +1342,7 @@ PHP_METHOD(Tensor_Vector, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " elements 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/vector.zep", 499);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 509);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1401,7 +1412,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Vector B cannot be", " larger than Vector A.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 517);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 527);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1415,7 +1426,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Stride cannot be", " less than 1, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 522);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 532);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1545,7 +1556,7 @@ PHP_METHOD(Tensor_Vector, outer)
 	} else {
 		_3 = &aHat;
 	}
-	zephir_is_iterable(_3, 0, "tensor/vector.zep", 578);
+	zephir_is_iterable(_3, 0, "tensor/vector.zep", 588);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -1553,7 +1564,7 @@ PHP_METHOD(Tensor_Vector, outer)
 			ZVAL_COPY(&valueA, _5);
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
-			zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 575);
+			zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 585);
 			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _7$$3, _8$$3, _6$$3)
 			{
 				ZEPHIR_INIT_NVAR(&j);
@@ -1566,11 +1577,11 @@ PHP_METHOD(Tensor_Vector, outer)
 				ZVAL_COPY(&valueB, _6$$3);
 				ZEPHIR_INIT_NVAR(&_9$$4);
 				mul_function(&_9$$4, &valueA, &valueB);
-				zephir_array_append(&rowC, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 572);
+				zephir_array_append(&rowC, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 582);
 			} ZEND_HASH_FOREACH_END();
 			ZEPHIR_INIT_NVAR(&valueB);
 			ZEPHIR_INIT_NVAR(&j);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 575);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 585);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -1592,7 +1603,7 @@ PHP_METHOD(Tensor_Vector, outer)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
-				zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 575);
+				zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 585);
 				ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$5, _14$$5, _12$$5)
 				{
 					ZEPHIR_INIT_NVAR(&j);
@@ -1605,11 +1616,11 @@ PHP_METHOD(Tensor_Vector, outer)
 					ZVAL_COPY(&valueB, _12$$5);
 					ZEPHIR_INIT_NVAR(&_15$$6);
 					mul_function(&_15$$6, &valueA, &valueB);
-					zephir_array_append(&rowC, &_15$$6, PH_SEPARATE, "tensor/vector.zep", 572);
+					zephir_array_append(&rowC, &_15$$6, PH_SEPARATE, "tensor/vector.zep", 582);
 				} ZEND_HASH_FOREACH_END();
 				ZEPHIR_INIT_NVAR(&valueB);
 				ZEPHIR_INIT_NVAR(&j);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 575);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 585);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -1710,7 +1721,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "P must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 612);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 622);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1812,7 +1823,7 @@ PHP_METHOD(Tensor_Vector, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 655);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 665);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1878,7 +1889,7 @@ PHP_METHOD(Tensor_Vector, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 685);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 695);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1945,7 +1956,7 @@ PHP_METHOD(Tensor_Vector, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 716);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 726);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2012,7 +2023,7 @@ PHP_METHOD(Tensor_Vector, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " vector from the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 747);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 757);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2079,7 +2090,7 @@ PHP_METHOD(Tensor_Vector, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " vector to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 778);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 788);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2146,7 +2157,7 @@ PHP_METHOD(Tensor_Vector, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " vector with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 809);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 819);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2213,7 +2224,7 @@ PHP_METHOD(Tensor_Vector, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 840);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 850);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2280,7 +2291,7 @@ PHP_METHOD(Tensor_Vector, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 871);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 881);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2347,7 +2358,7 @@ PHP_METHOD(Tensor_Vector, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 902);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 912);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2414,7 +2425,7 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 933);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 943);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2481,7 +2492,7 @@ PHP_METHOD(Tensor_Vector, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 964);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 974);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2548,7 +2559,7 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 995);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 1005);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2756,7 +2767,7 @@ PHP_METHOD(Tensor_Vector, log)
 	} else {
 		_2 = &a;
 	}
-	zephir_is_iterable(_2, 0, "tensor/vector.zep", 1081);
+	zephir_is_iterable(_2, 0, "tensor/vector.zep", 1091);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -2765,7 +2776,7 @@ PHP_METHOD(Tensor_Vector, log)
 			ZVAL_DOUBLE(&_5$$4, base);
 			ZEPHIR_CALL_FUNCTION(&_6$$4, "log", &_7, 8, &valueA, &_5$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/vector.zep", 1078);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/vector.zep", 1088);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -2788,7 +2799,7 @@ PHP_METHOD(Tensor_Vector, log)
 				ZVAL_DOUBLE(&_10$$5, base);
 				ZEPHIR_CALL_FUNCTION(&_11$$5, "log", &_7, 8, &valueA, &_10$$5);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/vector.zep", 1078);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/vector.zep", 1088);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -3183,12 +3194,12 @@ PHP_METHOD(Tensor_Vector, median)
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
 		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1240);
+		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1250);
 	} else {
 		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1242);
+		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1252);
 		zephir_memory_observe(&_5$$4);
-		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1242);
+		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1252);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
 		ZEPHIR_INIT_NVAR(&median);
@@ -3255,7 +3266,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1259);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1269);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3273,15 +3284,15 @@ PHP_METHOD(Tensor_Vector, quantile)
 	if (ZEPHIR_LE_LONG(&_7, xHat)) {
 		zephir_memory_observe(&_8$$4);
 		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1271);
+		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1281);
 		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
 	}
 	remainder =  ((x -  (double) xHat));
 	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1276);
+	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1286);
 	t =  (zephir_get_doubleval(&_10));
 	zephir_memory_observe(&_11);
-	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1278);
+	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1288);
 	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
 }
 
@@ -3340,7 +3351,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1293);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1303);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3423,7 +3434,7 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_CONCAT_SSVS(&_4$$4, "Decimal precision cannot", " be less than 0, ", &_3$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_4$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1321);
+		zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1331);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3439,7 +3450,7 @@ PHP_METHOD(Tensor_Vector, round)
 	} else {
 		_6 = &a;
 	}
-	zephir_is_iterable(_6, 0, "tensor/vector.zep", 1334);
+	zephir_is_iterable(_6, 0, "tensor/vector.zep", 1344);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -3448,7 +3459,7 @@ PHP_METHOD(Tensor_Vector, round)
 			ZEPHIR_INIT_NVAR(&_9$$5);
 			ZVAL_LONG(&_10$$5, precision);
 			zephir_round(&_9$$5, &valueA, &_10$$5, NULL);
-			zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/vector.zep", 1331);
+			zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/vector.zep", 1341);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -3471,7 +3482,7 @@ PHP_METHOD(Tensor_Vector, round)
 				ZEPHIR_INIT_NVAR(&_13$$6);
 				ZVAL_LONG(&_14$$6, precision);
 				zephir_round(&_13$$6, &valueA, &_14$$6, NULL);
-				zephir_array_append(&b, &_13$$6, PH_SEPARATE, "tensor/vector.zep", 1331);
+				zephir_array_append(&b, &_13$$6, PH_SEPARATE, "tensor/vector.zep", 1341);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -3579,7 +3590,7 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1370);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1380);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3595,7 +3606,7 @@ PHP_METHOD(Tensor_Vector, clip)
 	} else {
 		_3 = &a;
 	}
-	zephir_is_iterable(_3, 0, "tensor/vector.zep", 1395);
+	zephir_is_iterable(_3, 0, "tensor/vector.zep", 1405);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -3604,16 +3615,16 @@ PHP_METHOD(Tensor_Vector, clip)
 			if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 				ZEPHIR_INIT_NVAR(&_6$$5);
 				ZVAL_DOUBLE(&_6$$5, max);
-				zephir_array_append(&b, &_6$$5, PH_SEPARATE, "tensor/vector.zep", 1381);
+				zephir_array_append(&b, &_6$$5, PH_SEPARATE, "tensor/vector.zep", 1391);
 				continue;
 			}
 			if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 				ZEPHIR_INIT_NVAR(&_7$$6);
 				ZVAL_DOUBLE(&_7$$6, min);
-				zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1387);
+				zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1397);
 				continue;
 			}
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1392);
+			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1402);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -3636,16 +3647,16 @@ PHP_METHOD(Tensor_Vector, clip)
 				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 					ZEPHIR_INIT_NVAR(&_10$$8);
 					ZVAL_DOUBLE(&_10$$8, max);
-					zephir_array_append(&b, &_10$$8, PH_SEPARATE, "tensor/vector.zep", 1381);
+					zephir_array_append(&b, &_10$$8, PH_SEPARATE, "tensor/vector.zep", 1391);
 					continue;
 				}
 				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 					ZEPHIR_INIT_NVAR(&_11$$9);
 					ZVAL_DOUBLE(&_11$$9, min);
-					zephir_array_append(&b, &_11$$9, PH_SEPARATE, "tensor/vector.zep", 1387);
+					zephir_array_append(&b, &_11$$9, PH_SEPARATE, "tensor/vector.zep", 1397);
 					continue;
 				}
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1392);
+				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1402);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -3702,7 +3713,7 @@ PHP_METHOD(Tensor_Vector, clipLower)
 	} else {
 		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1422);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1432);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -3711,10 +3722,10 @@ PHP_METHOD(Tensor_Vector, clipLower)
 			if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 				ZEPHIR_INIT_NVAR(&_4$$4);
 				ZVAL_DOUBLE(&_4$$4, min);
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1414);
+				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1424);
 				continue;
 			}
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1419);
+			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1429);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -3737,10 +3748,10 @@ PHP_METHOD(Tensor_Vector, clipLower)
 				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
 					ZEPHIR_INIT_NVAR(&_7$$6);
 					ZVAL_DOUBLE(&_7$$6, min);
-					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1414);
+					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1424);
 					continue;
 				}
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1419);
+				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1429);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -3797,7 +3808,7 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 	} else {
 		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1449);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1459);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -3806,10 +3817,10 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 			if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 				ZEPHIR_INIT_NVAR(&_4$$4);
 				ZVAL_DOUBLE(&_4$$4, max);
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1441);
+				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1451);
 				continue;
 			}
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1446);
+			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1456);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -3832,10 +3843,10 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
 					ZEPHIR_INIT_NVAR(&_7$$6);
 					ZVAL_DOUBLE(&_7$$6, max);
-					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1441);
+					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1451);
 					continue;
 				}
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1446);
+				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1456);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -3889,7 +3900,7 @@ PHP_METHOD(Tensor_Vector, sign)
 	} else {
 		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1475);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1485);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -3898,15 +3909,15 @@ PHP_METHOD(Tensor_Vector, sign)
 			if (ZEPHIR_GT_LONG(&valueA, 0)) {
 				ZEPHIR_INIT_NVAR(&_4$$4);
 				ZVAL_DOUBLE(&_4$$4, 1.0);
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1467);
+				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1477);
 			} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 				ZEPHIR_INIT_NVAR(&_5$$5);
 				ZVAL_DOUBLE(&_5$$5, -1.0);
-				zephir_array_append(&b, &_5$$5, PH_SEPARATE, "tensor/vector.zep", 1469);
+				zephir_array_append(&b, &_5$$5, PH_SEPARATE, "tensor/vector.zep", 1479);
 			} else {
 				ZEPHIR_INIT_NVAR(&_6$$6);
 				ZVAL_DOUBLE(&_6$$6, 0.0);
-				zephir_array_append(&b, &_6$$6, PH_SEPARATE, "tensor/vector.zep", 1471);
+				zephir_array_append(&b, &_6$$6, PH_SEPARATE, "tensor/vector.zep", 1481);
 			}
 		} ZEND_HASH_FOREACH_END();
 	} else {
@@ -3930,15 +3941,15 @@ PHP_METHOD(Tensor_Vector, sign)
 				if (ZEPHIR_GT_LONG(&valueA, 0)) {
 					ZEPHIR_INIT_NVAR(&_9$$8);
 					ZVAL_DOUBLE(&_9$$8, 1.0);
-					zephir_array_append(&b, &_9$$8, PH_SEPARATE, "tensor/vector.zep", 1467);
+					zephir_array_append(&b, &_9$$8, PH_SEPARATE, "tensor/vector.zep", 1477);
 				} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
 					ZEPHIR_INIT_NVAR(&_10$$9);
 					ZVAL_DOUBLE(&_10$$9, -1.0);
-					zephir_array_append(&b, &_10$$9, PH_SEPARATE, "tensor/vector.zep", 1469);
+					zephir_array_append(&b, &_10$$9, PH_SEPARATE, "tensor/vector.zep", 1479);
 				} else {
 					ZEPHIR_INIT_NVAR(&_11$$10);
 					ZVAL_DOUBLE(&_11$$10, 0.0);
-					zephir_array_append(&b, &_11$$10, PH_SEPARATE, "tensor/vector.zep", 1471);
+					zephir_array_append(&b, &_11$$10, PH_SEPARATE, "tensor/vector.zep", 1481);
 				}
 		}
 	}
@@ -3987,14 +3998,14 @@ PHP_METHOD(Tensor_Vector, negate)
 	} else {
 		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1495);
+	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1505);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
 			ZEPHIR_INIT_NVAR(&valueA);
 			ZVAL_COPY(&valueA, _3);
 			zephir_negate(&valueA);
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1492);
+			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1502);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -4015,7 +4026,7 @@ PHP_METHOD(Tensor_Vector, negate)
 			ZEPHIR_CALL_METHOD(&valueA, _1, "current", NULL, 0);
 			zephir_check_call_status();
 				zephir_negate(&valueA);
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1492);
+				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1502);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -4090,7 +4101,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1510);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1520);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4105,7 +4116,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1521);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1531);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4114,7 +4125,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1518);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1528);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4137,7 +4148,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1518);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1528);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4212,7 +4223,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1536);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1546);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4227,7 +4238,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1547);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1557);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4236,7 +4247,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1544);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1554);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4259,7 +4270,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1544);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1554);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4334,7 +4345,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1562);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1572);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4349,7 +4360,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1573);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1583);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4358,7 +4369,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1570);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1580);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4381,7 +4392,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1570);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1580);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4456,7 +4467,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1588);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1598);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4471,7 +4482,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1599);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1609);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4480,7 +4491,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1596);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1606);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4503,7 +4514,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1596);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1606);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4578,7 +4589,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1614);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1624);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4593,7 +4604,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1625);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1635);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4602,7 +4613,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1622);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1632);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4625,7 +4636,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1622);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1632);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4700,7 +4711,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1640);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1650);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4715,7 +4726,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1651);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1661);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4724,7 +4735,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1648);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1658);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4747,7 +4758,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1648);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1658);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4822,7 +4833,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1666);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1676);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4837,7 +4848,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1677);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1687);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4846,7 +4857,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1674);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1684);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4869,7 +4880,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1674);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1684);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4944,7 +4955,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1692);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1702);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4959,7 +4970,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1703);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1713);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4968,7 +4979,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1700);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1710);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4991,7 +5002,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1700);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1710);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5066,7 +5077,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1718);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1728);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5081,7 +5092,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1729);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1739);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5090,7 +5101,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1726);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1736);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5113,7 +5124,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1726);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1736);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5188,7 +5199,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1744);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1754);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5203,7 +5214,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1755);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1765);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5212,7 +5223,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1752);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1762);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5235,7 +5246,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1752);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1762);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5310,7 +5321,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1770);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1780);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5325,7 +5336,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1781);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1791);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5334,7 +5345,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1778);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1788);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5357,7 +5368,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1778);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1788);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5432,7 +5443,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1796);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1806);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5447,7 +5458,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1807);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1817);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5456,7 +5467,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1804);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1814);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5479,7 +5490,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1804);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1814);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5546,7 +5557,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1822);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1832);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5617,7 +5628,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1840);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1850);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5688,7 +5699,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1858);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1868);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5759,7 +5770,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1876);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1886);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5830,7 +5841,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1894);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1904);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5901,7 +5912,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1912);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1922);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5973,7 +5984,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1931);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1941);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6044,7 +6055,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1949);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1959);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6115,7 +6126,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1967);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1977);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6186,7 +6197,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1985);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1995);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6257,7 +6268,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 2003);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 2013);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6328,7 +6339,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 2021);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 2031);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6826,7 +6837,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2178);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2188);
 	return;
 }
 
@@ -6877,7 +6888,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2202);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2212);
 	return;
 }
 
@@ -6935,7 +6946,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 3, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2216);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2226);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/vector.zep.h b/ext/tensor/vector.zep.h
index 624a147..e51c653 100644
--- a/ext/tensor/vector.zep.h
+++ b/ext/tensor/vector.zep.h
@@ -22,6 +22,7 @@ PHP_METHOD(Tensor_Vector, size);
 PHP_METHOD(Tensor_Vector, m);
 PHP_METHOD(Tensor_Vector, n);
 PHP_METHOD(Tensor_Vector, asArray);
+PHP_METHOD(Tensor_Vector, asTensorBuffer);
 PHP_METHOD(Tensor_Vector, asRowMatrix);
 PHP_METHOD(Tensor_Vector, asColumnMatrix);
 PHP_METHOD(Tensor_Vector, reshape);
@@ -201,6 +202,9 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_vector_asarray, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_astensorbuffer, 0, 0, Tensor\\TensorBuffer, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_asrowmatrix, 0, 0, Tensor\\Matrix, 0)
 ZEND_END_ARG_INFO()
 
@@ -599,6 +603,7 @@ ZEPHIR_INIT_FUNCS(tensor_vector_method_entry) {
 	PHP_ME(Tensor_Vector, m, arginfo_tensor_vector_m, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, n, arginfo_tensor_vector_n, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, asArray, arginfo_tensor_vector_asarray, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Vector, asTensorBuffer, arginfo_tensor_vector_astensorbuffer, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, asRowMatrix, arginfo_tensor_vector_asrowmatrix, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, asColumnMatrix, arginfo_tensor_vector_ascolumnmatrix, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, reshape, arginfo_tensor_vector_reshape, ZEND_ACC_PUBLIC)
diff --git a/optimizers/TensorConvolve2dOptimizer.php b/optimizers/TensorConvolve2dOptimizer.php
index 1a63d06..2dc938b 100644
--- a/optimizers/TensorConvolve2dOptimizer.php
+++ b/optimizers/TensorConvolve2dOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 3) {
+        if (count($expression['parameters']) !== 7) {
             throw new CompilerException(
-                'Convolve 1D accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                'Convolve 2D accepts exactly seven arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_convolve_2d($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+            "tensor_convolve_2d($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]}, {$resolvedParams[3]}, {$resolvedParams[4]}, {$resolvedParams[5]}, {$resolvedParams[6]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorInverseOptimizer.php b/optimizers/TensorInverseOptimizer.php
index 39dd7c0..d63eea7 100644
--- a/optimizers/TensorInverseOptimizer.php
+++ b/optimizers/TensorInverseOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 2) {
             throw new CompilerException(
-                'Inverse accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Inverse accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_inverse($symbol, {$resolvedParams[0]});"
+            "tensor_inverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorMatmulOptimizer.php b/optimizers/TensorMatmulOptimizer.php
index 64a84e7..7d433e6 100644
--- a/optimizers/TensorMatmulOptimizer.php
+++ b/optimizers/TensorMatmulOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 2) {
+        if (count($expression['parameters']) !== 5) {
             throw new CompilerException(
-                'Dot accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                'Matmul accepts exactly five arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_matmul($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+            "tensor_matmul($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]}, {$resolvedParams[3]}, {$resolvedParams[4]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorPseudoinverseOptimizer.php b/optimizers/TensorPseudoinverseOptimizer.php
index 8f9b7f6..03b2dfb 100644
--- a/optimizers/TensorPseudoinverseOptimizer.php
+++ b/optimizers/TensorPseudoinverseOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 3) {
             throw new CompilerException(
-                'Pseudo inverse accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Pseudo inverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_pseudoinverse($symbol, {$resolvedParams[0]});"
+            "tensor_pseudoinverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
         );
 
         return new CompiledExpression(
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index fb167a0..60122c1 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -49,11 +49,11 @@ class Matrix implements Tensor
      * @param array[] a
      * @return self
      */
-    public static function build(const array a = []) -> <Matrix>
+public static function build(const array a = []) -> <Matrix>
     {
-        return new self(a, true);
+        return new self(a, 0, 0, true);
     }
- 
+  
     /**
      * Build a new matrix foregoing any validation for quicker instantiation.
      *
@@ -62,7 +62,7 @@ class Matrix implements Tensor
      */
     public static function quick(const array a = []) -> <Matrix>
     {
-        return new self(a, false);
+        return new self(a, 0, 0, false);
     }
 
     /**
@@ -75,15 +75,7 @@ class Matrix implements Tensor
      */
     public static function fromTensorBuffer(<TensorBuffer> a, const int m, const int n) -> <Matrix>
     {
-        var rowBuffer;
-
-        array rows = [];
-
-        for rowBuffer in a->split(n) {
-            let rows[] = rowBuffer;
-        }
-
-        return new self(rows, false);
+        return new self(a, m, n, false);
     }
 
     /**
@@ -391,86 +383,110 @@ class Matrix implements Tensor
     }
 
     /**
-     * @param array[]|TensorBuffer[] a
+     * @param array[]|TensorBuffer[]|TensorBuffer a
+     * @param int m
+     * @param int n
      * @param bool validate
      * @throws \Tensor\Exceptions\InvalidArgumentException
      */
-    public function __construct(var a, const bool validate = true)
+    public function __construct(var a, const int m = 0, const int n = 0, const bool validate = true)
     {
         var i, rowA, valueA, firstRow;
 
-        if unlikely typeof a !== "array" {
-            throw new InvalidArgumentException("Matrix requires an"
-                . " array of arrays.");
-        }
+        if unlikely typeof a == "array" {
+            int rows = count(a);
 
-        int m = count(a);
+            var nHat;
 
-        var n;
+            array flat = [];
 
-        array flat = [];
+            let firstRow = current(a) ?: [];
 
-        let firstRow = current(a) ?: [];
+            if typeof firstRow == "object" {
+                if unlikely !(firstRow instanceof TensorBuffer) {
+                    throw new InvalidArgumentException("Matrix requires an"
+                        . " array of arrays.");
+                }
 
-        if typeof firstRow == "object" {
-            if unlikely !(firstRow instanceof TensorBuffer) {
-                throw new InvalidArgumentException("Matrix requires an"
-                    . " array of arrays.");
+                let nHat = firstRow->count();
+            } else {
+                let nHat = count(firstRow);
             }
 
-            let n = firstRow->count();
-        } else {
-            let n = count(firstRow);
-        }
-
-        if validate {
-            let a = array_values(a);
-
-            for i, rowA in a {
-                if typeof rowA == "object" {
-                    if unlikely !(rowA instanceof TensorBuffer) {
-                        throw new InvalidArgumentException("Matrix requires an"
-                            . " array of arrays.");
+            if validate {
+                let a = array_values(a);
+
+                for i, rowA in a {
+                    if typeof rowA == "object" {
+                        if unlikely !(rowA instanceof TensorBuffer) {
+                            throw new InvalidArgumentException("Matrix requires an"
+                                . " array of arrays.");
+                        }
+
+                        if unlikely rowA->count() !== nHat {
+                            throw new InvalidArgumentException("The number of"
+                                . " columns must be equal for all rows, "
+                                .  strval(nHat) . " needed but " . rowA->count()
+                                .  " given at row offset " . i . ".");
+                        }
+
+                        let rowA = rowA->toArray();
+                    } else {
+                        if unlikely count(rowA) !== nHat {
+                            throw new InvalidArgumentException("The number of"
+                                . " columns must be equal for all rows, "
+                                .  strval(nHat) . " needed but " . count(rowA)
+                                .  " given at row offset " . i . ".");
+                        }
                     }
 
-                    if unlikely rowA->count() !== n {
-                        throw new InvalidArgumentException("The number of"
-                            . " columns must be equal for all rows, "
-                            .  strval(n) . " needed but " . rowA->count()
-                            .  " given at row offset " . i . ".");
+                    for valueA in rowA {
+                        let flat[] = is_float(valueA) ? valueA : (float) valueA;
+                    }
+                }
+            } else {
+                for rowA in a {
+                    if typeof rowA == "object" {
+                        let rowA = rowA->toArray();
                     }
 
-                    let rowA = rowA->toArray();
-                } else {
-                    if unlikely count(rowA) !== n {
-                        throw new InvalidArgumentException("The number of"
-                            . " columns must be equal for all rows, "
-                            .  strval(n) . " needed but " . count(rowA)
-                            .  " given at row offset " . i . ".");
+                    for valueA in rowA {
+                        let flat[] = (float) valueA;
                     }
                 }
+            }
+
+            var buffer = tensor_buffer_from_array(flat);
 
-                for valueA in rowA {
-                    let flat[] = is_float(valueA) ? valueA : (float) valueA;
+            let this->a = new TensorBuffer(<Buffer> buffer);
+            let this->m = rows;
+            let this->n = nHat;
+        } elseif a instanceof TensorBuffer {
+            if unlikely validate {
+                if unlikely m < 1 {
+                    throw new InvalidArgumentException("The number of rows must be"
+                        . " greater than 0, " . strval(m) . " given.");
                 }
-            }
-        } else {
-            for rowA in a {
-                if typeof rowA == "object" {
-                    let rowA = rowA->toArray();
+
+                if unlikely n < 1 {
+                    throw new InvalidArgumentException("The number of columns must be"
+                        . " greater than 0, " . strval(n) . " given.");
                 }
 
-                for valueA in rowA {
-                    let flat[] = (float) valueA;
+                if unlikely a->count() !== m * n {
+                    throw new InvalidArgumentException("The number of elements"
+                        . " in the buffer must equal m times n, "
+                        .  strval(a->count()) . " given.");
                 }
             }
-        }
-
-        var buffer = tensor_buffer_from_array(flat);
 
-        let this->a = new TensorBuffer(<Buffer> buffer);
-        let this->m = m;
-        let this->n = n;
+            let this->a = <TensorBuffer> a;
+            let this->m = m;
+            let this->n = n;
+        } else {
+            throw new InvalidArgumentException("Matrix requires an array"
+                . " or TensorBuffer object.");
+        }
     }
 
     /**
@@ -759,15 +775,19 @@ class Matrix implements Tensor
      */
     public function transpose() -> <Matrix>
     {
-        int i;
-        
-        array b = [];
- 
-        for i in range(0, this->n - 1) {
-            let b[] = array_column(this->a, i);
+        var col;
+
+        var cols = this->asColumnBuffers();
+
+        if unlikely count(cols) < 1 {
+            return self::quick();
         }
- 
-        return self::quick(b);
+
+        let col = cols[0];
+
+        let col = col->concat(array_slice(cols, 1));
+
+        return self::fromTensorBuffer(col, this->n, this->m);
     }
 
     /**
@@ -788,14 +808,14 @@ class Matrix implements Tensor
                 . " of a singular matrix.");
         }
 
-        var result = tensor_inverse(this->a);
+        var result = tensor_inverse(this->a, this->n);
 
         if is_null(result) {
             throw new RuntimeException("Failed to compute the inverse"
                 . " of a singular matrix.");
         }
 
-        return self::quick(result);
+        return self::fromTensorBuffer(result, this->n, this->n);
     }
 
     /**
@@ -805,14 +825,14 @@ class Matrix implements Tensor
      */
       public function pseudoinverse() -> <Matrix>
     {
-        var result = tensor_pseudoinverse(this->a);
+        var result = tensor_pseudoinverse(this->a, this->m, this->n);
 
         if is_null(result) {
             throw new RuntimeException("Failed to compute the pseudoinverse"
                 . " of the matrix.");
         }
 
-        return self::quick(result);
+        return self::fromTensorBuffer(result, this->n, this->m);
     }
 
     /**
@@ -905,14 +925,10 @@ class Matrix implements Tensor
         }
 
         int i, j;
-        
-        var rowA;
 
         for i in range(0, this->m - 2) {
-            let rowA = this->a[i];
-
             for j in range(i + 1, this->n - 1) {
-                if rowA[j] != this->a[j][i] {
+                if this->a->get(i * this->n + j) != this->a->get(j * this->n + i) {
                     return false;
                 }
             }
@@ -936,7 +952,9 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
          
-        return self::quick(tensor_matmul(this->a, b->asArray()));
+        var result = tensor_matmul(this->a, b->a, this->m, this->n, b->n());
+
+        return self::fromTensorBuffer(result, this->m, b->n());
     }
 
     /**
@@ -977,7 +995,12 @@ class Matrix implements Tensor
                 . " less than 1, " . strval(stride) . " given.");
         }
 
-        return self::quick(tensor_convolve_2d(this->a, b->asArray(), stride));
+        var result = tensor_convolve_2d(this->a, b->a, stride, this->m, this->n, b->m(), b->n());
+
+        int outM = (int) intdiv(this->m + stride - 1, stride);
+        int outN = (int) intdiv(this->n + stride - 1, stride);
+
+        return self::fromTensorBuffer(result, outM, outN);
     }
 
     /**
@@ -1564,17 +1587,22 @@ class Matrix implements Tensor
 
         var rowA, valueA;
 
-        array rowB = [];
+        int i;
+
         array b = [];
  
-        for rowA in this->a {
-            let rowB = [];
- 
-            for valueA in rowA {
-                let rowB[] = log(valueA, base);
+        for rowA in this->a->split(this->n) {
+            let i = 0;
+
+            while i < this->n {
+                let valueA = rowA->get(i);
+
+                rowA->set(i, log(valueA, base));
+
+                let i++;
             }
  
-            let b[] = rowB;
+            let b[] = rowA;
         }
  
         return self::quick(b);
@@ -1677,7 +1705,15 @@ class Matrix implements Tensor
      */
     public function sum() -> <ColumnVector>
     {
-        return ColumnVector::quick(array_map("array_sum", this->a));
+        var rowBuffer;
+
+        array b = [];
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = rowBuffer->sum();
+        }
+
+        return ColumnVector::quick(b);
     }
 
     /**
@@ -1687,7 +1723,15 @@ class Matrix implements Tensor
      */
     public function product() -> <ColumnVector>
     {
-        return ColumnVector::quick(array_map("array_product", this->a));
+        var rowBuffer;
+
+        array b = [];
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = rowBuffer->product();
+        }
+
+        return ColumnVector::quick(b);
     }
 
     /**
@@ -1697,7 +1741,15 @@ class Matrix implements Tensor
      */
     public function min() -> <ColumnVector>
     {
-        return ColumnVector::quick(array_map("min", this->a));
+        var rowBuffer;
+
+        array b = [];
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = rowBuffer->min();
+        }
+
+        return ColumnVector::quick(b);
     }
 
     /**
@@ -1707,7 +1759,15 @@ class Matrix implements Tensor
      */
     public function max() -> <ColumnVector>
     {
-        return ColumnVector::quick(array_map("max", this->a));
+        var rowBuffer;
+
+        array b = [];
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = rowBuffer->max();
+        }
+
+        return ColumnVector::quick(b);
     }
 
     /**
@@ -1727,20 +1787,20 @@ class Matrix implements Tensor
      */
     public function median() -> <ColumnVector>
     {
-        var rowA, median;
+        var rowBuffer, median;
         array b = [];
 
         int mid = (int) intdiv(this->n, 2);
 
         bool odd = this->n % 2 === 1;
 
-        for rowA in this->a {
-            sort(rowA);
+        for rowBuffer in this->a->split(this->n) {
+            rowBuffer->sort();
 
             if odd {
-                let median = rowA[mid];
+                let median = rowBuffer->get(mid);
             } else {
-                let median = (rowA[mid - 1] + rowA[mid]) / 2.0;
+                let median = (rowBuffer->get(mid - 1) + rowBuffer->get(mid)) / 2.0;
             }
 
             let b[] = median;
@@ -1764,7 +1824,7 @@ class Matrix implements Tensor
         }
 
         float t;
-        var rowA;
+        var rowBuffer;
         
         array b = [];
 
@@ -1774,18 +1834,18 @@ class Matrix implements Tensor
     
         float remainder = x - xHat;
 
-        for rowA in this->a {
-            sort(rowA);
+        for rowBuffer in this->a->split(this->n) {
+            rowBuffer->sort();
 
             if xHat >= this->n {
-                let b[] = (float) rowA[this->n - 1];
+                let b[] = (float) rowBuffer->get(this->n - 1);
 
                 continue;
             }
 
-            let t = (float) rowA[xHat - 1];
+            let t = (float) rowBuffer->get(xHat - 1);
 
-            let b[] = t + remainder * (rowA[xHat] - t);
+            let b[] = t + remainder * (rowBuffer->get(xHat) - t);
         }
 
         return ColumnVector::quick(b);
@@ -1866,17 +1926,22 @@ class Matrix implements Tensor
 
         var rowA, valueA;
 
+        int i;
+
         array b = [];
-        array rowB = [];
 
-        for rowA in this->a {
-            let rowB = [];
+        for rowA in this->a->split(this->n) {
+            let i = 0;
 
-            for valueA in rowA {
-                let rowB[] = round(valueA, precision);
+            while i < this->n {
+                let valueA = rowA->get(i);
+
+                rowA->set(i, round(valueA, precision));
+
+                let i++;
             }
 
-            let b[] = rowB;
+            let b[] = rowA;
         }
 
         return self::quick(b);
@@ -1920,29 +1985,36 @@ class Matrix implements Tensor
 
         var rowA, valueA;
 
+        int i;
+
         array b = [];
-        array rowB = [];
 
-        for rowA in this->a {
-            let rowB = [];
+        for rowA in this->a->split(this->n) {
+            let i = 0;
+
+            while i < this->n {
+                let valueA = rowA->get(i);
 
-            for valueA in rowA {
                 if valueA > max {
-                    let rowB[] = max;
+                    rowA->set(i, max);
+
+                    let i++;
 
                     continue;
                 }
 
                 if valueA < min {
-                    let rowB[] = min;
+                    rowA->set(i, min);
+
+                    let i++;
 
                     continue;
                 }
 
-                let rowB[] = valueA;
+                let i++;
             }
 
-            let b[] = rowB;
+            let b[] = rowA;
         }
 
         return self::quick(b);
@@ -1958,23 +2030,24 @@ class Matrix implements Tensor
     {
         var rowA, valueA;
 
+        int i;
+
         array b = [];
-        array rowB = [];
 
-        for rowA in this->a {
-            let rowB = [];
+        for rowA in this->a->split(this->n) {
+            let i = 0;
 
-            for valueA in rowA {
-                if valueA < min {
-                    let rowB[] = min;
+            while i < this->n {
+                let valueA = rowA->get(i);
 
-                    continue;
+                if valueA < min {
+                    rowA->set(i, min);
                 }
 
-                let rowB[] = valueA;
+                let i++;
             }
 
-            let b[] = rowB;
+            let b[] = rowA;
         }
 
         return self::quick(b);
@@ -1990,23 +2063,24 @@ class Matrix implements Tensor
     {
         var rowA, valueA;
 
+        int i;
+
         array b = [];
-        array rowB = [];
 
-        for rowA in this->a {
-            let rowB = [];
+        for rowA in this->a->split(this->n) {
+            let i = 0;
 
-            for valueA in rowA {
-                if valueA > max {
-                    let rowB[] = max;
+            while i < this->n {
+                let valueA = rowA->get(i);
 
-                    continue;
+                if valueA > max {
+                    rowA->set(i, max);
                 }
 
-                let rowB[] = valueA;
+                let i++;
             }
 
-            let b[] = rowB;
+            let b[] = rowA;
         }
 
         return self::quick(b);
@@ -2020,24 +2094,29 @@ class Matrix implements Tensor
     public function sign() -> <Matrix>
     {
         var rowA, valueA;
-        
+
+        int i;
+
         array b = [];
-        array rowB = [];
 
-        for rowA in this->a {
-            let rowB = [];
+        for rowA in this->a->split(this->n) {
+            let i = 0;
+
+            while i < this->n {
+                let valueA = rowA->get(i);
 
-            for valueA in rowA {
                 if valueA > 0 {
-                    let rowB[] = 1.0;
+                    rowA->set(i, 1.0);
                 } elseif valueA < 0 {
-                    let rowB[] = -1.0;
+                    rowA->set(i, -1.0);
                 } else {
-                    let rowB[] = 0.0;
+                    rowA->set(i, 0.0);
                 }
+
+                let i++;
             }
 
-            let b[] = rowB;
+            let b[] = rowA;
         }
 
         return self::quick(b);
@@ -2052,17 +2131,22 @@ class Matrix implements Tensor
     {
         var rowA, valueA;
 
+        int i;
+
         array b = [];
-        array rowB = [];
 
-        for rowA in this->a {
-            let rowB = [];
+        for rowA in this->a->split(this->n) {
+            let i = 0;
 
-            for valueA in rowA {
-                let rowB[] = -valueA;
+            while i < this->n {
+                let valueA = rowA->get(i);
+
+                rowA->set(i, -valueA);
+
+                let i++;
             }
 
-            let b[] = rowB;
+            let b[] = rowA;
         }
 
         return self::quick(b);
@@ -2083,7 +2167,9 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        return self::quick(array_merge(b->asArray(), this->a));
+        var buffer = b->a->concat([this->a]);
+
+        return self::fromTensorBuffer(buffer, b->m() + this->m, this->n);
     }
 
     /**
@@ -2101,7 +2187,9 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        return self::quick(array_merge(this->a, b->asArray()));
+        var buffer = this->a->concat([b->a]);
+
+        return self::fromTensorBuffer(buffer, this->m + b->m(), this->n);
     }
 
     /**
@@ -2119,7 +2207,21 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        return self::quick(array_map("array_merge", b->asArray(), this->a));
+        var i;
+
+        var bufferB, bufferA;
+
+        array c = [];
+
+        for i in range(0, this->m - 1) {
+            let bufferB = b->a->slice(i * b->n(), b->n());
+
+            let bufferA = this->a->slice(i * this->n, this->n);
+
+            let c[] = bufferB->concat([bufferA]);
+        }
+
+        return self::quick(c);
     }
 
     /**
@@ -2137,7 +2239,21 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
         
-        return self::quick(array_map("array_merge", this->a, b->asArray()));
+        var i;
+
+        var bufferA, bufferB;
+
+        array c = [];
+
+        for i in range(0, this->m - 1) {
+            let bufferA = this->a->slice(i * this->n, this->n);
+
+            let bufferB = b->a->slice(i * b->n(), b->n());
+
+            let c[] = bufferA->concat([bufferB]);
+        }
+
+        return self::quick(c);
     }
 
     /**
@@ -2151,28 +2267,26 @@ class Matrix implements Tensor
     public function repeat(const int m, const int n) -> <Matrix>
     {
         var rowA;
-        array b = [];
-        array temp = [];
 
-        if n > 0 {
-            for rowA in this->a {
-                let temp = [];
+        array bigRows = [];
 
-                while count(temp) <= n {
-                    let temp[] = rowA;
-                }
-
-                let b[] = call_user_func_array("array_merge", temp);
+        if n > 0 {
+            for rowA in this->a->split(this->n) {
+                let bigRows[] = rowA->repeat(n + 1);
             }
         }
 
-        let temp = [];
+        if count(bigRows) > 0 {
+            var flat = bigRows[0];
+
+            let flat = flat->concat(array_slice(bigRows, 1));
 
-        while count(temp) <= m {
-            let temp[] = b;
+            let flat = flat->repeat(m + 1);
+
+            return self::fromTensorBuffer(flat, this->m * (m + 1), this->n * (n + 1));
         }
 
-        return self::quick(call_user_func_array("array_merge", temp));
+        return self::quick([]);
     }
 
     /**
@@ -2189,15 +2303,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-
-        array c = [];
+        var result = tensor_multiply(this->a, b->a);
 
-        for i, rowB in b->asArray() {
-            let c[] = tensor_multiply(this->a[i], rowB);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2214,15 +2322,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
+        var result = tensor_divide(this->a, b->a);
 
-        for i, rowB in b->asArray() {
-            let c[] = tensor_divide(this->a[i], rowB);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2239,15 +2341,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
+        var result = tensor_add(this->a, b->a);
 
-        for i, rowB in b->asArray() {
-            let c[] = tensor_add(this->a[i], rowB);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2264,15 +2360,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
-
-        for i, rowB in b->asArray() {
-            let c[] = tensor_subtract(this->a[i], rowB);
-        }
+        var result = tensor_subtract(this->a, b->a);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2290,15 +2380,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
-
-        for i, rowB in b->asArray() {
-            let c[] = tensor_pow(this->a[i], rowB);
-        }
+        var result = tensor_pow(this->a, b->a);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2316,15 +2400,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
-
-        for i, rowB in b->asArray() {
-            let c[] = tensor_mod(this->a[i], rowB);
-        }
+        var result = tensor_mod(this->a, b->a);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2342,15 +2420,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
-
-        for i, rowB in b->asArray() {
-            let c[] = tensor_equal(this->a[i], rowB);
-        }
+        var result = tensor_equal(this->a, b->a);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2367,15 +2439,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
-
-        for i, rowB in b->asArray() {
-            let c[] = tensor_not_equal(this->a[i], rowB);
-        }
+        var result = tensor_not_equal(this->a, b->a);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2393,15 +2459,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
-
-        for i, rowB in b->asArray() {
-            let c[] = tensor_greater(this->a[i], rowB);
-        }
+        var result = tensor_greater(this->a, b->a);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2419,15 +2479,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
+        var result = tensor_greater_equal(this->a, b->a);
 
-        for i, rowB in b->asArray() {
-            let c[] = tensor_greater_equal(this->a[i], rowB);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2444,15 +2498,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
-
-        for i, rowB in b->asArray() {
-            let c[] = tensor_less(this->a[i], rowB);
-        }
+        var result = tensor_less(this->a, b->a);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2469,15 +2517,9 @@ class Matrix implements Tensor
                 . " matrix expected but " . b->shapeString() . " given.");
         }
 
-        var i, rowB;
-        
-        array c = [];
-
-        for i, rowB in b->asArray() {
-            let c[] = tensor_less_equal(this->a[i], rowB);
-        }
+        var result = tensor_less_equal(this->a, b->a);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2495,16 +2537,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_multiply(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_multiply(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2523,16 +2565,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_divide(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_divide(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2551,16 +2593,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
     
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_add(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_add(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2579,16 +2621,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
     
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_subtract(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_subtract(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2607,16 +2649,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
     
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_pow(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_pow(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2635,16 +2677,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
     
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_mod(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_mod(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2664,16 +2706,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_equal(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_equal(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2692,16 +2734,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_not_equal(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_not_equal(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2720,16 +2762,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_greater(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_greater(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2748,16 +2790,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_greater_equal(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_greater_equal(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2776,16 +2818,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_less(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_less(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2805,16 +2847,16 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowA;
+        var i;
 
         array c = [];
 
-        var bHat = b->asArray();
-    
-        for rowA in this->a {
-            let c[] = tensor_less_equal(rowA, bHat);
+        var bHat = b->asTensorBuffer();
+
+        for i in range(0, this->m - 1) {
+            let c[] = tensor_less_equal(this->a->slice(i * this->n, this->n), bHat);
         }
-    
+
         return self::quick(c);
     }
 
@@ -2838,7 +2880,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_multiply_scalar(this->a[i], valueB);
+            let c[] = tensor_multiply_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -2864,7 +2906,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_divide_scalar(this->a[i], valueB);
+            let c[] = tensor_divide_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -2890,7 +2932,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_add_scalar(this->a[i], valueB);
+            let c[] = tensor_add_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -2916,7 +2958,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_subtract_scalar(this->a[i], valueB);
+            let c[] = tensor_subtract_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -2942,7 +2984,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_pow_scalar(this->a[i], valueB);
+            let c[] = tensor_pow_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -2968,7 +3010,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_mod_scalar(this->a[i], valueB);
+            let c[] = tensor_mod_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -2994,7 +3036,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_equal_scalar(this->a[i], valueB);
+            let c[] = tensor_equal_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -3020,7 +3062,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_not_equal_scalar(this->a[i], valueB);
+            let c[] = tensor_not_equal_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -3046,7 +3088,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_greater_scalar(this->a[i], valueB);
+            let c[] = tensor_greater_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -3072,7 +3114,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_greater_equal_scalar(this->a[i], valueB);
+            let c[] = tensor_greater_equal_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -3098,7 +3140,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_less_scalar(this->a[i], valueB);
+            let c[] = tensor_less_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -3124,7 +3166,7 @@ class Matrix implements Tensor
         array c = [];
 
         for i, valueB in b->asArray() {
-            let c[] = tensor_less_equal_scalar(this->a[i], valueB);
+            let c[] = tensor_less_equal_scalar(this->a->slice(i * this->n, this->n), valueB);
         }
 
         return self::quick(c);
@@ -3138,15 +3180,9 @@ class Matrix implements Tensor
      */
     public function multiplyScalar(const float b) -> <Matrix>
     {
-        var rowA;
-
-        array c = [];
+        var result = tensor_multiply_scalar(this->a, b);
 
-        for rowA in this->a {
-            let c[] = tensor_multiply_scalar(rowA, b);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3157,15 +3193,9 @@ class Matrix implements Tensor
      */
     public function divideScalar(const float b) -> <Matrix>
     {
-        var rowA;
-
-        array c = [];
-
-        for rowA in this->a {
-            let c[] = tensor_divide_scalar(rowA, b);
-        }
+        var result = tensor_divide_scalar(this->a, b);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3176,15 +3206,9 @@ class Matrix implements Tensor
      */
     public function addScalar(const float b) -> <Matrix>
     {
-        var rowA;
-
-        array c = [];
-
-        for rowA in this->a {
-            let c[] = tensor_add_scalar(rowA, b);
-        }
+        var result = tensor_add_scalar(this->a, b);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3195,15 +3219,9 @@ class Matrix implements Tensor
      */
     public function subtractScalar(const float b) -> <Matrix>
     {
-        var rowA;
-
-        array c = [];
-
-        for rowA in this->a {
-            let c[] = tensor_subtract_scalar(rowA, b);
-        }
+        var result = tensor_subtract_scalar(this->a, b);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3214,15 +3232,9 @@ class Matrix implements Tensor
      */
     public function powScalar(const float b) -> <Matrix>
     {
-        var rowA;
-
-        array c = [];
-
-        for rowA in this->a {
-            let c[] = tensor_pow_scalar(rowA, b);
-        }
+        var result = tensor_pow_scalar(this->a, b);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3233,15 +3245,9 @@ class Matrix implements Tensor
      */
     public function modScalar(const float b) -> <Matrix>
     {
-        var rowA;
+        var result = tensor_mod_scalar(this->a, b);
 
-        array c = [];
-
-        for rowA in this->a {
-            let c[] = tensor_mod_scalar(rowA, b);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3252,15 +3258,9 @@ class Matrix implements Tensor
      */
     public function equalScalar(const float b) -> <Matrix>
     {
-        var rowA;
-
-        array c = [];
-
-        for rowA in this->a {
-            let c[] = tensor_equal_scalar(rowA, b);
-        }
+        var result = tensor_equal_scalar(this->a, b);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3271,15 +3271,9 @@ class Matrix implements Tensor
      */
     public function notEqualScalar(const float b) -> <Matrix>
     {
-        var rowA;
+        var result = tensor_not_equal_scalar(this->a, b);
 
-        array c = [];
-
-        for rowA in this->a {
-            let c[] = tensor_not_equal_scalar(rowA, b);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3290,15 +3284,9 @@ class Matrix implements Tensor
      */
     public function greaterScalar(const float b) -> <Matrix>
     {
-        var rowA;
+        var result = tensor_greater_scalar(this->a, b);
 
-        array c = [];
-
-        for rowA in this->a {
-            let c[] = tensor_greater_scalar(rowA, b);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3310,15 +3298,9 @@ class Matrix implements Tensor
      */
     public function greaterEqualScalar(const float b) -> <Matrix>
     {
-        var rowA;
-
-        array c = [];
+        var result = tensor_greater_equal_scalar(this->a, b);
 
-        for rowA in this->a {
-            let c[] = tensor_greater_equal_scalar(rowA, b);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3329,15 +3311,9 @@ class Matrix implements Tensor
      */
     public function lessScalar(const float b) -> <Matrix>
     {
-        var rowA;
-
-        array c = [];
+        var result = tensor_less_scalar(this->a, b);
 
-        for rowA in this->a {
-            let c[] = tensor_less_scalar(rowA, b);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3349,15 +3325,9 @@ class Matrix implements Tensor
      */
     public function lessEqualScalar(const float b) -> <Matrix>
     {
-        var rowA;
-
-        array c = [];
-
-        for rowA in this->a {
-            let c[] = tensor_less_equal_scalar(rowA, b);
-        }
+        var result = tensor_less_equal_scalar(this->a, b);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3386,7 +3356,11 @@ class Matrix implements Tensor
      */
     public function offsetExists(const var index) -> bool
     {
-        return isset this->a[index];
+        if typeof index != "int" {
+            return false;
+        }
+
+        return index >= 0 && index < this->m;
     }
 
     /**
@@ -3407,14 +3381,17 @@ class Matrix implements Tensor
      */
     public function offsetGet(const var index) -> <Vector>
     {
-        var row;
+        if unlikely typeof index != "int" {
+            throw new InvalidArgumentException("Row offset must be"
+                . " an integer, " . gettype(index) . " given.");
+        }
 
-        if likely fetch row, this->a[index] {
-            return Vector::quick(row);
+        if unlikely index < 0 || index >= this->m {
+            throw new InvalidArgumentException("Row offset out of"
+                . " bounds, " . (string) index . " given.");
         }
 
-        throw new InvalidArgumentException("Element not found at"
-            . " offset " . (string) index . ".");
+        return Vector::fromTensorBuffer(this->a->slice(index * this->n, this->n));
     }
 
     /**
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 8b6c342..b31923e 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -375,6 +375,16 @@ class Vector implements Tensor
         return this->a->toArray();
     }
 
+    /**
+     * Return the underlying TensorBuffer of the vector.
+     *
+     * @return \Tensor\TensorBuffer
+     */
+    public function asTensorBuffer() -> <TensorBuffer>
+    {
+        return this->a;
+    }
+
     /**
      * Return this vector as a row matrix.
      *

From 9933179a9fc6224b1f121480b5c4fbe70725986f Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 22:15:48 -0500
Subject: [PATCH 13/51] Fix tests

---
 ext/tensor/matrix.zep.c | 892 ++++++++++++++++++++--------------------
 ext/tensor/matrix.zep.h |   2 +-
 tensor/matrix.zep       |  39 +-
 tests/MatrixTest.php    |   4 +-
 4 files changed, 465 insertions(+), 472 deletions(-)

diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 889b64d..167d524 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -982,15 +982,15 @@ PHP_METHOD(Tensor_Matrix, uniform)
  */
 PHP_METHOD(Tensor_Matrix, __construct)
 {
-	zend_string *_8$$9;
-	zend_ulong _7$$9;
-	zval _2$$7, _10$$12, _35$$20, _93$$40;
+	zend_string *_8$$9, *_59$$26;
+	zend_ulong _7$$9, _58$$26;
+	zval _2$$7, _10$$12, _35$$20, _61$$29, _82$$37, _117$$48;
 	zval flat$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_14 = NULL, *_27 = NULL;
-	zend_bool validate, _33$$9, _29$$10, _52$$18, _67$$26, _64$$27, _74$$31;
+	zend_bool validate, _33$$9, _29$$10, _52$$18, _80$$26, _77$$27, _98$$35;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS, rows$$3;
-	zval *a = NULL, a_sub, *m_param = NULL, *n_param = NULL, *validate_param = NULL, i, rowA, valueA, firstRow, nHat$$3, _0$$3, buffer$$3, _76$$3, _77$$3, _1$$7, _3$$9, *_4$$9, _5$$9, *_6$$9, _32$$9, _9$$12, _11$$11, _17$$11, _12$$13, _13$$13, _15$$13, _16$$13, _18$$15, _19$$15, _20$$15, _21$$15, *_22$$10, _23$$10, *_24$$10, _28$$10, _25$$16, _26$$16, _30$$17, _31$$17, _34$$20, _36$$19, _41$$19, _37$$21, _38$$21, _39$$21, _40$$21, _42$$23, _43$$23, _44$$23, _45$$23, *_46$$18, _47$$18, *_48$$18, _51$$18, _49$$24, _50$$24, _53$$25, _54$$25, *_55$$26, _56$$26, *_57$$26, _66$$26, _58$$28, *_59$$27, _60$$27, *_61$$27, _63$$27, _62$$29, _65$$30, _68$$32, *_69$$31, _70$$31, *_71$$31, _73$$31, _72$$33, _75$$34, _78$$37, _79$$37, _80$$37, _81$$37, _82$$38, _83$$38, _84$$38, _85$$38, _86$$36, _87$$39, _88$$39, _89$$39, _90$$39, _91$$35, _92$$40;
+	zval *a = NULL, a_sub, *m_param = NULL, *n_param = NULL, *validate_param = NULL, i, rowA, valueA, firstRow, nHat$$3, _0$$3, buffer$$3, _100$$3, _101$$3, _1$$7, _3$$9, *_4$$9, _5$$9, *_6$$9, _32$$9, _9$$12, _11$$11, _17$$11, _12$$13, _13$$13, _15$$13, _16$$13, _18$$15, _19$$15, _20$$15, _21$$15, *_22$$10, _23$$10, *_24$$10, _28$$10, _25$$16, _26$$16, _30$$17, _31$$17, _34$$20, _36$$19, _41$$19, _37$$21, _38$$21, _39$$21, _40$$21, _42$$23, _43$$23, _44$$23, _45$$23, *_46$$18, _47$$18, *_48$$18, _51$$18, _49$$24, _50$$24, _53$$25, _54$$25, *_55$$26, _56$$26, *_57$$26, _79$$26, _60$$29, _62$$28, _67$$28, _63$$30, _64$$30, _65$$30, _66$$30, _68$$32, _69$$32, _70$$32, _71$$32, *_72$$27, _73$$27, *_74$$27, _76$$27, _75$$33, _78$$34, _81$$37, _83$$36, _88$$36, _84$$38, _85$$38, _86$$38, _87$$38, _89$$40, _90$$40, _91$$40, _92$$40, *_93$$35, _94$$35, *_95$$35, _97$$35, _96$$41, _99$$42, _102$$45, _103$$45, _104$$45, _105$$45, _106$$46, _107$$46, _108$$46, _109$$46, _110$$44, _111$$47, _112$$47, _113$$47, _114$$47, _115$$43, _116$$48;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&a_sub);
@@ -1001,8 +1001,8 @@ PHP_METHOD(Tensor_Matrix, __construct)
 	ZVAL_UNDEF(&nHat$$3);
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&buffer$$3);
-	ZVAL_UNDEF(&_76$$3);
-	ZVAL_UNDEF(&_77$$3);
+	ZVAL_UNDEF(&_100$$3);
+	ZVAL_UNDEF(&_101$$3);
 	ZVAL_UNDEF(&_1$$7);
 	ZVAL_UNDEF(&_3$$9);
 	ZVAL_UNDEF(&_5$$9);
@@ -1042,37 +1042,59 @@ PHP_METHOD(Tensor_Matrix, __construct)
 	ZVAL_UNDEF(&_53$$25);
 	ZVAL_UNDEF(&_54$$25);
 	ZVAL_UNDEF(&_56$$26);
-	ZVAL_UNDEF(&_66$$26);
-	ZVAL_UNDEF(&_58$$28);
-	ZVAL_UNDEF(&_60$$27);
-	ZVAL_UNDEF(&_63$$27);
-	ZVAL_UNDEF(&_62$$29);
+	ZVAL_UNDEF(&_79$$26);
+	ZVAL_UNDEF(&_60$$29);
+	ZVAL_UNDEF(&_62$$28);
+	ZVAL_UNDEF(&_67$$28);
+	ZVAL_UNDEF(&_63$$30);
+	ZVAL_UNDEF(&_64$$30);
 	ZVAL_UNDEF(&_65$$30);
+	ZVAL_UNDEF(&_66$$30);
 	ZVAL_UNDEF(&_68$$32);
-	ZVAL_UNDEF(&_70$$31);
-	ZVAL_UNDEF(&_73$$31);
-	ZVAL_UNDEF(&_72$$33);
-	ZVAL_UNDEF(&_75$$34);
-	ZVAL_UNDEF(&_78$$37);
-	ZVAL_UNDEF(&_79$$37);
-	ZVAL_UNDEF(&_80$$37);
+	ZVAL_UNDEF(&_69$$32);
+	ZVAL_UNDEF(&_70$$32);
+	ZVAL_UNDEF(&_71$$32);
+	ZVAL_UNDEF(&_73$$27);
+	ZVAL_UNDEF(&_76$$27);
+	ZVAL_UNDEF(&_75$$33);
+	ZVAL_UNDEF(&_78$$34);
 	ZVAL_UNDEF(&_81$$37);
-	ZVAL_UNDEF(&_82$$38);
-	ZVAL_UNDEF(&_83$$38);
+	ZVAL_UNDEF(&_83$$36);
+	ZVAL_UNDEF(&_88$$36);
 	ZVAL_UNDEF(&_84$$38);
 	ZVAL_UNDEF(&_85$$38);
-	ZVAL_UNDEF(&_86$$36);
-	ZVAL_UNDEF(&_87$$39);
-	ZVAL_UNDEF(&_88$$39);
-	ZVAL_UNDEF(&_89$$39);
-	ZVAL_UNDEF(&_90$$39);
-	ZVAL_UNDEF(&_91$$35);
+	ZVAL_UNDEF(&_86$$38);
+	ZVAL_UNDEF(&_87$$38);
+	ZVAL_UNDEF(&_89$$40);
+	ZVAL_UNDEF(&_90$$40);
+	ZVAL_UNDEF(&_91$$40);
 	ZVAL_UNDEF(&_92$$40);
+	ZVAL_UNDEF(&_94$$35);
+	ZVAL_UNDEF(&_97$$35);
+	ZVAL_UNDEF(&_96$$41);
+	ZVAL_UNDEF(&_99$$42);
+	ZVAL_UNDEF(&_102$$45);
+	ZVAL_UNDEF(&_103$$45);
+	ZVAL_UNDEF(&_104$$45);
+	ZVAL_UNDEF(&_105$$45);
+	ZVAL_UNDEF(&_106$$46);
+	ZVAL_UNDEF(&_107$$46);
+	ZVAL_UNDEF(&_108$$46);
+	ZVAL_UNDEF(&_109$$46);
+	ZVAL_UNDEF(&_110$$44);
+	ZVAL_UNDEF(&_111$$47);
+	ZVAL_UNDEF(&_112$$47);
+	ZVAL_UNDEF(&_113$$47);
+	ZVAL_UNDEF(&_114$$47);
+	ZVAL_UNDEF(&_115$$43);
+	ZVAL_UNDEF(&_116$$48);
 	ZVAL_UNDEF(&flat$$3);
 	ZVAL_UNDEF(&_2$$7);
 	ZVAL_UNDEF(&_10$$12);
 	ZVAL_UNDEF(&_35$$20);
-	ZVAL_UNDEF(&_93$$40);
+	ZVAL_UNDEF(&_61$$29);
+	ZVAL_UNDEF(&_82$$37);
+	ZVAL_UNDEF(&_117$$48);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
@@ -1405,55 +1427,105 @@ PHP_METHOD(Tensor_Matrix, __construct)
 			} else {
 				_55$$26 = a;
 			}
-			zephir_is_iterable(_55$$26, 0, "tensor/matrix.zep", 457);
+			zephir_is_iterable(_55$$26, 0, "tensor/matrix.zep", 476);
 			if (Z_TYPE_P(_55$$26) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_55$$26), _57$$26)
+				ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_55$$26), _58$$26, _59$$26, _57$$26)
 				{
+					ZEPHIR_INIT_NVAR(&i);
+					if (_59$$26 != NULL) { 
+						ZVAL_STR_COPY(&i, _59$$26);
+					} else {
+						ZVAL_LONG(&i, _58$$26);
+					}
 					ZEPHIR_INIT_NVAR(&rowA);
 					ZVAL_COPY(&rowA, _57$$26);
 					if (Z_TYPE_P(&rowA) == IS_OBJECT) {
-						ZEPHIR_CALL_METHOD(&_58$$28, &rowA, "toArray", NULL, 0);
+						if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
+							ZEPHIR_INIT_NVAR(&_60$$29);
+							object_init_ex(&_60$$29, tensor_exceptions_invalidargumentexception_ce);
+							ZEPHIR_INIT_NVAR(&_61$$29);
+							ZEPHIR_CONCAT_SS(&_61$$29, "Matrix requires an", " array of arrays.");
+							ZEPHIR_CALL_METHOD(NULL, &_60$$29, "__construct", NULL, 3, &_61$$29);
+							zephir_check_call_status();
+							zephir_throw_exception_debug(&_60$$29, "tensor/matrix.zep", 452);
+							ZEPHIR_MM_RESTORE();
+							return;
+						}
+						ZEPHIR_CALL_METHOD(&_62$$28, &rowA, "count", NULL, 0);
 						zephir_check_call_status();
-						ZEPHIR_CPY_WRT(&rowA, &_58$$28);
+						if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_62$$28, &nHat$$3))) {
+							ZEPHIR_INIT_NVAR(&_63$$30);
+							object_init_ex(&_63$$30, tensor_exceptions_invalidargumentexception_ce);
+							ZEPHIR_CALL_FUNCTION(&_64$$30, "strval", &_14, 4, &nHat$$3);
+							zephir_check_call_status();
+							ZEPHIR_CALL_METHOD(&_65$$30, &rowA, "count", NULL, 0);
+							zephir_check_call_status();
+							ZEPHIR_INIT_NVAR(&_66$$30);
+							ZEPHIR_CONCAT_SSVSVSVS(&_66$$30, "The number of", " columns must be equal for all rows, ", &_64$$30, " needed but ", &_65$$30, " given at row offset ", &i, ".");
+							ZEPHIR_CALL_METHOD(NULL, &_63$$30, "__construct", NULL, 3, &_66$$30);
+							zephir_check_call_status();
+							zephir_throw_exception_debug(&_63$$30, "tensor/matrix.zep", 459);
+							ZEPHIR_MM_RESTORE();
+							return;
+						}
+						ZEPHIR_CALL_METHOD(&_67$$28, &rowA, "toArray", NULL, 0);
+						zephir_check_call_status();
+						ZEPHIR_CPY_WRT(&rowA, &_67$$28);
+					} else {
+						if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&nHat$$3, zephir_fast_count_int(&rowA)))) {
+							ZEPHIR_INIT_NVAR(&_68$$32);
+							object_init_ex(&_68$$32, tensor_exceptions_invalidargumentexception_ce);
+							ZEPHIR_CALL_FUNCTION(&_69$$32, "strval", &_14, 4, &nHat$$3);
+							zephir_check_call_status();
+							ZEPHIR_INIT_NVAR(&_70$$32);
+							ZVAL_LONG(&_70$$32, zephir_fast_count_int(&rowA));
+							ZEPHIR_INIT_NVAR(&_71$$32);
+							ZEPHIR_CONCAT_SSVSVSVS(&_71$$32, "The number of", " columns must be equal for all rows, ", &_69$$32, " needed but ", &_70$$32, " given at row offset ", &i, ".");
+							ZEPHIR_CALL_METHOD(NULL, &_68$$32, "__construct", NULL, 3, &_71$$32);
+							zephir_check_call_status();
+							zephir_throw_exception_debug(&_68$$32, "tensor/matrix.zep", 468);
+							ZEPHIR_MM_RESTORE();
+							return;
+						}
 					}
 					if (Z_TYPE_P(&rowA) == IS_STRING) {
-						ZEPHIR_INIT_NVAR(&_60$$27);
-						zephir_string_to_char_array(&_60$$27, &rowA);
-						_59$$27 = &_60$$27;
+						ZEPHIR_INIT_NVAR(&_73$$27);
+						zephir_string_to_char_array(&_73$$27, &rowA);
+						_72$$27 = &_73$$27;
 					} else {
-						_59$$27 = &rowA;
+						_72$$27 = &rowA;
 					}
-					zephir_is_iterable(_59$$27, 0, "tensor/matrix.zep", 456);
-					if (Z_TYPE_P(_59$$27) == IS_ARRAY) {
-						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_59$$27), _61$$27)
+					zephir_is_iterable(_72$$27, 0, "tensor/matrix.zep", 475);
+					if (Z_TYPE_P(_72$$27) == IS_ARRAY) {
+						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_72$$27), _74$$27)
 						{
 							ZEPHIR_INIT_NVAR(&valueA);
-							ZVAL_COPY(&valueA, _61$$27);
-							ZEPHIR_INIT_NVAR(&_62$$29);
-							ZVAL_DOUBLE(&_62$$29, zephir_get_doubleval(&valueA));
-							zephir_array_append(&flat$$3, &_62$$29, PH_SEPARATE, "tensor/matrix.zep", 454);
+							ZVAL_COPY(&valueA, _74$$27);
+							ZEPHIR_INIT_NVAR(&_75$$33);
+							ZVAL_DOUBLE(&_75$$33, zephir_get_doubleval(&valueA));
+							zephir_array_append(&flat$$3, &_75$$33, PH_SEPARATE, "tensor/matrix.zep", 473);
 						} ZEND_HASH_FOREACH_END();
 					} else {
-						ZEPHIR_CALL_METHOD(NULL, _59$$27, "rewind", NULL, 0);
+						ZEPHIR_CALL_METHOD(NULL, _72$$27, "rewind", NULL, 0);
 						zephir_check_call_status();
-						_64$$27 = 1;
+						_77$$27 = 1;
 						while (1) {
-							if (_64$$27) {
-								_64$$27 = 0;
+							if (_77$$27) {
+								_77$$27 = 0;
 							} else {
-								ZEPHIR_CALL_METHOD(NULL, _59$$27, "next", NULL, 0);
+								ZEPHIR_CALL_METHOD(NULL, _72$$27, "next", NULL, 0);
 								zephir_check_call_status();
 							}
-							ZEPHIR_CALL_METHOD(&_63$$27, _59$$27, "valid", NULL, 0);
+							ZEPHIR_CALL_METHOD(&_76$$27, _72$$27, "valid", NULL, 0);
 							zephir_check_call_status();
-							if (!zend_is_true(&_63$$27)) {
+							if (!zend_is_true(&_76$$27)) {
 								break;
 							}
-							ZEPHIR_CALL_METHOD(&valueA, _59$$27, "current", NULL, 0);
+							ZEPHIR_CALL_METHOD(&valueA, _72$$27, "current", NULL, 0);
 							zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_65$$30);
-								ZVAL_DOUBLE(&_65$$30, zephir_get_doubleval(&valueA));
-								zephir_array_append(&flat$$3, &_65$$30, PH_SEPARATE, "tensor/matrix.zep", 454);
+								ZEPHIR_INIT_NVAR(&_78$$34);
+								ZVAL_DOUBLE(&_78$$34, zephir_get_doubleval(&valueA));
+								zephir_array_append(&flat$$3, &_78$$34, PH_SEPARATE, "tensor/matrix.zep", 473);
 						}
 					}
 					ZEPHIR_INIT_NVAR(&valueA);
@@ -1461,145 +1533,192 @@ PHP_METHOD(Tensor_Matrix, __construct)
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _55$$26, "rewind", NULL, 0);
 				zephir_check_call_status();
-				_67$$26 = 1;
+				_80$$26 = 1;
 				while (1) {
-					if (_67$$26) {
-						_67$$26 = 0;
+					if (_80$$26) {
+						_80$$26 = 0;
 					} else {
 						ZEPHIR_CALL_METHOD(NULL, _55$$26, "next", NULL, 0);
 						zephir_check_call_status();
 					}
-					ZEPHIR_CALL_METHOD(&_66$$26, _55$$26, "valid", NULL, 0);
+					ZEPHIR_CALL_METHOD(&_79$$26, _55$$26, "valid", NULL, 0);
 					zephir_check_call_status();
-					if (!zend_is_true(&_66$$26)) {
+					if (!zend_is_true(&_79$$26)) {
 						break;
 					}
+					ZEPHIR_CALL_METHOD(&i, _55$$26, "key", NULL, 0);
+					zephir_check_call_status();
 					ZEPHIR_CALL_METHOD(&rowA, _55$$26, "current", NULL, 0);
 					zephir_check_call_status();
 						if (Z_TYPE_P(&rowA) == IS_OBJECT) {
-							ZEPHIR_CALL_METHOD(&_68$$32, &rowA, "toArray", NULL, 0);
+							if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
+								ZEPHIR_INIT_NVAR(&_81$$37);
+								object_init_ex(&_81$$37, tensor_exceptions_invalidargumentexception_ce);
+								ZEPHIR_INIT_NVAR(&_82$$37);
+								ZEPHIR_CONCAT_SS(&_82$$37, "Matrix requires an", " array of arrays.");
+								ZEPHIR_CALL_METHOD(NULL, &_81$$37, "__construct", NULL, 3, &_82$$37);
+								zephir_check_call_status();
+								zephir_throw_exception_debug(&_81$$37, "tensor/matrix.zep", 452);
+								ZEPHIR_MM_RESTORE();
+								return;
+							}
+							ZEPHIR_CALL_METHOD(&_83$$36, &rowA, "count", NULL, 0);
+							zephir_check_call_status();
+							if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_83$$36, &nHat$$3))) {
+								ZEPHIR_INIT_NVAR(&_84$$38);
+								object_init_ex(&_84$$38, tensor_exceptions_invalidargumentexception_ce);
+								ZEPHIR_CALL_FUNCTION(&_85$$38, "strval", &_14, 4, &nHat$$3);
+								zephir_check_call_status();
+								ZEPHIR_CALL_METHOD(&_86$$38, &rowA, "count", NULL, 0);
+								zephir_check_call_status();
+								ZEPHIR_INIT_NVAR(&_87$$38);
+								ZEPHIR_CONCAT_SSVSVSVS(&_87$$38, "The number of", " columns must be equal for all rows, ", &_85$$38, " needed but ", &_86$$38, " given at row offset ", &i, ".");
+								ZEPHIR_CALL_METHOD(NULL, &_84$$38, "__construct", NULL, 3, &_87$$38);
+								zephir_check_call_status();
+								zephir_throw_exception_debug(&_84$$38, "tensor/matrix.zep", 459);
+								ZEPHIR_MM_RESTORE();
+								return;
+							}
+							ZEPHIR_CALL_METHOD(&_88$$36, &rowA, "toArray", NULL, 0);
 							zephir_check_call_status();
-							ZEPHIR_CPY_WRT(&rowA, &_68$$32);
+							ZEPHIR_CPY_WRT(&rowA, &_88$$36);
+						} else {
+							if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&nHat$$3, zephir_fast_count_int(&rowA)))) {
+								ZEPHIR_INIT_NVAR(&_89$$40);
+								object_init_ex(&_89$$40, tensor_exceptions_invalidargumentexception_ce);
+								ZEPHIR_CALL_FUNCTION(&_90$$40, "strval", &_14, 4, &nHat$$3);
+								zephir_check_call_status();
+								ZEPHIR_INIT_NVAR(&_91$$40);
+								ZVAL_LONG(&_91$$40, zephir_fast_count_int(&rowA));
+								ZEPHIR_INIT_NVAR(&_92$$40);
+								ZEPHIR_CONCAT_SSVSVSVS(&_92$$40, "The number of", " columns must be equal for all rows, ", &_90$$40, " needed but ", &_91$$40, " given at row offset ", &i, ".");
+								ZEPHIR_CALL_METHOD(NULL, &_89$$40, "__construct", NULL, 3, &_92$$40);
+								zephir_check_call_status();
+								zephir_throw_exception_debug(&_89$$40, "tensor/matrix.zep", 468);
+								ZEPHIR_MM_RESTORE();
+								return;
+							}
 						}
 						if (Z_TYPE_P(&rowA) == IS_STRING) {
-							ZEPHIR_INIT_NVAR(&_70$$31);
-							zephir_string_to_char_array(&_70$$31, &rowA);
-							_69$$31 = &_70$$31;
+							ZEPHIR_INIT_NVAR(&_94$$35);
+							zephir_string_to_char_array(&_94$$35, &rowA);
+							_93$$35 = &_94$$35;
 						} else {
-							_69$$31 = &rowA;
+							_93$$35 = &rowA;
 						}
-						zephir_is_iterable(_69$$31, 0, "tensor/matrix.zep", 456);
-						if (Z_TYPE_P(_69$$31) == IS_ARRAY) {
-							ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_69$$31), _71$$31)
+						zephir_is_iterable(_93$$35, 0, "tensor/matrix.zep", 475);
+						if (Z_TYPE_P(_93$$35) == IS_ARRAY) {
+							ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_93$$35), _95$$35)
 							{
 								ZEPHIR_INIT_NVAR(&valueA);
-								ZVAL_COPY(&valueA, _71$$31);
-								ZEPHIR_INIT_NVAR(&_72$$33);
-								ZVAL_DOUBLE(&_72$$33, zephir_get_doubleval(&valueA));
-								zephir_array_append(&flat$$3, &_72$$33, PH_SEPARATE, "tensor/matrix.zep", 454);
+								ZVAL_COPY(&valueA, _95$$35);
+								ZEPHIR_INIT_NVAR(&_96$$41);
+								ZVAL_DOUBLE(&_96$$41, zephir_get_doubleval(&valueA));
+								zephir_array_append(&flat$$3, &_96$$41, PH_SEPARATE, "tensor/matrix.zep", 473);
 							} ZEND_HASH_FOREACH_END();
 						} else {
-							ZEPHIR_CALL_METHOD(NULL, _69$$31, "rewind", NULL, 0);
+							ZEPHIR_CALL_METHOD(NULL, _93$$35, "rewind", NULL, 0);
 							zephir_check_call_status();
-							_74$$31 = 1;
+							_98$$35 = 1;
 							while (1) {
-								if (_74$$31) {
-									_74$$31 = 0;
+								if (_98$$35) {
+									_98$$35 = 0;
 								} else {
-									ZEPHIR_CALL_METHOD(NULL, _69$$31, "next", NULL, 0);
+									ZEPHIR_CALL_METHOD(NULL, _93$$35, "next", NULL, 0);
 									zephir_check_call_status();
 								}
-								ZEPHIR_CALL_METHOD(&_73$$31, _69$$31, "valid", NULL, 0);
+								ZEPHIR_CALL_METHOD(&_97$$35, _93$$35, "valid", NULL, 0);
 								zephir_check_call_status();
-								if (!zend_is_true(&_73$$31)) {
+								if (!zend_is_true(&_97$$35)) {
 									break;
 								}
-								ZEPHIR_CALL_METHOD(&valueA, _69$$31, "current", NULL, 0);
+								ZEPHIR_CALL_METHOD(&valueA, _93$$35, "current", NULL, 0);
 								zephir_check_call_status();
-									ZEPHIR_INIT_NVAR(&_75$$34);
-									ZVAL_DOUBLE(&_75$$34, zephir_get_doubleval(&valueA));
-									zephir_array_append(&flat$$3, &_75$$34, PH_SEPARATE, "tensor/matrix.zep", 454);
+									ZEPHIR_INIT_NVAR(&_99$$42);
+									ZVAL_DOUBLE(&_99$$42, zephir_get_doubleval(&valueA));
+									zephir_array_append(&flat$$3, &_99$$42, PH_SEPARATE, "tensor/matrix.zep", 473);
 							}
 						}
 						ZEPHIR_INIT_NVAR(&valueA);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&rowA);
+			ZEPHIR_INIT_NVAR(&i);
 		}
 		ZEPHIR_INIT_VAR(&buffer$$3);
 		tensor_buffer_from_array(&buffer$$3, &flat$$3);
-		ZEPHIR_INIT_VAR(&_76$$3);
-		object_init_ex(&_76$$3, tensor_tensorbuffer_ce);
-		ZEPHIR_CALL_METHOD(NULL, &_76$$3, "__construct", NULL, 14, &buffer$$3);
-		zephir_check_call_status();
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_76$$3);
-		ZVAL_UNDEF(&_77$$3);
-		ZVAL_LONG(&_77$$3, rows$$3);
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_77$$3);
+		ZEPHIR_INIT_VAR(&_100$$3);
+		object_init_ex(&_100$$3, tensor_tensorbuffer_ce);
+		ZEPHIR_CALL_METHOD(NULL, &_100$$3, "__construct", NULL, 14, &buffer$$3);
+		zephir_check_call_status();
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_100$$3);
+		ZVAL_UNDEF(&_101$$3);
+		ZVAL_LONG(&_101$$3, rows$$3);
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_101$$3);
 		zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &nHat$$3);
 	} else if (zephir_instance_of_ev(a, tensor_tensorbuffer_ce)) {
 		if (UNEXPECTED(validate)) {
 			if (UNEXPECTED(m < 1)) {
-				ZEPHIR_INIT_VAR(&_78$$37);
-				object_init_ex(&_78$$37, tensor_exceptions_invalidargumentexception_ce);
-				ZVAL_LONG(&_79$$37, m);
-				ZEPHIR_CALL_FUNCTION(&_80$$37, "strval", &_14, 4, &_79$$37);
+				ZEPHIR_INIT_VAR(&_102$$45);
+				object_init_ex(&_102$$45, tensor_exceptions_invalidargumentexception_ce);
+				ZVAL_LONG(&_103$$45, m);
+				ZEPHIR_CALL_FUNCTION(&_104$$45, "strval", &_14, 4, &_103$$45);
 				zephir_check_call_status();
-				ZEPHIR_INIT_VAR(&_81$$37);
-				ZEPHIR_CONCAT_SSVS(&_81$$37, "The number of rows must be", " greater than 0, ", &_80$$37, " given.");
-				ZEPHIR_CALL_METHOD(NULL, &_78$$37, "__construct", NULL, 3, &_81$$37);
+				ZEPHIR_INIT_VAR(&_105$$45);
+				ZEPHIR_CONCAT_SSVS(&_105$$45, "The number of rows must be", " greater than 0, ", &_104$$45, " given.");
+				ZEPHIR_CALL_METHOD(NULL, &_102$$45, "__construct", NULL, 3, &_105$$45);
 				zephir_check_call_status();
-				zephir_throw_exception_debug(&_78$$37, "tensor/matrix.zep", 468);
+				zephir_throw_exception_debug(&_102$$45, "tensor/matrix.zep", 487);
 				ZEPHIR_MM_RESTORE();
 				return;
 			}
 			if (UNEXPECTED(n < 1)) {
-				ZEPHIR_INIT_VAR(&_82$$38);
-				object_init_ex(&_82$$38, tensor_exceptions_invalidargumentexception_ce);
-				ZVAL_LONG(&_83$$38, n);
-				ZEPHIR_CALL_FUNCTION(&_84$$38, "strval", &_14, 4, &_83$$38);
+				ZEPHIR_INIT_VAR(&_106$$46);
+				object_init_ex(&_106$$46, tensor_exceptions_invalidargumentexception_ce);
+				ZVAL_LONG(&_107$$46, n);
+				ZEPHIR_CALL_FUNCTION(&_108$$46, "strval", &_14, 4, &_107$$46);
 				zephir_check_call_status();
-				ZEPHIR_INIT_VAR(&_85$$38);
-				ZEPHIR_CONCAT_SSVS(&_85$$38, "The number of columns must be", " greater than 0, ", &_84$$38, " given.");
-				ZEPHIR_CALL_METHOD(NULL, &_82$$38, "__construct", NULL, 3, &_85$$38);
+				ZEPHIR_INIT_VAR(&_109$$46);
+				ZEPHIR_CONCAT_SSVS(&_109$$46, "The number of columns must be", " greater than 0, ", &_108$$46, " given.");
+				ZEPHIR_CALL_METHOD(NULL, &_106$$46, "__construct", NULL, 3, &_109$$46);
 				zephir_check_call_status();
-				zephir_throw_exception_debug(&_82$$38, "tensor/matrix.zep", 473);
+				zephir_throw_exception_debug(&_106$$46, "tensor/matrix.zep", 492);
 				ZEPHIR_MM_RESTORE();
 				return;
 			}
-			ZEPHIR_CALL_METHOD(&_86$$36, a, "count", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_110$$44, a, "count", NULL, 0);
 			zephir_check_call_status();
-			if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&_86$$36, (m * n)))) {
-				ZEPHIR_INIT_VAR(&_87$$39);
-				object_init_ex(&_87$$39, tensor_exceptions_invalidargumentexception_ce);
-				ZEPHIR_CALL_METHOD(&_88$$39, a, "count", NULL, 0);
+			if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&_110$$44, (m * n)))) {
+				ZEPHIR_INIT_VAR(&_111$$47);
+				object_init_ex(&_111$$47, tensor_exceptions_invalidargumentexception_ce);
+				ZEPHIR_CALL_METHOD(&_112$$47, a, "count", NULL, 0);
 				zephir_check_call_status();
-				ZEPHIR_CALL_FUNCTION(&_89$$39, "strval", &_14, 4, &_88$$39);
+				ZEPHIR_CALL_FUNCTION(&_113$$47, "strval", &_14, 4, &_112$$47);
 				zephir_check_call_status();
-				ZEPHIR_INIT_VAR(&_90$$39);
-				ZEPHIR_CONCAT_SSVS(&_90$$39, "The number of elements", " in the buffer must equal m times n, ", &_89$$39, " given.");
-				ZEPHIR_CALL_METHOD(NULL, &_87$$39, "__construct", NULL, 3, &_90$$39);
+				ZEPHIR_INIT_VAR(&_114$$47);
+				ZEPHIR_CONCAT_SSVS(&_114$$47, "The number of elements", " in the buffer must equal m times n, ", &_113$$47, " given.");
+				ZEPHIR_CALL_METHOD(NULL, &_111$$47, "__construct", NULL, 3, &_114$$47);
 				zephir_check_call_status();
-				zephir_throw_exception_debug(&_87$$39, "tensor/matrix.zep", 479);
+				zephir_throw_exception_debug(&_111$$47, "tensor/matrix.zep", 498);
 				ZEPHIR_MM_RESTORE();
 				return;
 			}
 		}
 		zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, a);
-		ZVAL_UNDEF(&_91$$35);
-		ZVAL_LONG(&_91$$35, m);
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_91$$35);
-		ZVAL_UNDEF(&_91$$35);
-		ZVAL_LONG(&_91$$35, n);
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_91$$35);
+		ZVAL_UNDEF(&_115$$43);
+		ZVAL_LONG(&_115$$43, m);
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_115$$43);
+		ZVAL_UNDEF(&_115$$43);
+		ZVAL_LONG(&_115$$43, n);
+		zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_115$$43);
 	} else {
-		ZEPHIR_INIT_VAR(&_92$$40);
-		object_init_ex(&_92$$40, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_INIT_VAR(&_93$$40);
-		ZEPHIR_CONCAT_SS(&_93$$40, "Matrix requires an array", " or TensorBuffer object.");
-		ZEPHIR_CALL_METHOD(NULL, &_92$$40, "__construct", NULL, 3, &_93$$40);
+		ZEPHIR_INIT_VAR(&_116$$48);
+		object_init_ex(&_116$$48, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_117$$48);
+		ZEPHIR_CONCAT_SS(&_117$$48, "Matrix requires an array", " or TensorBuffer object.");
+		ZEPHIR_CALL_METHOD(NULL, &_116$$48, "__construct", NULL, 3, &_117$$48);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_92$$40, "tensor/matrix.zep", 488);
+		zephir_throw_exception_debug(&_116$$48, "tensor/matrix.zep", 507);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1804,7 +1923,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Row offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 563);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 582);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1874,7 +1993,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Column offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 580);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 599);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1892,7 +2011,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 /**
  * Return the diagonal elements of a square matrix as a vector.
  *
- * @return \Tensor\ColumnVector
+ * @return \Tensor\Vector
  * @throws \Tensor\Exceptions\InvalidArgumentException
  */
 PHP_METHOD(Tensor_Matrix, diagonalAsVector)
@@ -1938,7 +2057,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 596);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 615);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1949,7 +2068,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 	ZVAL_LONG(&_9, (zephir_get_numberval(&_7) + 1));
 	ZEPHIR_CALL_METHOD(&_5, &_4, "sliceStrided", NULL, 0, &_8, &_6, &_9);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromTensorBuffer", NULL, 0, &_5);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2033,7 +2152,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 631);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 650);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -2041,7 +2160,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 628);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 647);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -2063,7 +2182,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 628);
+				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 647);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -2162,7 +2281,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 667);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 686);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -2170,7 +2289,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_CE_STATIC(&_7$$4, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 664);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 683);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -2192,7 +2311,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			zephir_check_call_status();
 				ZEPHIR_CALL_CE_STATIC(&_11$$5, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 664);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 683);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -2264,7 +2383,7 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 686);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 705);
 		}
 	}
 	RETURN_CTOR(&b);
@@ -2316,7 +2435,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 711);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 730);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -2324,7 +2443,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			ZVAL_COPY(&columnBuffer, _4);
 			ZEPHIR_CALL_CE_STATIC(&_5$$4, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 708);
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 727);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -2346,7 +2465,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			zephir_check_call_status();
 				ZEPHIR_CALL_CE_STATIC(&_9$$5, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 708);
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 727);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&columnBuffer);
@@ -2457,38 +2576,20 @@ PHP_METHOD(Tensor_Matrix, map)
  */
 PHP_METHOD(Tensor_Matrix, reduce)
 {
-	zend_bool _14, _11$$3, _20$$6;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	double initial;
-	zval *callback, callback_sub, *initial_param = NULL, rowBuffer, valueA, carry, _0, _1, _2, *_3, _4, *_5, _13, *_6$$3, _7$$3, *_8$$3, _10$$3, _9$$4, _12$$5, *_15$$6, _16$$6, *_17$$6, _19$$6, _18$$7, _21$$8;
+	zval *callback, callback_sub, *initial_param = NULL, _0, _1, _2;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&callback_sub);
-	ZVAL_UNDEF(&rowBuffer);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&carry);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_13);
-	ZVAL_UNDEF(&_7$$3);
-	ZVAL_UNDEF(&_10$$3);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&_12$$5);
-	ZVAL_UNDEF(&_16$$6);
-	ZVAL_UNDEF(&_19$$6);
-	ZVAL_UNDEF(&_18$$7);
-	ZVAL_UNDEF(&_21$$8);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		Z_PARAM_ZVAL(callback)
@@ -2503,130 +2604,13 @@ PHP_METHOD(Tensor_Matrix, reduce)
 	} else {
 		initial = zephir_get_doubleval(initial_param);
 	}
-	ZEPHIR_INIT_VAR(&carry);
-	ZVAL_DOUBLE(&carry, initial);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 768);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _5);
-			if (Z_TYPE_P(&rowBuffer) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_7$$3);
-				zephir_string_to_char_array(&_7$$3, &rowBuffer);
-				_6$$3 = &_7$$3;
-			} else {
-				_6$$3 = &rowBuffer;
-			}
-			zephir_is_iterable(_6$$3, 0, "tensor/matrix.zep", 766);
-			if (Z_TYPE_P(_6$$3) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6$$3), _8$$3)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _8$$3);
-					ZEPHIR_CALL_ZVAL_FUNCTION(&_9$$4, callback, NULL, 0, &carry, &valueA);
-					zephir_check_call_status();
-					ZEPHIR_CPY_WRT(&carry, &_9$$4);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _6$$3, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_11$$3 = 1;
-				while (1) {
-					if (_11$$3) {
-						_11$$3 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _6$$3, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_10$$3, _6$$3, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_10$$3)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _6$$3, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_CALL_ZVAL_FUNCTION(&_12$$5, callback, NULL, 0, &carry, &valueA);
-						zephir_check_call_status();
-						ZEPHIR_CPY_WRT(&carry, &_12$$5);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueA);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
-		while (1) {
-			if (_14) {
-				_14 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				if (Z_TYPE_P(&rowBuffer) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_16$$6);
-					zephir_string_to_char_array(&_16$$6, &rowBuffer);
-					_15$$6 = &_16$$6;
-				} else {
-					_15$$6 = &rowBuffer;
-				}
-				zephir_is_iterable(_15$$6, 0, "tensor/matrix.zep", 766);
-				if (Z_TYPE_P(_15$$6) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$6), _17$$6)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _17$$6);
-						ZEPHIR_CALL_ZVAL_FUNCTION(&_18$$7, callback, NULL, 0, &carry, &valueA);
-						zephir_check_call_status();
-						ZEPHIR_CPY_WRT(&carry, &_18$$7);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _15$$6, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_20$$6 = 1;
-					while (1) {
-						if (_20$$6) {
-							_20$$6 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _15$$6, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_19$$6, _15$$6, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_19$$6)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _15$$6, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_CALL_ZVAL_FUNCTION(&_21$$8, callback, NULL, 0, &carry, &valueA);
-							zephir_check_call_status();
-							ZEPHIR_CPY_WRT(&carry, &_21$$8);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueA);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	RETURN_CCTOR(&carry);
+	ZVAL_DOUBLE(&_2, initial);
+	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 16, &_1, callback, &_2);
+	zephir_check_call_status();
+	RETURN_MM();
 }
 
 /**
@@ -2666,7 +2650,7 @@ PHP_METHOD(Tensor_Matrix, transpose)
 		RETURN_MM();
 	}
 	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 786);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 795);
 	ZVAL_LONG(&_1, 1);
 	ZEPHIR_CALL_FUNCTION(&_2, "array_slice", NULL, 28, &cols, &_1);
 	zephir_check_call_status();
@@ -2730,7 +2714,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 803);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 812);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2743,7 +2727,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 29, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 808);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 817);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2758,7 +2742,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 29, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 815);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 824);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2817,7 +2801,7 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 29, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 832);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 841);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2866,7 +2850,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 848);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 857);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2952,7 +2936,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 	ZEPHIR_CPY_WRT(&a, &_3);
 	pivots = 0;
 	epsilon =  (0.00000001);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 903);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 912);
 	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _4)
 	{
 		ZEPHIR_INIT_NVAR(&rowA);
@@ -2965,7 +2949,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 		} else {
 			_5$$3 = &rowA;
 		}
-		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 901);
+		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 910);
 		if (Z_TYPE_P(_5$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$3), _7$$3)
 			{
@@ -3203,7 +3187,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_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/matrix.zep", 952);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 961);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3277,7 +3261,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements 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", 972);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 981);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3375,7 +3359,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 3, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 990);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 999);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3389,7 +3373,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 3, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 995);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 1004);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3725,7 +3709,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1139);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1148);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3796,7 +3780,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1172);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1181);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3868,7 +3852,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1206);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1215);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3940,7 +3924,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1240);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1249);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4012,7 +3996,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1274);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1283);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4084,7 +4068,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1308);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1317);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4156,7 +4140,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1342);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1351);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4228,7 +4212,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1376);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1385);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4300,7 +4284,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1410);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1419);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4372,7 +4356,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1444);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1453);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4444,7 +4428,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1478);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1487);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4516,7 +4500,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1512);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1521);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4739,7 +4723,7 @@ PHP_METHOD(Tensor_Matrix, log)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 1608);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 1617);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -4762,7 +4746,7 @@ PHP_METHOD(Tensor_Matrix, log)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1605);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1614);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -4799,7 +4783,7 @@ PHP_METHOD(Tensor_Matrix, log)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1605);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1614);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5062,7 +5046,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1716);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1725);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5070,7 +5054,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1713);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1722);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5092,7 +5076,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1713);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1722);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5148,7 +5132,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1734);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1743);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5156,7 +5140,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1731);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1740);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5178,7 +5162,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1731);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1740);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5234,7 +5218,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1752);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1761);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5242,7 +5226,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1749);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1758);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5264,7 +5248,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1749);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1758);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5320,7 +5304,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1770);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1779);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5328,7 +5312,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1767);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1776);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5350,7 +5334,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1767);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1776);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5454,7 +5438,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1809);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1818);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5478,7 +5462,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1806);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1815);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5516,7 +5500,7 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1806);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1815);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5602,7 +5586,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1823);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1832);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5623,7 +5607,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1851);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1860);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5639,7 +5623,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1841);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1850);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5651,7 +5635,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1848);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1857);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5681,7 +5665,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1841);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1850);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5693,7 +5677,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1848);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1857);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5768,7 +5752,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1867);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1876);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5788,7 +5772,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 3, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1873);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1882);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5877,7 +5861,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 3, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1898);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1907);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5971,7 +5955,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_4$$4, "Decimal precision cannot", " be less than 0, ", &_3$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_4$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$4, "tensor/matrix.zep", 1924);
+		zephir_throw_exception_debug(&_1$$4, "tensor/matrix.zep", 1933);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5988,7 +5972,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_8 = &_6;
 	}
-	zephir_is_iterable(_8, 0, "tensor/matrix.zep", 1947);
+	zephir_is_iterable(_8, 0, "tensor/matrix.zep", 1956);
 	if (Z_TYPE_P(_8) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_8), _10)
 		{
@@ -6011,7 +5995,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1944);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1953);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _8, "rewind", NULL, 0);
@@ -6048,7 +6032,7 @@ PHP_METHOD(Tensor_Matrix, round)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1944);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1953);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6171,7 +6155,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1983);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1992);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6188,7 +6172,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 	} else {
 		_5 = &_3;
 	}
-	zephir_is_iterable(_5, 0, "tensor/matrix.zep", 2020);
+	zephir_is_iterable(_5, 0, "tensor/matrix.zep", 2029);
 	if (Z_TYPE_P(_5) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5), _7)
 		{
@@ -6221,7 +6205,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 				}
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2017);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2026);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _5, "rewind", NULL, 0);
@@ -6268,7 +6252,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 					}
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2017);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2026);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6339,7 +6323,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2053);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2062);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -6362,7 +6346,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 				}
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2050);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2059);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -6399,7 +6383,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 					}
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2050);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2059);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6470,7 +6454,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2086);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2095);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -6493,7 +6477,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 				}
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2083);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2092);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -6530,7 +6514,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 					}
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2083);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2092);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6602,7 +6586,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2122);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2131);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -6635,7 +6619,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 				}
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2119);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2128);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -6682,7 +6666,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 					}
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2119);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2128);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6742,7 +6726,7 @@ PHP_METHOD(Tensor_Matrix, negate)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2152);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2161);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -6763,7 +6747,7 @@ PHP_METHOD(Tensor_Matrix, negate)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2149);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2158);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -6798,7 +6782,7 @@ PHP_METHOD(Tensor_Matrix, negate)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2149);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2158);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6881,7 +6865,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", 2167);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2176);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6978,7 +6962,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", 2187);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2196);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7082,7 +7066,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", 2207);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2216);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7125,7 +7109,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2221);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2230);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -7214,7 +7198,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", 2239);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2248);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7257,7 +7241,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2253);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2262);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -7335,7 +7319,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2277);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2286);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -7344,7 +7328,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2275);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2284);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -7367,14 +7351,14 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2275);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2284);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2280);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2289);
 		ZVAL_LONG(&_13$$6, 1);
 		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 28, &bigRows, &_13$$6);
 		zephir_check_call_status();
@@ -7460,7 +7444,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2303);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2312);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7535,7 +7519,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2322);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2331);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7610,7 +7594,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2341);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2350);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7685,7 +7669,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2360);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2369);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7761,7 +7745,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2380);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2389);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7837,7 +7821,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2400);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2409);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7913,7 +7897,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2420);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2429);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7988,7 +7972,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2439);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2448);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8064,7 +8048,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2459);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2468);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8140,7 +8124,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2479);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2488);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8215,7 +8199,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2498);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2507);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8290,7 +8274,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2517);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2526);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8375,7 +8359,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2537);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2546);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8408,7 +8392,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_multiply(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2547);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2556);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8486,7 +8470,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2565);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2574);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8519,7 +8503,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_divide(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2575);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2584);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8597,7 +8581,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2593);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2602);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8630,7 +8614,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_add(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2603);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2612);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8708,7 +8692,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2621);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2630);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8741,7 +8725,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_subtract(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2631);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2640);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8819,7 +8803,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2649);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2658);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8852,7 +8836,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_pow(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2659);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2668);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8930,7 +8914,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2677);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2686);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8963,7 +8947,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_mod(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2687);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2696);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9042,7 +9026,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2706);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2715);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9075,7 +9059,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2716);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2725);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9153,7 +9137,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2734);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2743);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9186,7 +9170,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_not_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2744);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2753);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9264,7 +9248,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2762);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2771);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9297,7 +9281,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2772);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2781);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9375,7 +9359,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2790);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2799);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9408,7 +9392,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2800);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2809);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9486,7 +9470,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2818);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2827);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9519,7 +9503,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2828);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2837);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9598,7 +9582,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2847);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2856);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9631,7 +9615,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2857);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2866);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9718,7 +9702,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2875);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2884);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9733,7 +9717,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2886);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2895);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -9754,7 +9738,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_multiply_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2883);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2892);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9785,7 +9769,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_multiply_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2883);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2892);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -9874,7 +9858,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2901);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2910);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9889,7 +9873,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2912);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2921);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -9910,7 +9894,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_divide_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2909);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2918);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9941,7 +9925,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_divide_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2909);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2918);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10030,7 +10014,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2927);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2936);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10045,7 +10029,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2938);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2947);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10066,7 +10050,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_add_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2935);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2944);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10097,7 +10081,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_add_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2935);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2944);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10186,7 +10170,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2953);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2962);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10201,7 +10185,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2964);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2973);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10222,7 +10206,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_subtract_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2961);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2970);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10253,7 +10237,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_subtract_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2961);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2970);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10342,7 +10326,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2979);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2988);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10357,7 +10341,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2990);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2999);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10378,7 +10362,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_pow_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2987);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2996);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10409,7 +10393,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_pow_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2987);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2996);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10498,7 +10482,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3005);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3014);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10513,7 +10497,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3016);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3025);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10534,7 +10518,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_mod_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3013);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3022);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10565,7 +10549,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_mod_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3013);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3022);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10654,7 +10638,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3031);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3040);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10669,7 +10653,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3042);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3051);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10690,7 +10674,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3039);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3048);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10721,7 +10705,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3039);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3048);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10810,7 +10794,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3057);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3066);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10825,7 +10809,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3068);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3077);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10846,7 +10830,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_not_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3065);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3074);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10877,7 +10861,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_not_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3065);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3074);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10966,7 +10950,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3083);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3092);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10981,7 +10965,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3094);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3103);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11002,7 +10986,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_greater_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3091);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3100);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11033,7 +11017,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_greater_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3091);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3100);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11122,7 +11106,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3109);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3118);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11137,7 +11121,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3120);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3129);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11158,7 +11142,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_greater_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3117);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3126);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11189,7 +11173,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_greater_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3117);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3126);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11278,7 +11262,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3135);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3144);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11293,7 +11277,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3146);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3155);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11314,7 +11298,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_less_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3143);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3152);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11345,7 +11329,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_less_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3143);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3152);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11434,7 +11418,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3161);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3170);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11449,7 +11433,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3172);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3181);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11470,7 +11454,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_less_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3169);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3178);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11501,7 +11485,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_less_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3169);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3178);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -12145,7 +12129,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3348);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3357);
 	return;
 }
 
@@ -12196,7 +12180,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3372);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3381);
 	return;
 }
 
@@ -12256,7 +12240,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3386);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3395);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -12273,7 +12257,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3391);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3400);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index e740eb3..bb423f1 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -253,7 +253,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_columnasvector, 0,
 	ZEND_ARG_TYPE_INFO(0, index, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_diagonalasvector, 0, 0, Tensor\\ColumnVector, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_diagonalasvector, 0, 0, Tensor\\Vector, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_asvector, 0, 0, Tensor\\Vector, 0)
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 60122c1..68de06e 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -445,9 +445,28 @@ public static function build(const array a = []) -> <Matrix>
                     }
                 }
             } else {
-                for rowA in a {
+                for i, rowA in a {
                     if typeof rowA == "object" {
+                        if unlikely !(rowA instanceof TensorBuffer) {
+                            throw new InvalidArgumentException("Matrix requires an"
+                                . " array of arrays.");
+                        }
+
+                        if unlikely rowA->count() !== nHat {
+                            throw new InvalidArgumentException("The number of"
+                                . " columns must be equal for all rows, "
+                                .  strval(nHat) . " needed but " . rowA->count()
+                                .  " given at row offset " . i . ".");
+                        }
+
                         let rowA = rowA->toArray();
+                    } else {
+                        if unlikely count(rowA) !== nHat {
+                            throw new InvalidArgumentException("The number of"
+                                . " columns must be equal for all rows, "
+                                .  strval(nHat) . " needed but " . count(rowA)
+                                .  " given at row offset " . i . ".");
+                        }
                     }
 
                     for valueA in rowA {
@@ -586,17 +605,17 @@ public static function build(const array a = []) -> <Matrix>
     /**
      * Return the diagonal elements of a square matrix as a vector.
      *
-     * @return \Tensor\ColumnVector
+     * @return \Tensor\Vector
      * @throws \Tensor\Exceptions\InvalidArgumentException
      */
-    public function diagonalAsVector() -> <ColumnVector>
+    public function diagonalAsVector() -> <Vector>
     {
         if unlikely !this->isSquare() {
             throw new InvalidArgumentException("Matrix must be"
                 . " square, " . this->shapeString() . " given.");
         }
 
-        return ColumnVector::fromTensorBuffer(this->a->sliceStrided(0, this->m, this->n + 1));
+        return Vector::fromTensorBuffer(this->a->sliceStrided(0, this->m, this->n + 1));
     }
 
     /**
@@ -755,17 +774,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function reduce(const var callback, float initial = 0.0) -> float
     {
-        var rowBuffer, valueA;
-
-        var carry = initial;
-
-        for rowBuffer in this->a->split(this->n) {
-            for valueA in rowBuffer {
-                let carry = {callback}(carry, valueA);
-            }
-        }
-
-        return carry;
+        return array_reduce(this->a->toArray(), callback, initial);
     }
  
     /**
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index 449b19d..71dfcda 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -1119,9 +1119,9 @@ public function convolve() : void
             [3, 27, 66, 29, 42, 5],
             [5, 9, 15, 42, 45, 16],
             [1, 5, 10, 22, 66, 5],
-            [0, 1, 4, 9, 10, 22, 2],
+            [0, 1, 4, 9, 10, 22],
             [0, 0, 3, 19, 21, 25],
-            [0, 0, 0, 5, 2, 33, 35],
+            [0, 0, 0, 5, 2, 33],
         ]);
 
         $b = Matrix::quick([

From c068683c040d1a55fcbf9148169c844f89175533 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 22:26:28 -0500
Subject: [PATCH 14/51] Fix benchmarks

---
 benchmarks/Buffer/TensorBufferBench.php     | 6 +++---
 benchmarks/Decompositions/CholeskyBench.php | 4 +++-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/benchmarks/Buffer/TensorBufferBench.php b/benchmarks/Buffer/TensorBufferBench.php
index d150658..a93ac26 100644
--- a/benchmarks/Buffer/TensorBufferBench.php
+++ b/benchmarks/Buffer/TensorBufferBench.php
@@ -57,9 +57,9 @@ public function setUp() : void
         $this->buffer = new TensorBuffer(Buffer::fromArray($a));
         $this->concatOther = new TensorBuffer(Buffer::fromArray($a));
 
-        $this->offset = 2500;
-        $this->length = 5000;
-        $this->stride = 2;
+        $this->offset = 500;
+        $this->length = 2500;
+        $this->stride = 3;
         $this->chunkLength = 100;
         $this->times = 10;
     }
diff --git a/benchmarks/Decompositions/CholeskyBench.php b/benchmarks/Decompositions/CholeskyBench.php
index 7e2b98c..e06e145 100644
--- a/benchmarks/Decompositions/CholeskyBench.php
+++ b/benchmarks/Decompositions/CholeskyBench.php
@@ -17,7 +17,9 @@ class CholeskyBench
 
     public function setUp() : void
     {
-        $this->a = Matrix::rand(500, 500);
+        $a = Matrix::rand(500, 500);
+
+        $this->a = $a->transpose()->matmul($a);
     }
 
     /**

From 5e4212f9c1006cceb8f565aa76b62908bbef0e8b Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 23:32:07 -0500
Subject: [PATCH 15/51] Optimize unary operations

---
 config.json                              |    3 +-
 ext/config.m4                            |    1 +
 ext/config.w32                           |    2 +-
 ext/include/unary.c                      |  446 +++++++
 ext/include/unary.h                      |   30 +
 ext/php_tensor_ext.h                     |    2 +-
 ext/tensor/decompositions/cholesky.zep.c |    6 +-
 ext/tensor/decompositions/eigen.zep.c    |    8 +-
 ext/tensor/decompositions/lu.zep.c       |    6 +-
 ext/tensor/decompositions/svd.zep.c      |    2 +-
 ext/tensor/matrix.zep.c                  | 1507 +++++++++-------------
 ext/tensor/reductions/ref.zep.c          |    2 +-
 ext/tensor/reductions/rref.zep.c         |    2 +-
 ext/tensor/vector.zep.c                  |  891 +++++--------
 optimizers/TensorAbsOptimizer.php        |   76 ++
 optimizers/TensorAcosOptimizer.php       |   76 ++
 optimizers/TensorAsinOptimizer.php       |   76 ++
 optimizers/TensorAtanOptimizer.php       |   76 ++
 optimizers/TensorCeilOptimizer.php       |   76 ++
 optimizers/TensorClipLowerOptimizer.php  |   76 ++
 optimizers/TensorClipOptimizer.php       |   76 ++
 optimizers/TensorClipUpperOptimizer.php  |   76 ++
 optimizers/TensorCosOptimizer.php        |   76 ++
 optimizers/TensorDeg2radOptimizer.php    |   76 ++
 optimizers/TensorExpOptimizer.php        |   76 ++
 optimizers/TensorExpm1Optimizer.php      |   76 ++
 optimizers/TensorFloorOptimizer.php      |   76 ++
 optimizers/TensorLog1pOptimizer.php      |   76 ++
 optimizers/TensorLogBaseOptimizer.php    |   76 ++
 optimizers/TensorLogOptimizer.php        |   76 ++
 optimizers/TensorNegateOptimizer.php     |   76 ++
 optimizers/TensorRad2degOptimizer.php    |   76 ++
 optimizers/TensorRoundOptimizer.php      |   76 ++
 optimizers/TensorSignOptimizer.php       |   76 ++
 optimizers/TensorSinOptimizer.php        |   76 ++
 optimizers/TensorSqrtOptimizer.php       |   76 ++
 optimizers/TensorTanOptimizer.php        |   76 ++
 tensor/matrix.zep                        |  204 +--
 tensor/vector.zep                        |  153 +--
 39 files changed, 3228 insertions(+), 1785 deletions(-)
 create mode 100644 ext/include/unary.c
 create mode 100644 ext/include/unary.h
 create mode 100644 optimizers/TensorAbsOptimizer.php
 create mode 100644 optimizers/TensorAcosOptimizer.php
 create mode 100644 optimizers/TensorAsinOptimizer.php
 create mode 100644 optimizers/TensorAtanOptimizer.php
 create mode 100644 optimizers/TensorCeilOptimizer.php
 create mode 100644 optimizers/TensorClipLowerOptimizer.php
 create mode 100644 optimizers/TensorClipOptimizer.php
 create mode 100644 optimizers/TensorClipUpperOptimizer.php
 create mode 100644 optimizers/TensorCosOptimizer.php
 create mode 100644 optimizers/TensorDeg2radOptimizer.php
 create mode 100644 optimizers/TensorExpOptimizer.php
 create mode 100644 optimizers/TensorExpm1Optimizer.php
 create mode 100644 optimizers/TensorFloorOptimizer.php
 create mode 100644 optimizers/TensorLog1pOptimizer.php
 create mode 100644 optimizers/TensorLogBaseOptimizer.php
 create mode 100644 optimizers/TensorLogOptimizer.php
 create mode 100644 optimizers/TensorNegateOptimizer.php
 create mode 100644 optimizers/TensorRad2degOptimizer.php
 create mode 100644 optimizers/TensorRoundOptimizer.php
 create mode 100644 optimizers/TensorSignOptimizer.php
 create mode 100644 optimizers/TensorSinOptimizer.php
 create mode 100644 optimizers/TensorSqrtOptimizer.php
 create mode 100644 optimizers/TensorTanOptimizer.php

diff --git a/config.json b/config.json
index 92ef75d..e37ff6d 100644
--- a/config.json
+++ b/config.json
@@ -4,7 +4,7 @@
     "extension-name": "tensor_ext",
     "description": "Scientific computing for the PHP language.",
     "author": "The Rubix ML Community",
-    "version": "3.2.0",
+    "version": "4.0.0",
     "verbose": true,
     "extra-cflags": "-O3",
     "extra-libs": "-lopenblas -llapacke -lgfortran",
@@ -12,6 +12,7 @@
         "include/arithmetic.c",
         "include/buffer.c",
         "include/comparison.c",
+        "include/unary.c",
         "include/linear_algebra.c",
         "include/signal_processing.c",
         "include/settings.c"
diff --git a/ext/config.m4 b/ext/config.m4
index a92b929..f902605 100644
--- a/ext/config.m4
+++ b/ext/config.m4
@@ -35,6 +35,7 @@ if test "$PHP_TENSOR_EXT" = "yes"; then
 	tensor/tensorbuffer.zep.c include/arithmetic.c
 	include/buffer.c
 	include/comparison.c
+	include/unary.c
 	include/linear_algebra.c
 	include/signal_processing.c
 	include/settings.c"
diff --git a/ext/config.w32 b/ext/config.w32
index 6fefafe..ffc215e 100644
--- a/ext/config.w32
+++ b/ext/config.w32
@@ -9,7 +9,7 @@ if (PHP_TENSOR_EXT != "no") {
     ADD_EXTENSION_DEP("tensor_ext", "json");
     AC_DEFINE("ZEPHIR_USE_PHP_JSON", 1, "Whether PHP json extension is present at compile time");
   }
-  ADD_SOURCES(configure_module_dirname + "/include", "arithmetic.c buffer.c comparison.c linear_algebra.c signal_processing.c settings.c", "tensor_ext");
+  ADD_SOURCES(configure_module_dirname + "/include", "arithmetic.c buffer.c comparison.c unary.c linear_algebra.c signal_processing.c settings.c", "tensor_ext");
   ADD_SOURCES(configure_module_dirname + "/tensor", "algebraic.zep.c arithmetic.zep.c arraylike.zep.c comparable.zep.c special.zep.c statistical.zep.c trigonometric.zep.c tensor.zep.c vector.zep.c columnvector.zep.c matrix.zep.c settings.zep.c tensorbuffer.zep.c", "tensor_ext");
 	ADD_SOURCES(configure_module_dirname + "/tensor/exceptions", "tensorexception.zep.c invalidargumentexception.zep.c runtimeexception.zep.c dimensionalitymismatch.zep.c singularmatrix.zep.c", "tensor_ext");
 	ADD_SOURCES(configure_module_dirname + "/tensor/decompositions", "cholesky.zep.c eigen.zep.c lu.zep.c svd.zep.c", "tensor_ext");
diff --git a/ext/include/unary.c b/ext/include/unary.c
new file mode 100644
index 0000000..77917c7
--- /dev/null
+++ b/ext/include/unary.c
@@ -0,0 +1,446 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <php.h>
+#include <math.h>
+#include <limits.h>
+#include <stdio.h>
+#include <ext/spl/spl_exceptions.h>
+#include "kernel/operators.h"
+#include "kernel/buffer.h"
+#include "include/buffer.h"
+
+/* Values wrapped up by the kernel Buffer used in the unary operations below.
+ * Returns a reference to a newly created `Tensor\TensorBuffer` holding the
+ * mapped doubles. */
+
+static void tensor_elementwise_unary(zval * return_value, zval * a, double (* fn)(double))
+{
+	zend_long n = 0;
+	int ok = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &n, &ok);
+
+	if (UNEXPECTED(!ok)) {
+		return;
+	}
+
+	zval b;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, n, &b) == FAILURE)) {
+		return;
+	}
+
+	double * vb = zephir_buffer_doubles(&b);
+
+	zend_long i;
+
+	for (i = 0; i < n; ++i) {
+		vb[i] = fn(va[i]);
+	}
+
+	zval_ptr_dtor(&b);
+}
+
+static double tensor_rad2deg_value(double v)
+{
+	return (v / M_PI) * 180;
+}
+
+static double tensor_deg2rad_value(double v)
+{
+	return (v / 180.0) * M_PI;
+}
+
+static double tensor_negate_value(double v)
+{
+	return -v;
+}
+
+static double tensor_sign_value(double v)
+{
+	return v > 0.0 ? 1.0 : (v < 0.0 ? -1.0 : 0.0);
+}
+
+void tensor_abs(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, fabs);
+}
+
+void tensor_sqrt(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, sqrt);
+}
+
+void tensor_exp(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, exp);
+}
+
+void tensor_expm1(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, expm1);
+}
+
+void tensor_log(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, log);
+}
+
+void tensor_log1p(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, log1p);
+}
+
+void tensor_sin(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, sin);
+}
+
+void tensor_asin(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, asin);
+}
+
+void tensor_cos(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, cos);
+}
+
+void tensor_acos(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, acos);
+}
+
+void tensor_tan(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, tan);
+}
+
+void tensor_atan(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, atan);
+}
+
+void tensor_rad2deg(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, tensor_rad2deg_value);
+}
+
+void tensor_deg2rad(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, tensor_deg2rad_value);
+}
+
+void tensor_floor(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, floor);
+}
+
+void tensor_ceil(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, ceil);
+}
+
+void tensor_negate(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, tensor_negate_value);
+}
+
+void tensor_sign(zval * return_value, zval * a)
+{
+	tensor_elementwise_unary(return_value, a, tensor_sign_value);
+}
+
+void tensor_log_base(zval * return_value, zval * a, zval * b)
+{
+	zend_long i;
+	zend_long n = 0;
+	int ok = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &n, &ok);
+
+	if (UNEXPECTED(!ok)) {
+		return;
+	}
+
+	double base = zephir_get_doubleval(b);
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, n, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < n; ++i) {
+		vc[i] = log(va[i]) / log(base);
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+/* The following mirror the rounding implementation in ext/standard/math.c so
+ * that results match PHP's round() exactly. */
+static int tensor_intlog10abs(double value)
+{
+	value = fabs(value);
+
+	if (value < 1e-8 || value > 1e22) {
+		return (int) floor(log10(value));
+	} else {
+		int result = 15;
+		static const double values[] = {
+				1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1e0, 1e1, 1e2,
+				1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13,
+				1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+
+		if (value < values[result]) {
+			result -= 8;
+		} else {
+			result += 8;
+		}
+
+		if (value < values[result]) {
+			result -= 4;
+		} else {
+			result += 4;
+		}
+
+		if (value < values[result]) {
+			result -= 2;
+		} else {
+			result += 2;
+		}
+
+		if (value < values[result]) {
+			result -= 1;
+		} else {
+			result += 1;
+		}
+
+		if (value < values[result]) {
+			result -= 1;
+		}
+
+		result -= 8;
+
+		return result;
+	}
+}
+
+static double tensor_intpow10(int power)
+{
+	if (power < 0 || power > 22) {
+		return pow(10.0, (double) power);
+	}
+
+	static const double powers[] = {
+			1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11,
+			1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+
+	return powers[power];
+}
+
+static double tensor_round_half_up(double value)
+{
+	return value >= 0.0 ? floor(value + 0.5) : ceil(value - 0.5);
+}
+
+static double tensor_math_round(double value, int places)
+{
+	double f1, f2;
+	double tmp_value;
+	int precision_places;
+
+	if (!isfinite(value) || value == 0.0) {
+		return value;
+	}
+
+	places = places < INT_MIN + 1 ? INT_MIN + 1 : places;
+
+	precision_places = 14 - tensor_intlog10abs(value);
+
+	f1 = tensor_intpow10(abs(places));
+
+	if (precision_places > places && precision_places - 15 < places) {
+		int64_t use_precision = precision_places < INT_MIN + 1 ? INT_MIN + 1 : precision_places;
+
+		f2 = tensor_intpow10(abs((int) use_precision));
+
+		if (use_precision >= 0) {
+			tmp_value = value * f2;
+		} else {
+			tmp_value = value / f2;
+		}
+
+		tmp_value = tensor_round_half_up(tmp_value);
+
+		use_precision = places - precision_places;
+
+		if (use_precision < INT_MIN + 1) {
+			use_precision = INT_MIN + 1;
+		}
+
+		f2 = tensor_intpow10(abs((int) use_precision));
+
+		tmp_value = tmp_value / f2;
+	} else {
+		if (places >= 0) {
+			tmp_value = value * f1;
+		} else {
+			tmp_value = value / f1;
+		}
+
+		if (fabs(tmp_value) >= 1e15) {
+			return value;
+		}
+	}
+
+	tmp_value = tensor_round_half_up(tmp_value);
+
+	if (abs(places) < 23) {
+		if (places > 0) {
+			tmp_value = tmp_value / f1;
+		} else {
+			tmp_value = tmp_value * f1;
+		}
+	} else {
+		char buf[40];
+
+		snprintf(buf, 39, "%15fe%d", tmp_value, -places);
+
+		buf[39] = '\0';
+
+		double parsed = zend_strtod(buf, NULL);
+
+		if (!isfinite(parsed) || isnan(parsed)) {
+			parsed = value;
+		}
+
+		tmp_value = parsed;
+	}
+
+	return tmp_value;
+}
+
+void tensor_round(zval * return_value, zval * a, zval * precision)
+{
+	zend_long i;
+	zend_long n = 0;
+	int ok = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &n, &ok);
+
+	if (UNEXPECTED(!ok)) {
+		return;
+	}
+
+	zend_long p = zephir_get_intval(precision);
+
+	int places = p > INT_MAX ? INT_MAX : (int) p;
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, n, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < n; ++i) {
+		vc[i] = tensor_math_round(va[i], places);
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+void tensor_clip(zval * return_value, zval * a, zval * min, zval * max)
+{
+	zend_long i;
+	zend_long n = 0;
+	int ok = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &n, &ok);
+
+	if (UNEXPECTED(!ok)) {
+		return;
+	}
+
+	double lo = zephir_get_doubleval(min);
+	double hi = zephir_get_doubleval(max);
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, n, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < n; ++i) {
+		vc[i] = va[i] > hi ? hi : (va[i] < lo ? lo : va[i]);
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+void tensor_clip_lower(zval * return_value, zval * a, zval * min)
+{
+	zend_long i;
+	zend_long n = 0;
+	int ok = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &n, &ok);
+
+	if (UNEXPECTED(!ok)) {
+		return;
+	}
+
+	double lo = zephir_get_doubleval(min);
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, n, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < n; ++i) {
+		vc[i] = va[i] < lo ? lo : va[i];
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+void tensor_clip_upper(zval * return_value, zval * a, zval * max)
+{
+	zend_long i;
+	zend_long n = 0;
+	int ok = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &n, &ok);
+
+	if (UNEXPECTED(!ok)) {
+		return;
+	}
+
+	double hi = zephir_get_doubleval(max);
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, n, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < n; ++i) {
+		vc[i] = va[i] > hi ? hi : va[i];
+	}
+
+	zval_ptr_dtor(&c);
+}
\ No newline at end of file
diff --git a/ext/include/unary.h b/ext/include/unary.h
new file mode 100644
index 0000000..5a8b39a
--- /dev/null
+++ b/ext/include/unary.h
@@ -0,0 +1,30 @@
+#ifndef TENSOR_ELEMENTWISE_H
+#define TENSOR_ELEMENTWISE_H
+
+#include <Zend/zend.h>
+
+void tensor_abs(zval * return_value, zval * a);
+void tensor_sqrt(zval * return_value, zval * a);
+void tensor_exp(zval * return_value, zval * a);
+void tensor_expm1(zval * return_value, zval * a);
+void tensor_log(zval * return_value, zval * a);
+void tensor_log_base(zval * return_value, zval * a, zval * b);
+void tensor_log1p(zval * return_value, zval * a);
+void tensor_sin(zval * return_value, zval * a);
+void tensor_asin(zval * return_value, zval * a);
+void tensor_cos(zval * return_value, zval * a);
+void tensor_acos(zval * return_value, zval * a);
+void tensor_tan(zval * return_value, zval * a);
+void tensor_atan(zval * return_value, zval * a);
+void tensor_rad2deg(zval * return_value, zval * a);
+void tensor_deg2rad(zval * return_value, zval * a);
+void tensor_floor(zval * return_value, zval * a);
+void tensor_ceil(zval * return_value, zval * a);
+void tensor_round(zval * return_value, zval * a, zval * precision);
+void tensor_negate(zval * return_value, zval * a);
+void tensor_sign(zval * return_value, zval * a);
+void tensor_clip(zval * return_value, zval * a, zval * min, zval * max);
+void tensor_clip_lower(zval * return_value, zval * a, zval * min);
+void tensor_clip_upper(zval * return_value, zval * a, zval * max);
+
+#endif
\ No newline at end of file
diff --git a/ext/php_tensor_ext.h b/ext/php_tensor_ext.h
index 603d87c..50ab57c 100644
--- a/ext/php_tensor_ext.h
+++ b/ext/php_tensor_ext.h
@@ -11,7 +11,7 @@
 #include "kernel/globals.h"
 
 #define PHP_TENSOR_EXT_NAME        "tensor"
-#define PHP_TENSOR_EXT_VERSION     "3.2.0"
+#define PHP_TENSOR_EXT_VERSION     "4.0.0"
 #define PHP_TENSOR_EXT_EXTNAME     "tensor_ext"
 #define PHP_TENSOR_EXT_AUTHOR      "The Rubix ML Community"
 #define PHP_TENSOR_EXT_ZEPVERSION  "1.5.0-$Id$"
diff --git a/ext/tensor/decompositions/cholesky.zep.c b/ext/tensor/decompositions/cholesky.zep.c
index 7c052bc..d2ec0a9 100644
--- a/ext/tensor/decompositions/cholesky.zep.c
+++ b/ext/tensor/decompositions/cholesky.zep.c
@@ -71,12 +71,12 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
 	zephir_check_call_status();
 	if (!(zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -87,7 +87,7 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&l);
-	ZEPHIR_CALL_METHOD(&_4, a, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, a, "asarray", NULL, 0);
 	zephir_check_call_status();
 	tensor_cholesky(&l, &_4);
 	if (Z_TYPE_P(&l) == IS_NULL) {
diff --git a/ext/tensor/decompositions/eigen.zep.c b/ext/tensor/decompositions/eigen.zep.c
index b6fbc33..d42b223 100644
--- a/ext/tensor/decompositions/eigen.zep.c
+++ b/ext/tensor/decompositions/eigen.zep.c
@@ -95,12 +95,12 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 		symmetric = 0;
 	} else {
 		}
-	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -112,12 +112,12 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	}
 	if (symmetric) {
 		ZEPHIR_INIT_VAR(&result);
-		ZEPHIR_CALL_METHOD(&_4$$4, a, "asArray", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$4, a, "asarray", NULL, 0);
 		zephir_check_call_status();
 		tensor_eig_symmetric(&result, &_4$$4);
 	} else {
 		ZEPHIR_INIT_NVAR(&result);
-		ZEPHIR_CALL_METHOD(&_5$$5, a, "asArray", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_5$$5, a, "asarray", NULL, 0);
 		zephir_check_call_status();
 		tensor_eig(&result, &_5$$5);
 	}
diff --git a/ext/tensor/decompositions/lu.zep.c b/ext/tensor/decompositions/lu.zep.c
index 2558442..fe2704e 100644
--- a/ext/tensor/decompositions/lu.zep.c
+++ b/ext/tensor/decompositions/lu.zep.c
@@ -94,12 +94,12 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -110,7 +110,7 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_4, a, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, a, "asarray", NULL, 0);
 	zephir_check_call_status();
 	tensor_lu(&result, &_4);
 	if (Z_TYPE_P(&result) == IS_NULL) {
diff --git a/ext/tensor/decompositions/svd.zep.c b/ext/tensor/decompositions/svd.zep.c
index 8c95622..bb34fce 100644
--- a/ext/tensor/decompositions/svd.zep.c
+++ b/ext/tensor/decompositions/svd.zep.c
@@ -85,7 +85,7 @@ PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_0, a, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "asarray", NULL, 0);
 	zephir_check_call_status();
 	tensor_svd(&result, &_0);
 	if (Z_TYPE_P(&result) == IS_NULL) {
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 167d524..8854893 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -26,6 +26,7 @@
 #include "include/buffer.h"
 #include "include/linear_algebra.h"
 #include "include/signal_processing.h"
+#include "include/unary.h"
 #include "include/arithmetic.h"
 #include "include/comparison.h"
 
@@ -4547,18 +4548,36 @@ PHP_METHOD(Tensor_Matrix, reciprocal)
  */
 PHP_METHOD(Tensor_Matrix, abs)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "abs");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_abs(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4588,18 +4607,36 @@ PHP_METHOD(Tensor_Matrix, square)
  */
 PHP_METHOD(Tensor_Matrix, sqrt)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "sqrt");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_sqrt(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4611,18 +4648,36 @@ PHP_METHOD(Tensor_Matrix, sqrt)
  */
 PHP_METHOD(Tensor_Matrix, exp)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "exp");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_exp(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4634,18 +4689,36 @@ PHP_METHOD(Tensor_Matrix, exp)
  */
 PHP_METHOD(Tensor_Matrix, expm1)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "expm1");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_expm1(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4658,37 +4731,32 @@ PHP_METHOD(Tensor_Matrix, expm1)
  */
 PHP_METHOD(Tensor_Matrix, log)
 {
-	zend_bool _14;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_9 = NULL, *_11 = NULL, *_12 = NULL, *_17 = NULL, *_19 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
-	zval *base_param = NULL, _0$$3, rowA, valueA, _1, _2, _3, *_4, _5, *_6, _13, _7$$4, _8$$5, _10$$5, _15$$6, _16$$7, _18$$7;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *base_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4, _5, _6, _7, _8;
 	double base;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_13);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_8$$5);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_15$$6);
-	ZVAL_UNDEF(&_16$$7);
-	ZVAL_UNDEF(&_18$$7);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(0, 1)
@@ -4705,89 +4773,21 @@ PHP_METHOD(Tensor_Matrix, log)
 	}
 	if (base == 2.7182818284590452354) {
 		ZEPHIR_INIT_VAR(&_0$$3);
-		ZVAL_STRING(&_0$$3, "log");
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0$$3);
+		zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+		tensor_log(&_0$$3, &_1$$3);
+		zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+		zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+		ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0$$3, &_2$$3, &_3$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_2, &_1, "split", NULL, 0, &_3);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_2) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_5);
-		zephir_string_to_char_array(&_5, &_2);
-		_4 = &_5;
-	} else {
-		_4 = &_2;
-	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 1617);
-	if (Z_TYPE_P(_4) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _6);
-			i = 0;
-			while (1) {
-				zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-				if (!(ZEPHIR_GT_LONG(&_7$$4, i))) {
-					break;
-				}
-				ZVAL_LONG(&_8$$5, i);
-				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_9, 0, &_8$$5);
-				zephir_check_call_status();
-				ZVAL_DOUBLE(&_8$$5, base);
-				ZEPHIR_CALL_FUNCTION(&_10$$5, "log", &_11, 8, &valueA, &_8$$5);
-				zephir_check_call_status();
-				ZVAL_LONG(&_8$$5, i);
-				ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_12, 0, &_8$$5, &_10$$5);
-				zephir_check_call_status();
-				i++;
-			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1614);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_14 = 1;
-		while (1) {
-			if (_14) {
-				_14 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _4, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_13, _4, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_13)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _4, "current", NULL, 0);
-			zephir_check_call_status();
-				i = 0;
-				while (1) {
-					zephir_read_property_cached(&_15$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-					if (!(ZEPHIR_GT_LONG(&_15$$6, i))) {
-						break;
-					}
-					ZVAL_LONG(&_16$$7, i);
-					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_17, 0, &_16$$7);
-					zephir_check_call_status();
-					ZVAL_DOUBLE(&_16$$7, base);
-					ZEPHIR_CALL_FUNCTION(&_18$$7, "log", &_11, 8, &valueA, &_16$$7);
-					zephir_check_call_status();
-					ZVAL_LONG(&_16$$7, i);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_19, 0, &_16$$7, &_18$$7);
-					zephir_check_call_status();
-					i++;
-				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1614);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_4);
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_6, base);
+	tensor_log_base(&_4, &_5, &_6);
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_4, &_7, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4799,18 +4799,36 @@ PHP_METHOD(Tensor_Matrix, log)
  */
 PHP_METHOD(Tensor_Matrix, log1p)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "log1p");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_log1p(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4822,18 +4840,36 @@ PHP_METHOD(Tensor_Matrix, log1p)
  */
 PHP_METHOD(Tensor_Matrix, sin)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "sin");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_sin(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4845,18 +4881,36 @@ PHP_METHOD(Tensor_Matrix, sin)
  */
 PHP_METHOD(Tensor_Matrix, asin)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "asin");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_asin(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4868,18 +4922,36 @@ PHP_METHOD(Tensor_Matrix, asin)
  */
 PHP_METHOD(Tensor_Matrix, cos)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "cos");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_cos(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4891,18 +4963,36 @@ PHP_METHOD(Tensor_Matrix, cos)
  */
 PHP_METHOD(Tensor_Matrix, acos)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "acos");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_acos(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4914,18 +5004,36 @@ PHP_METHOD(Tensor_Matrix, acos)
  */
 PHP_METHOD(Tensor_Matrix, tan)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "tan");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_tan(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4937,18 +5045,36 @@ PHP_METHOD(Tensor_Matrix, tan)
  */
 PHP_METHOD(Tensor_Matrix, atan)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "atan");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_atan(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4960,18 +5086,36 @@ PHP_METHOD(Tensor_Matrix, atan)
  */
 PHP_METHOD(Tensor_Matrix, rad2deg)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "rad2deg");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_rad2deg(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4983,18 +5127,36 @@ PHP_METHOD(Tensor_Matrix, rad2deg)
  */
 PHP_METHOD(Tensor_Matrix, deg2rad)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "deg2rad");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_deg2rad(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5046,7 +5208,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1725);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1707);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5054,7 +5216,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1722);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1704);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5076,7 +5238,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1722);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1704);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5132,7 +5294,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1743);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1725);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5140,7 +5302,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1740);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1722);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5162,7 +5324,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1740);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1722);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5218,7 +5380,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1761);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1743);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5226,7 +5388,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1758);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1740);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5248,7 +5410,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1758);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1740);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5304,7 +5466,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1779);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1761);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5312,7 +5474,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1776);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1758);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5334,7 +5496,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1776);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1758);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5438,7 +5600,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1818);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1800);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5462,7 +5624,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1815);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1797);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5500,7 +5662,7 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1815);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1797);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5586,7 +5748,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1832);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1814);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5607,7 +5769,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1860);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1842);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5623,7 +5785,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1850);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1832);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5635,7 +5797,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1857);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1839);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5665,7 +5827,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1850);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1832);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5677,7 +5839,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1857);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1839);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5752,7 +5914,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1876);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1858);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5772,7 +5934,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 3, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1882);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1864);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5861,7 +6023,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 3, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1907);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1889);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5889,42 +6051,50 @@ PHP_METHOD(Tensor_Matrix, covariance)
  */
 PHP_METHOD(Tensor_Matrix, round)
 {
-	zend_bool _18;
+	zend_bool _22;
 	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_13 = NULL, *_16 = NULL, *_21 = NULL, *_24 = NULL;
-	zval *precision_param = NULL, _0$$3, _1$$4, _2$$4, _3$$4, _4$$4, rowA, valueA, _5, _6, _7, *_8, _9, *_10, _17, _11$$5, _12$$6, _14$$6, _15$$6, _19$$7, _20$$8, _22$$8, _23$$8;
+	zephir_fcall_cache_entry *_17 = NULL, *_20 = NULL, *_25 = NULL, *_28 = NULL;
+	zval *precision_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, rowA, valueA, _9, _10, _11, *_12, _13, *_14, _21, _15$$5, _16$$6, _18$$6, _19$$6, _23$$7, _24$$8, _26$$8, _27$$8;
 	zend_long precision, ZEPHIR_LAST_CALL_STATUS, i = 0;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&_1$$4);
-	ZVAL_UNDEF(&_2$$4);
-	ZVAL_UNDEF(&_3$$4);
-	ZVAL_UNDEF(&_4$$4);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_7$$4);
+	ZVAL_UNDEF(&_8$$4);
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_9);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_11$$5);
-	ZVAL_UNDEF(&_12$$6);
-	ZVAL_UNDEF(&_14$$6);
-	ZVAL_UNDEF(&_15$$6);
-	ZVAL_UNDEF(&_19$$7);
-	ZVAL_UNDEF(&_20$$8);
-	ZVAL_UNDEF(&_22$$8);
-	ZVAL_UNDEF(&_23$$8);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&_21);
+	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_16$$6);
+	ZVAL_UNDEF(&_18$$6);
+	ZVAL_UNDEF(&_19$$6);
+	ZVAL_UNDEF(&_23$$7);
+	ZVAL_UNDEF(&_24$$8);
+	ZVAL_UNDEF(&_26$$8);
+	ZVAL_UNDEF(&_27$$8);
 	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(0, 1)
@@ -5940,99 +6110,103 @@ PHP_METHOD(Tensor_Matrix, round)
 		}
 	if (precision == 0) {
 		ZEPHIR_INIT_VAR(&_0$$3);
-		ZVAL_STRING(&_0$$3, "round");
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0$$3);
+		zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+		ZVAL_LONG(&_2$$3, 0);
+		tensor_round(&_0$$3, &_1$$3, &_2$$3);
+		zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+		zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+		ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0$$3, &_3$$3, &_4$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
 	if (UNEXPECTED(precision < 0)) {
-		ZEPHIR_INIT_VAR(&_1$$4);
-		object_init_ex(&_1$$4, tensor_exceptions_invalidargumentexception_ce);
-		ZVAL_LONG(&_2$$4, precision);
-		ZEPHIR_CALL_FUNCTION(&_3$$4, "strval", NULL, 4, &_2$$4);
+		ZEPHIR_INIT_VAR(&_5$$4);
+		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
+		ZVAL_LONG(&_6$$4, precision);
+		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", NULL, 4, &_6$$4);
 		zephir_check_call_status();
-		ZEPHIR_INIT_VAR(&_4$$4);
-		ZEPHIR_CONCAT_SSVS(&_4$$4, "Decimal precision cannot", " be less than 0, ", &_3$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_4$$4);
+		ZEPHIR_INIT_VAR(&_8$$4);
+		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less than 0, ", &_7$$4, " given.");
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$4, "tensor/matrix.zep", 1933);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1917);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&b);
 	array_init(&b);
-	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_6, &_5, "split", NULL, 0, &_7);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_6) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_9);
-		zephir_string_to_char_array(&_9, &_6);
-		_8 = &_9;
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_10, &_9, "split", NULL, 0, &_11);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_10) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_13);
+		zephir_string_to_char_array(&_13, &_10);
+		_12 = &_13;
 	} else {
-		_8 = &_6;
+		_12 = &_10;
 	}
-	zephir_is_iterable(_8, 0, "tensor/matrix.zep", 1956);
-	if (Z_TYPE_P(_8) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_8), _10)
+	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1940);
+	if (Z_TYPE_P(_12) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
 		{
 			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _10);
+			ZVAL_COPY(&rowA, _14);
 			i = 0;
 			while (1) {
-				zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-				if (!(ZEPHIR_GT_LONG(&_11$$5, i))) {
+				zephir_read_property_cached(&_15$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+				if (!(ZEPHIR_GT_LONG(&_15$$5, i))) {
 					break;
 				}
-				ZVAL_LONG(&_12$$6, i);
-				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_13, 0, &_12$$6);
+				ZVAL_LONG(&_16$$6, i);
+				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_17, 0, &_16$$6);
 				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_14$$6);
-				ZVAL_LONG(&_12$$6, precision);
-				zephir_round(&_14$$6, &valueA, &_12$$6, NULL);
-				ZVAL_LONG(&_15$$6, i);
-				ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_16, 0, &_15$$6, &_14$$6);
+				ZEPHIR_INIT_NVAR(&_18$$6);
+				ZVAL_LONG(&_16$$6, precision);
+				zephir_round(&_18$$6, &valueA, &_16$$6, NULL);
+				ZVAL_LONG(&_19$$6, i);
+				ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_20, 0, &_19$$6, &_18$$6);
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1953);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1937);
 		} ZEND_HASH_FOREACH_END();
 	} else {
-		ZEPHIR_CALL_METHOD(NULL, _8, "rewind", NULL, 0);
+		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_18 = 1;
+		_22 = 1;
 		while (1) {
-			if (_18) {
-				_18 = 0;
+			if (_22) {
+				_22 = 0;
 			} else {
-				ZEPHIR_CALL_METHOD(NULL, _8, "next", NULL, 0);
+				ZEPHIR_CALL_METHOD(NULL, _12, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_17, _8, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_21, _12, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
+			if (!zend_is_true(&_21)) {
 				break;
 			}
-			ZEPHIR_CALL_METHOD(&rowA, _8, "current", NULL, 0);
+			ZEPHIR_CALL_METHOD(&rowA, _12, "current", NULL, 0);
 			zephir_check_call_status();
 				i = 0;
 				while (1) {
-					zephir_read_property_cached(&_19$$7, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-					if (!(ZEPHIR_GT_LONG(&_19$$7, i))) {
+					zephir_read_property_cached(&_23$$7, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+					if (!(ZEPHIR_GT_LONG(&_23$$7, i))) {
 						break;
 					}
-					ZVAL_LONG(&_20$$8, i);
-					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_21, 0, &_20$$8);
+					ZVAL_LONG(&_24$$8, i);
+					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_25, 0, &_24$$8);
 					zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&_22$$8);
-					ZVAL_LONG(&_20$$8, precision);
-					zephir_round(&_22$$8, &valueA, &_20$$8, NULL);
-					ZVAL_LONG(&_23$$8, i);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_24, 0, &_23$$8, &_22$$8);
+					ZEPHIR_INIT_NVAR(&_26$$8);
+					ZVAL_LONG(&_24$$8, precision);
+					zephir_round(&_26$$8, &valueA, &_24$$8, NULL);
+					ZVAL_LONG(&_27$$8, i);
+					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_28, 0, &_27$$8, &_26$$8);
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1953);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1937);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6048,18 +6222,36 @@ PHP_METHOD(Tensor_Matrix, round)
  */
 PHP_METHOD(Tensor_Matrix, floor)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "floor");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_floor(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6071,18 +6263,36 @@ PHP_METHOD(Tensor_Matrix, floor)
  */
 PHP_METHOD(Tensor_Matrix, ceil)
 {
-	zval _0;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "ceil");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_ceil(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6098,45 +6308,32 @@ PHP_METHOD(Tensor_Matrix, ceil)
  */
 PHP_METHOD(Tensor_Matrix, clip)
 {
-	zend_bool _18;
-	zval b;
 	zval _1$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_10 = NULL, *_13 = NULL, *_16 = NULL, *_21 = NULL, *_24 = NULL, *_27 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
-	zval *min_param = NULL, *max_param = NULL, _0$$3, rowA, valueA, _2, _3, _4, *_5, _6, *_7, _17, _8$$4, _9$$5, _11$$6, _12$$6, _14$$7, _15$$7, _19$$8, _20$$9, _22$$10, _23$$10, _25$$11, _26$$11;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *min_param = NULL, *max_param = NULL, _0$$3, _2, _3, _4, _5, _6, _7;
 	double min, max;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
 	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$5);
-	ZVAL_UNDEF(&_11$$6);
-	ZVAL_UNDEF(&_12$$6);
-	ZVAL_UNDEF(&_14$$7);
-	ZVAL_UNDEF(&_15$$7);
-	ZVAL_UNDEF(&_19$$8);
-	ZVAL_UNDEF(&_20$$9);
-	ZVAL_UNDEF(&_22$$10);
-	ZVAL_UNDEF(&_23$$10);
-	ZVAL_UNDEF(&_25$$11);
-	ZVAL_UNDEF(&_26$$11);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_1$$3);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(2, 2)
@@ -6155,108 +6352,18 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1992);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1976);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_3, &_2, "split", NULL, 0, &_4);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_3) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_6);
-		zephir_string_to_char_array(&_6, &_3);
-		_5 = &_6;
-	} else {
-		_5 = &_3;
-	}
-	zephir_is_iterable(_5, 0, "tensor/matrix.zep", 2029);
-	if (Z_TYPE_P(_5) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5), _7)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _7);
-			i = 0;
-			while (1) {
-				zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-				if (!(ZEPHIR_GT_LONG(&_8$$4, i))) {
-					break;
-				}
-				ZVAL_LONG(&_9$$5, i);
-				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_10, 0, &_9$$5);
-				zephir_check_call_status();
-				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-					ZVAL_LONG(&_11$$6, i);
-					ZVAL_DOUBLE(&_12$$6, max);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_13, 0, &_11$$6, &_12$$6);
-					zephir_check_call_status();
-					i++;
-					continue;
-				}
-				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-					ZVAL_LONG(&_14$$7, i);
-					ZVAL_DOUBLE(&_15$$7, min);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_16, 0, &_14$$7, &_15$$7);
-					zephir_check_call_status();
-					i++;
-					continue;
-				}
-				i++;
-			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2026);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _5, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_18 = 1;
-		while (1) {
-			if (_18) {
-				_18 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _5, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_17, _5, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_17)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _5, "current", NULL, 0);
-			zephir_check_call_status();
-				i = 0;
-				while (1) {
-					zephir_read_property_cached(&_19$$8, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-					if (!(ZEPHIR_GT_LONG(&_19$$8, i))) {
-						break;
-					}
-					ZVAL_LONG(&_20$$9, i);
-					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_21, 0, &_20$$9);
-					zephir_check_call_status();
-					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-						ZVAL_LONG(&_22$$10, i);
-						ZVAL_DOUBLE(&_23$$10, max);
-						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_24, 0, &_22$$10, &_23$$10);
-						zephir_check_call_status();
-						i++;
-						continue;
-					}
-					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-						ZVAL_LONG(&_25$$11, i);
-						ZVAL_DOUBLE(&_26$$11, min);
-						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_27, 0, &_25$$11, &_26$$11);
-						zephir_check_call_status();
-						i++;
-						continue;
-					}
-					i++;
-				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2026);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_2);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_4, min);
+	ZVAL_DOUBLE(&_5, max);
+	tensor_clip(&_2, &_3, &_4, &_5);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_2, &_6, &_7);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6269,125 +6376,44 @@ PHP_METHOD(Tensor_Matrix, clip)
  */
 PHP_METHOD(Tensor_Matrix, clipLower)
 {
-	zend_bool _13;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL, *_16 = NULL, *_19 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
-	zval *min_param = NULL, rowA, valueA, _0, _1, _2, *_3, _4, *_5, _12, _6$$3, _7$$4, _9$$5, _10$$5, _14$$6, _15$$7, _17$$8, _18$$8;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *min_param = NULL, _0, _1, _2, _3, _4;
 	double min;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_12);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_9$$5);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_14$$6);
-	ZVAL_UNDEF(&_15$$7);
-	ZVAL_UNDEF(&_17$$8);
-	ZVAL_UNDEF(&_18$$8);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
-	}
-
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_ZVAL(min_param)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 0, &min_param);
-	min = zephir_get_doubleval(min_param);
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2062);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _5);
-			i = 0;
-			while (1) {
-				zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-				if (!(ZEPHIR_GT_LONG(&_6$$3, i))) {
-					break;
-				}
-				ZVAL_LONG(&_7$$4, i);
-				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_8, 0, &_7$$4);
-				zephir_check_call_status();
-				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-					ZVAL_LONG(&_9$$5, i);
-					ZVAL_DOUBLE(&_10$$5, min);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_11, 0, &_9$$5, &_10$$5);
-					zephir_check_call_status();
-				}
-				i++;
-			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2059);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_13 = 1;
-		while (1) {
-			if (_13) {
-				_13 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_12, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_12)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				i = 0;
-				while (1) {
-					zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-					if (!(ZEPHIR_GT_LONG(&_14$$6, i))) {
-						break;
-					}
-					ZVAL_LONG(&_15$$7, i);
-					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_16, 0, &_15$$7);
-					zephir_check_call_status();
-					if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-						ZVAL_LONG(&_17$$8, i);
-						ZVAL_DOUBLE(&_18$$8, min);
-						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_19, 0, &_17$$8, &_18$$8);
-						zephir_check_call_status();
-					}
-					i++;
-				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2059);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_ZVAL(min_param)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &min_param);
+	min = zephir_get_doubleval(min_param);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_2, min);
+	tensor_clip_lower(&_0, &_1, &_2);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_3, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6400,38 +6426,28 @@ PHP_METHOD(Tensor_Matrix, clipLower)
  */
 PHP_METHOD(Tensor_Matrix, clipUpper)
 {
-	zend_bool _13;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL, *_16 = NULL, *_19 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
-	zval *max_param = NULL, rowA, valueA, _0, _1, _2, *_3, _4, *_5, _12, _6$$3, _7$$4, _9$$5, _10$$5, _14$$6, _15$$7, _17$$8, _18$$8;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *max_param = NULL, _0, _1, _2, _3, _4;
 	double max;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_12);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_9$$5);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_14$$6);
-	ZVAL_UNDEF(&_15$$7);
-	ZVAL_UNDEF(&_17$$8);
-	ZVAL_UNDEF(&_18$$8);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -6441,84 +6457,13 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &max_param);
 	max = zephir_get_doubleval(max_param);
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2095);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _5);
-			i = 0;
-			while (1) {
-				zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-				if (!(ZEPHIR_GT_LONG(&_6$$3, i))) {
-					break;
-				}
-				ZVAL_LONG(&_7$$4, i);
-				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_8, 0, &_7$$4);
-				zephir_check_call_status();
-				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-					ZVAL_LONG(&_9$$5, i);
-					ZVAL_DOUBLE(&_10$$5, max);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_11, 0, &_9$$5, &_10$$5);
-					zephir_check_call_status();
-				}
-				i++;
-			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2092);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_13 = 1;
-		while (1) {
-			if (_13) {
-				_13 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_12, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_12)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				i = 0;
-				while (1) {
-					zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-					if (!(ZEPHIR_GT_LONG(&_14$$6, i))) {
-						break;
-					}
-					ZVAL_LONG(&_15$$7, i);
-					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_16, 0, &_15$$7);
-					zephir_check_call_status();
-					if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-						ZVAL_LONG(&_17$$8, i);
-						ZVAL_DOUBLE(&_18$$8, max);
-						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_19, 0, &_17$$8, &_18$$8);
-						zephir_check_call_status();
-					}
-					i++;
-				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2092);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_2, max);
+	tensor_clip_upper(&_0, &_1, &_2);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_3, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6530,147 +6475,36 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
  */
 PHP_METHOD(Tensor_Matrix, sign)
 {
-	zend_bool _19;
-	zval b;
-	zval rowA, valueA, _0, _1, _2, *_3, _4, *_5, _18, _6$$3, _7$$4, _9$$5, _10$$5, _12$$6, _13$$6, _15$$7, _16$$7, _20$$8, _21$$9, _23$$10, _24$$10, _26$$11, _27$$11, _29$$12, _30$$12;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL, *_14 = NULL, *_17 = NULL, *_22 = NULL, *_25 = NULL, *_28 = NULL, *_31 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_9$$5);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_12$$6);
-	ZVAL_UNDEF(&_13$$6);
-	ZVAL_UNDEF(&_15$$7);
-	ZVAL_UNDEF(&_16$$7);
-	ZVAL_UNDEF(&_20$$8);
-	ZVAL_UNDEF(&_21$$9);
-	ZVAL_UNDEF(&_23$$10);
-	ZVAL_UNDEF(&_24$$10);
-	ZVAL_UNDEF(&_26$$11);
-	ZVAL_UNDEF(&_27$$11);
-	ZVAL_UNDEF(&_29$$12);
-	ZVAL_UNDEF(&_30$$12);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2131);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _5);
-			i = 0;
-			while (1) {
-				zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-				if (!(ZEPHIR_GT_LONG(&_6$$3, i))) {
-					break;
-				}
-				ZVAL_LONG(&_7$$4, i);
-				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_8, 0, &_7$$4);
-				zephir_check_call_status();
-				if (ZEPHIR_GT_LONG(&valueA, 0)) {
-					ZVAL_LONG(&_9$$5, i);
-					ZVAL_DOUBLE(&_10$$5, 1.0);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_11, 0, &_9$$5, &_10$$5);
-					zephir_check_call_status();
-				} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
-					ZVAL_LONG(&_12$$6, i);
-					ZVAL_DOUBLE(&_13$$6, -1.0);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_14, 0, &_12$$6, &_13$$6);
-					zephir_check_call_status();
-				} else {
-					ZVAL_LONG(&_15$$7, i);
-					ZVAL_DOUBLE(&_16$$7, 0.0);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_17, 0, &_15$$7, &_16$$7);
-					zephir_check_call_status();
-				}
-				i++;
-			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2128);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_19 = 1;
-		while (1) {
-			if (_19) {
-				_19 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_18, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_18)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				i = 0;
-				while (1) {
-					zephir_read_property_cached(&_20$$8, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-					if (!(ZEPHIR_GT_LONG(&_20$$8, i))) {
-						break;
-					}
-					ZVAL_LONG(&_21$$9, i);
-					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_22, 0, &_21$$9);
-					zephir_check_call_status();
-					if (ZEPHIR_GT_LONG(&valueA, 0)) {
-						ZVAL_LONG(&_23$$10, i);
-						ZVAL_DOUBLE(&_24$$10, 1.0);
-						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_25, 0, &_23$$10, &_24$$10);
-						zephir_check_call_status();
-					} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
-						ZVAL_LONG(&_26$$11, i);
-						ZVAL_DOUBLE(&_27$$11, -1.0);
-						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_28, 0, &_26$$11, &_27$$11);
-						zephir_check_call_status();
-					} else {
-						ZVAL_LONG(&_29$$12, i);
-						ZVAL_DOUBLE(&_30$$12, 0.0);
-						ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_31, 0, &_29$$12, &_30$$12);
-						zephir_check_call_status();
-					}
-					i++;
-				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2128);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_sign(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6682,111 +6516,36 @@ PHP_METHOD(Tensor_Matrix, sign)
  */
 PHP_METHOD(Tensor_Matrix, negate)
 {
-	zend_bool _11;
-	zval b;
-	zval rowA, valueA, _0, _1, _2, *_3, _4, *_5, _10, _6$$3, _7$$4, _12$$5, _13$$6;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_8 = NULL, *_9 = NULL, *_14 = NULL, *_15 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_12$$5);
-	ZVAL_UNDEF(&_13$$6);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 2161);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _5);
-			i = 0;
-			while (1) {
-				zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-				if (!(ZEPHIR_GT_LONG(&_6$$3, i))) {
-					break;
-				}
-				ZVAL_LONG(&_7$$4, i);
-				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_8, 0, &_7$$4);
-				zephir_check_call_status();
-				zephir_negate(&valueA);
-				ZVAL_LONG(&_7$$4, i);
-				ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_9, 0, &_7$$4, &valueA);
-				zephir_check_call_status();
-				i++;
-			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2158);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_11 = 1;
-		while (1) {
-			if (_11) {
-				_11 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_10, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_10)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				i = 0;
-				while (1) {
-					zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-					if (!(ZEPHIR_GT_LONG(&_12$$5, i))) {
-						break;
-					}
-					ZVAL_LONG(&_13$$6, i);
-					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_14, 0, &_13$$6);
-					zephir_check_call_status();
-					zephir_negate(&valueA);
-					ZVAL_LONG(&_13$$6, i);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_15, 0, &_13$$6, &valueA);
-					zephir_check_call_status();
-					i++;
-				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 2158);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	tensor_negate(&_0, &_1);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6865,7 +6624,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", 2176);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2042);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6962,7 +6721,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", 2196);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2062);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7066,7 +6825,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", 2216);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2082);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7109,7 +6868,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2230);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2096);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -7198,7 +6957,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", 2248);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2114);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7241,7 +7000,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2262);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2128);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -7319,7 +7078,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2286);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2152);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -7328,7 +7087,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2284);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2150);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -7351,14 +7110,14 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2284);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2150);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2289);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2155);
 		ZVAL_LONG(&_13$$6, 1);
 		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 28, &bigRows, &_13$$6);
 		zephir_check_call_status();
@@ -7444,7 +7203,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2312);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2178);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7519,7 +7278,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2331);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2197);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7594,7 +7353,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2350);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2216);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7669,7 +7428,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2369);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2235);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7745,7 +7504,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2389);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2255);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7821,7 +7580,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2409);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2275);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7897,7 +7656,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2429);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2295);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7972,7 +7731,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2448);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2314);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8048,7 +7807,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2468);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2334);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8124,7 +7883,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2488);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2354);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8199,7 +7958,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2507);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2373);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8274,7 +8033,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2526);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2392);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8359,7 +8118,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2546);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2412);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8392,7 +8151,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_multiply(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2556);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2422);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8470,7 +8229,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2574);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2440);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8503,7 +8262,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_divide(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2584);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2450);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8581,7 +8340,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2602);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2468);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8614,7 +8373,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_add(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2612);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2478);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8692,7 +8451,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2630);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2496);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8725,7 +8484,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_subtract(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2640);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2506);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8803,7 +8562,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2658);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2524);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8836,7 +8595,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_pow(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2668);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2534);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8914,7 +8673,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2686);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2552);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8947,7 +8706,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_mod(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2696);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2562);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9026,7 +8785,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2715);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2581);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9059,7 +8818,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2725);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2591);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9137,7 +8896,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2743);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2609);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9170,7 +8929,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_not_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2753);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2619);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9248,7 +9007,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2771);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2637);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9281,7 +9040,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2781);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2647);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9359,7 +9118,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2665);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9392,7 +9151,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2809);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2675);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9470,7 +9229,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2827);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2693);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9503,7 +9262,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2837);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2703);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9582,7 +9341,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2856);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2722);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9615,7 +9374,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2866);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2732);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9702,7 +9461,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2884);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2750);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9717,7 +9476,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2895);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2761);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -9738,7 +9497,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_multiply_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2892);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2758);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9769,7 +9528,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_multiply_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2892);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2758);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -9858,7 +9617,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2910);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2776);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9873,7 +9632,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2921);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2787);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -9894,7 +9653,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_divide_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2918);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2784);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -9925,7 +9684,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_divide_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2918);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2784);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10014,7 +9773,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2936);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2802);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10029,7 +9788,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2947);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2813);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10050,7 +9809,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_add_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2944);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2810);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10081,7 +9840,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_add_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2944);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2810);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10170,7 +9929,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2962);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2828);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10185,7 +9944,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2973);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2839);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10206,7 +9965,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_subtract_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2970);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2836);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10237,7 +9996,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_subtract_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2970);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2836);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10326,7 +10085,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2988);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2854);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10341,7 +10100,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2999);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2865);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10362,7 +10121,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_pow_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2996);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2862);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10393,7 +10152,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_pow_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2996);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2862);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10482,7 +10241,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3014);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2880);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10497,7 +10256,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3025);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2891);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10518,7 +10277,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_mod_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3022);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2888);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10549,7 +10308,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_mod_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3022);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2888);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10638,7 +10397,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3040);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2906);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10653,7 +10412,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3051);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2917);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10674,7 +10433,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3048);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2914);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10705,7 +10464,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3048);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2914);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10794,7 +10553,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3066);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2932);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10809,7 +10568,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3077);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2943);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10830,7 +10589,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_not_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3074);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2940);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -10861,7 +10620,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_not_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3074);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2940);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -10950,7 +10709,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3092);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2958);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10965,7 +10724,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3103);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2969);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -10986,7 +10745,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_greater_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3100);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2966);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11017,7 +10776,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_greater_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3100);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2966);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11106,7 +10865,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3118);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2984);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11121,7 +10880,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3129);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2995);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11142,7 +10901,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_greater_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3126);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2992);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11173,7 +10932,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_greater_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3126);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2992);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11262,7 +11021,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3144);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3010);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11277,7 +11036,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3155);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3021);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11298,7 +11057,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_less_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3152);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3018);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11329,7 +11088,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_less_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3152);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3018);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -11418,7 +11177,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3170);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3036);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11433,7 +11192,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3181);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3047);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
 		{
@@ -11454,7 +11213,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
 			zephir_check_call_status();
 			tensor_less_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3178);
+			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3044);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -11485,7 +11244,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
 				zephir_check_call_status();
 				tensor_less_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3178);
+				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3044);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueB);
@@ -12129,7 +11888,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3357);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3223);
 	return;
 }
 
@@ -12180,7 +11939,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3381);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3247);
 	return;
 }
 
@@ -12240,7 +11999,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3395);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3261);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -12257,7 +12016,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3400);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3266);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index 0caa2d2..b418f23 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -80,7 +80,7 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_0, a, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "asarray", NULL, 0);
 	zephir_check_call_status();
 	tensor_ref(&result, &_0);
 	if (Z_TYPE_P(&result) == IS_NULL) {
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index 74c2378..d1ef9f4 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -111,7 +111,7 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_3, &_2, "a", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_4, &_3, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, &_3, "asarray", NULL, 0);
 	zephir_check_call_status();
 	zephir_get_arrval(&_5, &_4);
 	ZEPHIR_CPY_WRT(&b, &_5);
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 72bb5d6..9916d35 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -26,6 +26,7 @@
 #include "include/buffer.h"
 #include "include/linear_algebra.h"
 #include "include/signal_processing.h"
+#include "include/unary.h"
 #include "include/arithmetic.h"
 #include "include/comparison.h"
 
@@ -2600,18 +2601,24 @@ PHP_METHOD(Tensor_Vector, reciprocal)
  */
 PHP_METHOD(Tensor_Vector, abs)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "abs");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_abs(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2641,18 +2648,24 @@ PHP_METHOD(Tensor_Vector, square)
  */
 PHP_METHOD(Tensor_Vector, sqrt)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "sqrt");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_sqrt(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2664,18 +2677,24 @@ PHP_METHOD(Tensor_Vector, sqrt)
  */
 PHP_METHOD(Tensor_Vector, exp)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "exp");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_exp(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2687,18 +2706,24 @@ PHP_METHOD(Tensor_Vector, exp)
  */
 PHP_METHOD(Tensor_Vector, expm1)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "expm1");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_expm1(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2711,26 +2736,21 @@ PHP_METHOD(Tensor_Vector, expm1)
  */
 PHP_METHOD(Tensor_Vector, log)
 {
-	zend_bool _9;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_7 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *base_param = NULL, _0$$3, valueA, a, _1, *_2, _3, *_4, _8, _5$$4, _6$$4, _10$$5, _11$$5;
+	zval *base_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4$$4, _5$$4, _6, _7, _8;
 	double base;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_3);
-	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4$$4);
 	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_6$$4);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_11$$5);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -2748,62 +2768,33 @@ PHP_METHOD(Tensor_Vector, log)
 	} else {
 		base = zephir_get_doubleval(base_param);
 	}
-	if (base == 2.7182818284590452354) {
+	if (UNEXPECTED(base <= 0.0)) {
 		ZEPHIR_INIT_VAR(&_0$$3);
-		ZVAL_STRING(&_0$$3, "log");
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0$$3);
+		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZVAL_DOUBLE(&_1$$3, base);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
 		zephir_check_call_status();
-		RETURN_MM();
-	}
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_1, "toArray", NULL, 0);
-	zephir_check_call_status();
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	if (Z_TYPE_P(&a) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_3);
-		zephir_string_to_char_array(&_3, &a);
-		_2 = &_3;
-	} else {
-		_2 = &a;
+		ZEPHIR_INIT_VAR(&_3$$3);
+		ZEPHIR_CONCAT_SSVS(&_3$$3, "Log base must be greater", " than 0, ", &_2$$3, " given.");
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1079);
+		ZEPHIR_MM_RESTORE();
+		return;
 	}
-	zephir_is_iterable(_2, 0, "tensor/vector.zep", 1091);
-	if (Z_TYPE_P(_2) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _4);
-			ZVAL_DOUBLE(&_5$$4, base);
-			ZEPHIR_CALL_FUNCTION(&_6$$4, "log", &_7, 8, &valueA, &_5$$4);
-			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/vector.zep", 1088);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
+	if (base == 2.7182818284590452354) {
+		ZEPHIR_INIT_VAR(&_4$$4);
+		zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+		tensor_log(&_4$$4, &_5$$4);
+		ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_4$$4);
 		zephir_check_call_status();
-		_9 = 1;
-		while (1) {
-			if (_9) {
-				_9 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _2, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_8, _2, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_8)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, _2, "current", NULL, 0);
-			zephir_check_call_status();
-				ZVAL_DOUBLE(&_10$$5, base);
-				ZEPHIR_CALL_FUNCTION(&_11$$5, "log", &_7, 8, &valueA, &_10$$5);
-				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/vector.zep", 1088);
-		}
+		RETURN_MM();
 	}
-	ZEPHIR_INIT_NVAR(&valueA);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_6);
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_8, base);
+	tensor_log_base(&_6, &_7, &_8);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2815,18 +2806,24 @@ PHP_METHOD(Tensor_Vector, log)
  */
 PHP_METHOD(Tensor_Vector, log1p)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "log1p");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_log1p(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2838,18 +2835,24 @@ PHP_METHOD(Tensor_Vector, log1p)
  */
 PHP_METHOD(Tensor_Vector, sin)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "sin");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_sin(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2861,18 +2864,24 @@ PHP_METHOD(Tensor_Vector, sin)
  */
 PHP_METHOD(Tensor_Vector, asin)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "asin");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_asin(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2884,18 +2893,24 @@ PHP_METHOD(Tensor_Vector, asin)
  */
 PHP_METHOD(Tensor_Vector, cos)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "cos");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_cos(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2907,18 +2922,24 @@ PHP_METHOD(Tensor_Vector, cos)
  */
 PHP_METHOD(Tensor_Vector, acos)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "acos");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_acos(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2930,18 +2951,24 @@ PHP_METHOD(Tensor_Vector, acos)
  */
 PHP_METHOD(Tensor_Vector, tan)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "tan");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_tan(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2953,18 +2980,24 @@ PHP_METHOD(Tensor_Vector, tan)
  */
 PHP_METHOD(Tensor_Vector, atan)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "atan");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_atan(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2976,18 +3009,24 @@ PHP_METHOD(Tensor_Vector, atan)
  */
 PHP_METHOD(Tensor_Vector, rad2deg)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "rad2deg");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_rad2deg(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2999,18 +3038,24 @@ PHP_METHOD(Tensor_Vector, rad2deg)
  */
 PHP_METHOD(Tensor_Vector, deg2rad)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "deg2rad");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_deg2rad(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3194,12 +3239,12 @@ PHP_METHOD(Tensor_Vector, median)
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
 		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1250);
+		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1245);
 	} else {
 		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1252);
+		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1247);
 		zephir_memory_observe(&_5$$4);
-		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1252);
+		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1247);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
 		ZEPHIR_INIT_NVAR(&median);
@@ -3266,7 +3311,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1269);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1264);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3284,15 +3329,15 @@ PHP_METHOD(Tensor_Vector, quantile)
 	if (ZEPHIR_LE_LONG(&_7, xHat)) {
 		zephir_memory_observe(&_8$$4);
 		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1281);
+		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1276);
 		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
 	}
 	remainder =  ((x -  (double) xHat));
 	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1286);
+	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1281);
 	t =  (zephir_get_doubleval(&_10));
 	zephir_memory_observe(&_11);
-	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1288);
+	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1283);
 	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
 }
 
@@ -3351,7 +3396,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1303);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1298);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3379,28 +3424,18 @@ PHP_METHOD(Tensor_Vector, variance)
  */
 PHP_METHOD(Tensor_Vector, round)
 {
-	zend_bool _12;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *precision_param = NULL, _0$$3, _1$$4, _2$$4, _3$$4, _4$$4, valueA, a, _5, *_6, _7, *_8, _11, _9$$5, _10$$5, _13$$6, _14$$6;
+	zval *precision_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4, _5, _6;
 	zend_long precision, ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&_1$$4);
-	ZVAL_UNDEF(&_2$$4);
-	ZVAL_UNDEF(&_3$$4);
-	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&a);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_9$$5);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_13$$6);
-	ZVAL_UNDEF(&_14$$6);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_6);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3417,76 +3452,25 @@ PHP_METHOD(Tensor_Vector, round)
 		precision = 0;
 	} else {
 		}
-	if (precision == 0) {
-		ZEPHIR_INIT_VAR(&_0$$3);
-		ZVAL_STRING(&_0$$3, "round");
-		ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0$$3);
-		zephir_check_call_status();
-		RETURN_MM();
-	}
 	if (UNEXPECTED(precision < 0)) {
-		ZEPHIR_INIT_VAR(&_1$$4);
-		object_init_ex(&_1$$4, tensor_exceptions_invalidargumentexception_ce);
-		ZVAL_LONG(&_2$$4, precision);
-		ZEPHIR_CALL_FUNCTION(&_3$$4, "strval", NULL, 4, &_2$$4);
+		ZEPHIR_INIT_VAR(&_0$$3);
+		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZVAL_LONG(&_1$$3, precision);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
 		zephir_check_call_status();
-		ZEPHIR_INIT_VAR(&_4$$4);
-		ZEPHIR_CONCAT_SSVS(&_4$$4, "Decimal precision cannot", " be less than 0, ", &_3$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_4$$4);
+		ZEPHIR_INIT_VAR(&_3$$3);
+		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1331);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1322);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
+	ZEPHIR_INIT_VAR(&_4);
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_5, "toArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&a) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_7);
-		zephir_string_to_char_array(&_7, &a);
-		_6 = &_7;
-	} else {
-		_6 = &a;
-	}
-	zephir_is_iterable(_6, 0, "tensor/vector.zep", 1344);
-	if (Z_TYPE_P(_6) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _8);
-			ZEPHIR_INIT_NVAR(&_9$$5);
-			ZVAL_LONG(&_10$$5, precision);
-			zephir_round(&_9$$5, &valueA, &_10$$5, NULL);
-			zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/vector.zep", 1341);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_12 = 1;
-		while (1) {
-			if (_12) {
-				_12 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _6, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_11, _6, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_11)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, _6, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_13$$6);
-				ZVAL_LONG(&_14$$6, precision);
-				zephir_round(&_13$$6, &valueA, &_14$$6, NULL);
-				zephir_array_append(&b, &_13$$6, PH_SEPARATE, "tensor/vector.zep", 1341);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueA);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &b);
+	ZVAL_LONG(&_6, precision);
+	tensor_round(&_4, &_5, &_6);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3498,18 +3482,24 @@ PHP_METHOD(Tensor_Vector, round)
  */
 PHP_METHOD(Tensor_Vector, floor)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "floor");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_floor(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3521,18 +3511,24 @@ PHP_METHOD(Tensor_Vector, floor)
  */
 PHP_METHOD(Tensor_Vector, ceil)
 {
-	zval _0;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	ZEPHIR_INIT_VAR(&_0);
-	ZVAL_STRING(&_0, "ceil");
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "map", NULL, 0, &_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_ceil(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3548,27 +3544,19 @@ PHP_METHOD(Tensor_Vector, ceil)
  */
 PHP_METHOD(Tensor_Vector, clip)
 {
-	zend_bool _9;
-	zval b;
 	zval _1$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *min_param = NULL, *max_param = NULL, _0$$3, valueA, a, _2, *_3, _4, *_5, _8, _6$$5, _7$$6, _10$$8, _11$$9;
+	zval *min_param = NULL, *max_param = NULL, _0$$3, _2, _3, _4, _5;
 	double min, max;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_6$$5);
-	ZVAL_UNDEF(&_7$$6);
-	ZVAL_UNDEF(&_10$$8);
-	ZVAL_UNDEF(&_11$$9);
+	ZVAL_UNDEF(&_5);
 	ZVAL_UNDEF(&_1$$3);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3590,77 +3578,16 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1380);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1361);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_2, "toArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&a) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &a);
-		_3 = &_4;
-	} else {
-		_3 = &a;
-	}
-	zephir_is_iterable(_3, 0, "tensor/vector.zep", 1405);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _5);
-			if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-				ZEPHIR_INIT_NVAR(&_6$$5);
-				ZVAL_DOUBLE(&_6$$5, max);
-				zephir_array_append(&b, &_6$$5, PH_SEPARATE, "tensor/vector.zep", 1391);
-				continue;
-			}
-			if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-				ZEPHIR_INIT_NVAR(&_7$$6);
-				ZVAL_DOUBLE(&_7$$6, min);
-				zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1397);
-				continue;
-			}
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1402);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_9 = 1;
-		while (1) {
-			if (_9) {
-				_9 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_8, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_8)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-					ZEPHIR_INIT_NVAR(&_10$$8);
-					ZVAL_DOUBLE(&_10$$8, max);
-					zephir_array_append(&b, &_10$$8, PH_SEPARATE, "tensor/vector.zep", 1391);
-					continue;
-				}
-				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-					ZEPHIR_INIT_NVAR(&_11$$9);
-					ZVAL_DOUBLE(&_11$$9, min);
-					zephir_array_append(&b, &_11$$9, PH_SEPARATE, "tensor/vector.zep", 1397);
-					continue;
-				}
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1402);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueA);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_2);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_4, min);
+	ZVAL_DOUBLE(&_5, max);
+	tensor_clip(&_2, &_3, &_4, &_5);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3673,22 +3600,15 @@ PHP_METHOD(Tensor_Vector, clip)
  */
 PHP_METHOD(Tensor_Vector, clipLower)
 {
-	zend_bool _6;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *min_param = NULL, valueA, a, _0, *_1, _2, *_3, _5, _4$$4, _7$$6;
+	zval *min_param = NULL, _0, _1, _2;
 	double min;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&_7$$6);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3701,61 +3621,11 @@ PHP_METHOD(Tensor_Vector, clipLower)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &min_param);
 	min = zephir_get_doubleval(min_param);
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&a) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &a);
-		_1 = &_2;
-	} else {
-		_1 = &a;
-	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1432);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _3);
-			if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-				ZEPHIR_INIT_NVAR(&_4$$4);
-				ZVAL_DOUBLE(&_4$$4, min);
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1424);
-				continue;
-			}
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1429);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_6 = 1;
-		while (1) {
-			if (_6) {
-				_6 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_5, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_5)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				if (ZEPHIR_LT_DOUBLE(&valueA, min)) {
-					ZEPHIR_INIT_NVAR(&_7$$6);
-					ZVAL_DOUBLE(&_7$$6, min);
-					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1424);
-					continue;
-				}
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1429);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueA);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_2, min);
+	tensor_clip_lower(&_0, &_1, &_2);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3768,22 +3638,15 @@ PHP_METHOD(Tensor_Vector, clipLower)
  */
 PHP_METHOD(Tensor_Vector, clipUpper)
 {
-	zend_bool _6;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *max_param = NULL, valueA, a, _0, *_1, _2, *_3, _5, _4$$4, _7$$6;
+	zval *max_param = NULL, _0, _1, _2;
 	double max;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&_7$$6);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3796,61 +3659,11 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &max_param);
 	max = zephir_get_doubleval(max_param);
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&a) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &a);
-		_1 = &_2;
-	} else {
-		_1 = &a;
-	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1459);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _3);
-			if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-				ZEPHIR_INIT_NVAR(&_4$$4);
-				ZVAL_DOUBLE(&_4$$4, max);
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1451);
-				continue;
-			}
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1456);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_6 = 1;
-		while (1) {
-			if (_6) {
-				_6 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_5, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_5)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				if (ZEPHIR_GT_DOUBLE(&valueA, max)) {
-					ZEPHIR_INIT_NVAR(&_7$$6);
-					ZVAL_DOUBLE(&_7$$6, max);
-					zephir_array_append(&b, &_7$$6, PH_SEPARATE, "tensor/vector.zep", 1451);
-					continue;
-				}
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1456);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueA);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_2, max);
+	tensor_clip_upper(&_0, &_1, &_2);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3862,25 +3675,13 @@ PHP_METHOD(Tensor_Vector, clipUpper)
  */
 PHP_METHOD(Tensor_Vector, sign)
 {
-	zend_bool _8;
-	zval b;
-	zval valueA, a, _0, *_1, _2, *_3, _7, _4$$4, _5$$5, _6$$6, _9$$8, _10$$9, _11$$10;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&_5$$5);
-	ZVAL_UNDEF(&_6$$6);
-	ZVAL_UNDEF(&_9$$8);
-	ZVAL_UNDEF(&_10$$9);
-	ZVAL_UNDEF(&_11$$10);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3888,73 +3689,10 @@ PHP_METHOD(Tensor_Vector, sign)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&a) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &a);
-		_1 = &_2;
-	} else {
-		_1 = &a;
-	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1485);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _3);
-			if (ZEPHIR_GT_LONG(&valueA, 0)) {
-				ZEPHIR_INIT_NVAR(&_4$$4);
-				ZVAL_DOUBLE(&_4$$4, 1.0);
-				zephir_array_append(&b, &_4$$4, PH_SEPARATE, "tensor/vector.zep", 1477);
-			} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
-				ZEPHIR_INIT_NVAR(&_5$$5);
-				ZVAL_DOUBLE(&_5$$5, -1.0);
-				zephir_array_append(&b, &_5$$5, PH_SEPARATE, "tensor/vector.zep", 1479);
-			} else {
-				ZEPHIR_INIT_NVAR(&_6$$6);
-				ZVAL_DOUBLE(&_6$$6, 0.0);
-				zephir_array_append(&b, &_6$$6, PH_SEPARATE, "tensor/vector.zep", 1481);
-			}
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_8 = 1;
-		while (1) {
-			if (_8) {
-				_8 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_7, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_7)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				if (ZEPHIR_GT_LONG(&valueA, 0)) {
-					ZEPHIR_INIT_NVAR(&_9$$8);
-					ZVAL_DOUBLE(&_9$$8, 1.0);
-					zephir_array_append(&b, &_9$$8, PH_SEPARATE, "tensor/vector.zep", 1477);
-				} else if (ZEPHIR_LT_LONG(&valueA, 0)) {
-					ZEPHIR_INIT_NVAR(&_10$$9);
-					ZVAL_DOUBLE(&_10$$9, -1.0);
-					zephir_array_append(&b, &_10$$9, PH_SEPARATE, "tensor/vector.zep", 1479);
-				} else {
-					ZEPHIR_INIT_NVAR(&_11$$10);
-					ZVAL_DOUBLE(&_11$$10, 0.0);
-					zephir_array_append(&b, &_11$$10, PH_SEPARATE, "tensor/vector.zep", 1481);
-				}
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueA);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_sign(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3966,19 +3704,13 @@ PHP_METHOD(Tensor_Vector, sign)
  */
 PHP_METHOD(Tensor_Vector, negate)
 {
-	zend_bool _5;
-	zval b;
-	zval valueA, a, _0, *_1, _2, *_3, _4;
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -3986,51 +3718,10 @@ PHP_METHOD(Tensor_Vector, negate)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&a) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &a);
-		_1 = &_2;
-	} else {
-		_1 = &a;
-	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 1505);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _3);
-			zephir_negate(&valueA);
-			zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1502);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_5 = 1;
-		while (1) {
-			if (_5) {
-				_5 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_4, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_4)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_negate(&valueA);
-				zephir_array_append(&b, &valueA, PH_SEPARATE, "tensor/vector.zep", 1502);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueA);
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &b);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_negate(&_0, &_1);
+	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4101,7 +3792,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1520);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1421);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4116,7 +3807,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1531);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1432);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4125,7 +3816,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1528);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1429);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4148,7 +3839,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1528);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1429);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4223,7 +3914,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1546);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1447);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4238,7 +3929,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1557);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1458);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4247,7 +3938,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1554);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1455);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4270,7 +3961,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1554);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1455);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4345,7 +4036,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1572);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1473);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4360,7 +4051,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1583);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1484);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4369,7 +4060,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1580);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1481);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4392,7 +4083,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1580);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1481);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4467,7 +4158,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1598);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1499);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4482,7 +4173,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1609);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1510);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4491,7 +4182,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1606);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1507);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4514,7 +4205,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1606);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1507);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4589,7 +4280,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1624);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1525);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4604,7 +4295,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1635);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1536);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4613,7 +4304,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1632);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1533);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4636,7 +4327,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1632);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1533);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4711,7 +4402,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1650);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1551);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4726,7 +4417,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1661);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1562);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4735,7 +4426,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1658);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1559);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4758,7 +4449,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1658);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1559);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4833,7 +4524,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1676);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1577);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4848,7 +4539,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1687);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1588);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4857,7 +4548,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1684);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1585);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4880,7 +4571,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1684);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1585);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4955,7 +4646,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1702);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1603);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4970,7 +4661,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1713);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1614);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4979,7 +4670,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1710);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1611);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5002,7 +4693,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1710);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1611);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5077,7 +4768,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1728);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1629);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5092,7 +4783,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1739);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1640);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5101,7 +4792,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1736);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1637);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5124,7 +4815,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1736);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1637);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5199,7 +4890,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1754);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1655);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5214,7 +4905,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1765);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1666);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5223,7 +4914,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1762);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1663);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5246,7 +4937,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1762);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1663);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5321,7 +5012,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1780);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1681);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5336,7 +5027,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1791);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1692);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5345,7 +5036,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1788);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1689);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5368,7 +5059,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1788);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1689);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5443,7 +5134,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1806);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1707);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5458,7 +5149,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1817);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1718);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5467,7 +5158,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1814);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1715);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5490,7 +5181,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1814);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1715);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5557,7 +5248,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1832);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1733);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5628,7 +5319,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1850);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1751);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5699,7 +5390,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1868);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1769);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5770,7 +5461,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1886);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1787);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5841,7 +5532,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1904);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1805);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5912,7 +5603,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1922);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1823);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5984,7 +5675,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1941);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1842);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6055,7 +5746,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1959);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1860);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6126,7 +5817,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1977);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1878);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6197,7 +5888,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1995);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1896);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6268,7 +5959,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 2013);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1914);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6339,7 +6030,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 2031);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1932);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6837,7 +6528,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2188);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2089);
 	return;
 }
 
@@ -6888,7 +6579,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2212);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2113);
 	return;
 }
 
@@ -6946,7 +6637,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 3, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2226);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2127);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/optimizers/TensorAbsOptimizer.php b/optimizers/TensorAbsOptimizer.php
new file mode 100644
index 0000000..c1fd2ab
--- /dev/null
+++ b/optimizers/TensorAbsOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorAbsOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor abs accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_abs($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorAcosOptimizer.php b/optimizers/TensorAcosOptimizer.php
new file mode 100644
index 0000000..94bcaa4
--- /dev/null
+++ b/optimizers/TensorAcosOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorAcosOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor acos accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_acos($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorAsinOptimizer.php b/optimizers/TensorAsinOptimizer.php
new file mode 100644
index 0000000..550e7de
--- /dev/null
+++ b/optimizers/TensorAsinOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorAsinOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor asin accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_asin($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorAtanOptimizer.php b/optimizers/TensorAtanOptimizer.php
new file mode 100644
index 0000000..4beccfb
--- /dev/null
+++ b/optimizers/TensorAtanOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorAtanOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor atan accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_atan($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorCeilOptimizer.php b/optimizers/TensorCeilOptimizer.php
new file mode 100644
index 0000000..5cd859b
--- /dev/null
+++ b/optimizers/TensorCeilOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorCeilOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor ceil accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_ceil($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorClipLowerOptimizer.php b/optimizers/TensorClipLowerOptimizer.php
new file mode 100644
index 0000000..6effc03
--- /dev/null
+++ b/optimizers/TensorClipLowerOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorClipLowerOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor clip lower accepts exactly 2 arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_clip_lower($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorClipOptimizer.php b/optimizers/TensorClipOptimizer.php
new file mode 100644
index 0000000..68e5283
--- /dev/null
+++ b/optimizers/TensorClipOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorClipOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor clip accepts exactly 3 arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_clip($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorClipUpperOptimizer.php b/optimizers/TensorClipUpperOptimizer.php
new file mode 100644
index 0000000..fae1caa
--- /dev/null
+++ b/optimizers/TensorClipUpperOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorClipUpperOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor clip upper accepts exactly 2 arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_clip_upper($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorCosOptimizer.php b/optimizers/TensorCosOptimizer.php
new file mode 100644
index 0000000..4eee563
--- /dev/null
+++ b/optimizers/TensorCosOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorCosOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor cos accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_cos($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorDeg2radOptimizer.php b/optimizers/TensorDeg2radOptimizer.php
new file mode 100644
index 0000000..6eae1ef
--- /dev/null
+++ b/optimizers/TensorDeg2radOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorDeg2radOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor deg2rad accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_deg2rad($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorExpOptimizer.php b/optimizers/TensorExpOptimizer.php
new file mode 100644
index 0000000..de3e7d7
--- /dev/null
+++ b/optimizers/TensorExpOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorExpOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor exp accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_exp($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorExpm1Optimizer.php b/optimizers/TensorExpm1Optimizer.php
new file mode 100644
index 0000000..c3e26d5
--- /dev/null
+++ b/optimizers/TensorExpm1Optimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorExpm1Optimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor expm1 accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_expm1($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorFloorOptimizer.php b/optimizers/TensorFloorOptimizer.php
new file mode 100644
index 0000000..53307e5
--- /dev/null
+++ b/optimizers/TensorFloorOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorFloorOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor floor accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_floor($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLog1pOptimizer.php b/optimizers/TensorLog1pOptimizer.php
new file mode 100644
index 0000000..a8dfa8d
--- /dev/null
+++ b/optimizers/TensorLog1pOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLog1pOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor log1p accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_log1p($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLogBaseOptimizer.php b/optimizers/TensorLogBaseOptimizer.php
new file mode 100644
index 0000000..ce150bd
--- /dev/null
+++ b/optimizers/TensorLogBaseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLogBaseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor log base accepts exactly 2 arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_log_base($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLogOptimizer.php b/optimizers/TensorLogOptimizer.php
new file mode 100644
index 0000000..4377415
--- /dev/null
+++ b/optimizers/TensorLogOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLogOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor log accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_log($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorNegateOptimizer.php b/optimizers/TensorNegateOptimizer.php
new file mode 100644
index 0000000..a9b92b8
--- /dev/null
+++ b/optimizers/TensorNegateOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorNegateOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor negate accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_negate($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorRad2degOptimizer.php b/optimizers/TensorRad2degOptimizer.php
new file mode 100644
index 0000000..5eb8c0f
--- /dev/null
+++ b/optimizers/TensorRad2degOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorRad2degOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor rad2deg accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_rad2deg($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorRoundOptimizer.php b/optimizers/TensorRoundOptimizer.php
new file mode 100644
index 0000000..d2c2e22
--- /dev/null
+++ b/optimizers/TensorRoundOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorRoundOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor round accepts exactly 2 arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_round($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorSignOptimizer.php b/optimizers/TensorSignOptimizer.php
new file mode 100644
index 0000000..852c3ba
--- /dev/null
+++ b/optimizers/TensorSignOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorSignOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor sign accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_sign($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorSinOptimizer.php b/optimizers/TensorSinOptimizer.php
new file mode 100644
index 0000000..ec3f2e3
--- /dev/null
+++ b/optimizers/TensorSinOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorSinOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor sin accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_sin($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorSqrtOptimizer.php b/optimizers/TensorSqrtOptimizer.php
new file mode 100644
index 0000000..7c161a6
--- /dev/null
+++ b/optimizers/TensorSqrtOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorSqrtOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor sqrt accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_sqrt($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorTanOptimizer.php b/optimizers/TensorTanOptimizer.php
new file mode 100644
index 0000000..db24ab1
--- /dev/null
+++ b/optimizers/TensorTanOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorTanOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor tan accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_tan($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 68de06e..08d2980 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -49,7 +49,7 @@ class Matrix implements Tensor
      * @param array[] a
      * @return self
      */
-public static function build(const array a = []) -> <Matrix>
+    public static function build(const array a = []) -> <Matrix>
     {
         return new self(a, 0, 0, true);
     }
@@ -1539,7 +1539,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function abs() -> <Matrix>
     {
-        return this->map("abs");
+        return self::fromTensorBuffer(tensor_abs(this->a), this->m, this->n);
     }
 
     /**
@@ -1559,9 +1559,9 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function sqrt() -> <Matrix>
     {
-        return this->map("sqrt");
+        return self::fromTensorBuffer(tensor_sqrt(this->a), this->m, this->n);
     }
- 
+
     /**
      * Return the exponential of the matrix.
      *
@@ -1569,7 +1569,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function exp() -> <Matrix>
     {
-        return this->map("exp");
+        return self::fromTensorBuffer(tensor_exp(this->a), this->m, this->n);
     }
 
     /**
@@ -1579,7 +1579,7 @@ public static function build(const array a = []) -> <Matrix>
     */
     public function expm1() -> <Matrix>
     {
-        return this->map("expm1");
+        return self::fromTensorBuffer(tensor_expm1(this->a), this->m, this->n);
     }
 
     /**
@@ -1591,30 +1591,12 @@ public static function build(const array a = []) -> <Matrix>
     public function log(const float base = self::M_E) -> <Matrix>
     {
         if base === self::M_E {
-            return this->map("log");
+            return self::fromTensorBuffer(tensor_log(this->a), this->m, this->n);
         }
 
-        var rowA, valueA;
-
-        int i;
-
-        array b = [];
- 
-        for rowA in this->a->split(this->n) {
-            let i = 0;
-
-            while i < this->n {
-                let valueA = rowA->get(i);
-
-                rowA->set(i, log(valueA, base));
-
-                let i++;
-            }
- 
-            let b[] = rowA;
-        }
- 
-        return self::quick(b);
+        return self::fromTensorBuffer(
+            tensor_log_base(this->a, (double) base), this->m, this->n
+        );
     }
 
     /**
@@ -1624,7 +1606,7 @@ public static function build(const array a = []) -> <Matrix>
     */
     public function log1p() -> <Matrix>
     {
-        return this->map("log1p");
+        return self::fromTensorBuffer(tensor_log1p(this->a), this->m, this->n);
     }
  
     /**
@@ -1634,7 +1616,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function sin() -> <Matrix>
     {
-        return this->map("sin");
+        return self::fromTensorBuffer(tensor_sin(this->a), this->m, this->n);
     }
 
     /**
@@ -1644,7 +1626,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function asin() -> <Matrix>
     {
-        return this->map("asin");
+        return self::fromTensorBuffer(tensor_asin(this->a), this->m, this->n);
     }
  
     /**
@@ -1654,7 +1636,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function cos() -> <Matrix>
     {
-        return this->map("cos");
+        return self::fromTensorBuffer(tensor_cos(this->a), this->m, this->n);
     }
 
     /**
@@ -1664,7 +1646,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function acos() -> <Matrix>
     {
-        return this->map("acos");
+        return self::fromTensorBuffer(tensor_acos(this->a), this->m, this->n);
     }
  
     /**
@@ -1674,7 +1656,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function tan() -> <Matrix>
     {
-        return this->map("tan");
+        return self::fromTensorBuffer(tensor_tan(this->a), this->m, this->n);
     }
 
     /**
@@ -1684,7 +1666,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function atan() -> <Matrix>
     {
-        return this->map("atan");
+        return self::fromTensorBuffer(tensor_atan(this->a), this->m, this->n);
     }
  
     /**
@@ -1694,7 +1676,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function rad2deg() -> <Matrix>
     {
-        return this->map("rad2deg");
+        return self::fromTensorBuffer(tensor_rad2deg(this->a), this->m, this->n);
     }
  
     /**
@@ -1704,7 +1686,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function deg2rad() -> <Matrix>
     {
-      return this->map("deg2rad");
+        return self::fromTensorBuffer(tensor_deg2rad(this->a), this->m, this->n);
     }
 
     /**
@@ -1925,7 +1907,9 @@ public static function build(const array a = []) -> <Matrix>
     public function round(const int precision = 0) -> <Matrix>
     {
         if precision === 0 {
-            return this->map("round");
+            return self::fromTensorBuffer(
+                tensor_round(this->a, 0), this->m, this->n
+            );
         }
 
         if unlikely precision < 0 {
@@ -1963,7 +1947,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function floor() -> <Matrix>
     {
-        return this->map("floor");
+        return self::fromTensorBuffer(tensor_floor(this->a), this->m, this->n);
     }
 
     /**
@@ -1973,7 +1957,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function ceil() -> <Matrix>
     {
-        return this->map("ceil");
+        return self::fromTensorBuffer(tensor_ceil(this->a), this->m, this->n);
     }
 
     /**
@@ -1992,41 +1976,9 @@ public static function build(const array a = []) -> <Matrix>
                 . " greater than maximum.");
         }
 
-        var rowA, valueA;
-
-        int i;
-
-        array b = [];
-
-        for rowA in this->a->split(this->n) {
-            let i = 0;
-
-            while i < this->n {
-                let valueA = rowA->get(i);
-
-                if valueA > max {
-                    rowA->set(i, max);
-
-                    let i++;
-
-                    continue;
-                }
-
-                if valueA < min {
-                    rowA->set(i, min);
-
-                    let i++;
-
-                    continue;
-                }
-
-                let i++;
-            }
-
-            let b[] = rowA;
-        }
-
-        return self::quick(b);
+        return self::fromTensorBuffer(
+            tensor_clip(this->a, (double) min, (double) max), this->m, this->n
+        );
     }
 
     /**
@@ -2037,29 +1989,9 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function clipLower(const float min) -> <Matrix>
     {
-        var rowA, valueA;
-
-        int i;
-
-        array b = [];
-
-        for rowA in this->a->split(this->n) {
-            let i = 0;
-
-            while i < this->n {
-                let valueA = rowA->get(i);
-
-                if valueA < min {
-                    rowA->set(i, min);
-                }
-
-                let i++;
-            }
-
-            let b[] = rowA;
-        }
-
-        return self::quick(b);
+        return self::fromTensorBuffer(
+            tensor_clip_lower(this->a, (double) min), this->m, this->n
+        );
     }
 
     /**
@@ -2070,29 +2002,9 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function clipUpper(const float max) -> <Matrix>
     {
-        var rowA, valueA;
-
-        int i;
-
-        array b = [];
-
-        for rowA in this->a->split(this->n) {
-            let i = 0;
-
-            while i < this->n {
-                let valueA = rowA->get(i);
-
-                if valueA > max {
-                    rowA->set(i, max);
-                }
-
-                let i++;
-            }
-
-            let b[] = rowA;
-        }
-
-        return self::quick(b);
+        return self::fromTensorBuffer(
+            tensor_clip_upper(this->a, (double) max), this->m, this->n
+        );
     }
 
     /**
@@ -2102,33 +2014,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function sign() -> <Matrix>
     {
-        var rowA, valueA;
-
-        int i;
-
-        array b = [];
-
-        for rowA in this->a->split(this->n) {
-            let i = 0;
-
-            while i < this->n {
-                let valueA = rowA->get(i);
-
-                if valueA > 0 {
-                    rowA->set(i, 1.0);
-                } elseif valueA < 0 {
-                    rowA->set(i, -1.0);
-                } else {
-                    rowA->set(i, 0.0);
-                }
-
-                let i++;
-            }
-
-            let b[] = rowA;
-        }
-
-        return self::quick(b);
+        return self::fromTensorBuffer(tensor_sign(this->a), this->m, this->n);
     }
 
     /**
@@ -2138,27 +2024,7 @@ public static function build(const array a = []) -> <Matrix>
      */
     public function negate() -> <Matrix>
     {
-        var rowA, valueA;
-
-        int i;
-
-        array b = [];
-
-        for rowA in this->a->split(this->n) {
-            let i = 0;
-
-            while i < this->n {
-                let valueA = rowA->get(i);
-
-                rowA->set(i, -valueA);
-
-                let i++;
-            }
-
-            let b[] = rowA;
-        }
-
-        return self::quick(b);
+        return self::fromTensorBuffer(tensor_negate(this->a), this->m, this->n);
     }
 
     /**
diff --git a/tensor/vector.zep b/tensor/vector.zep
index b31923e..7142282 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -1023,7 +1023,7 @@ class Vector implements Tensor
      */
     public function abs() -> <Vector>
     {
-        return this->map("abs");
+        return static::fromTensorBuffer(tensor_abs(this->a));
     }
 
     /**
@@ -1043,7 +1043,7 @@ class Vector implements Tensor
      */
     public function sqrt() -> <Vector>
     {
-        return this->map("sqrt");
+        return static::fromTensorBuffer(tensor_sqrt(this->a));
     }
 
     /**
@@ -1053,7 +1053,7 @@ class Vector implements Tensor
      */
     public function exp() -> <Vector>
     {
-        return this->map("exp");
+        return static::fromTensorBuffer(tensor_exp(this->a));
     }
 
     /**
@@ -1063,7 +1063,7 @@ class Vector implements Tensor
     */
     public function expm1() -> <Vector>
     {
-        return this->map("expm1");
+        return static::fromTensorBuffer(tensor_expm1(this->a));
     }
 
     /**
@@ -1074,21 +1074,16 @@ class Vector implements Tensor
      */
     public function log(const float base = self::M_E) -> <Vector>
     {
-        if base === self::M_E {
-            return this->map("log");
+        if unlikely base <= 0.0 {
+            throw new InvalidArgumentException("Log base must be greater"
+                . " than 0, " . strval(base) . " given.");
         }
 
-        var valueA;
-
-        var a = this->a->toArray();
-
-        array b = [];
-
-        for valueA in a {
-            let b[] = log(valueA, base);
+        if base === self::M_E {
+            return static::fromTensorBuffer(tensor_log(this->a));
         }
 
-        return static::quick(b);
+        return static::fromTensorBuffer(tensor_log_base(this->a, (double) base));
     }
 
     /**
@@ -1098,7 +1093,7 @@ class Vector implements Tensor
     */
     public function log1p() -> <Vector>
     {
-        return this->map("log1p");
+        return static::fromTensorBuffer(tensor_log1p(this->a));
     }
 
     /**
@@ -1108,7 +1103,7 @@ class Vector implements Tensor
      */
     public function sin() -> <Vector>
     {
-        return this->map("sin");
+        return static::fromTensorBuffer(tensor_sin(this->a));
     }
 
     /**
@@ -1118,7 +1113,7 @@ class Vector implements Tensor
      */
     public function asin() -> <Vector>
     {
-        return this->map("asin");
+        return static::fromTensorBuffer(tensor_asin(this->a));
     }
 
     /**
@@ -1128,7 +1123,7 @@ class Vector implements Tensor
      */
     public function cos() -> <Vector>
     {
-        return this->map("cos");
+        return static::fromTensorBuffer(tensor_cos(this->a));
     }
 
     /**
@@ -1138,7 +1133,7 @@ class Vector implements Tensor
      */
     public function acos() -> <Vector>
     {
-        return this->map("acos");
+        return static::fromTensorBuffer(tensor_acos(this->a));
     }
 
     /**
@@ -1148,7 +1143,7 @@ class Vector implements Tensor
      */
     public function tan() -> <Vector>
     {
-        return this->map("tan");
+        return static::fromTensorBuffer(tensor_tan(this->a));
     }
 
     /**
@@ -1158,7 +1153,7 @@ class Vector implements Tensor
      */
     public function atan() -> <Vector>
     {
-        return this->map("atan");
+        return static::fromTensorBuffer(tensor_atan(this->a));
     }
 
     /**
@@ -1168,7 +1163,7 @@ class Vector implements Tensor
      */
     public function rad2deg() -> <Vector>
     {
-        return this->map("rad2deg");
+        return static::fromTensorBuffer(tensor_rad2deg(this->a));
     }
 
     /**
@@ -1178,7 +1173,7 @@ class Vector implements Tensor
      */
     public function deg2rad() -> <Vector>
     {
-        return this->map("deg2rad");
+        return static::fromTensorBuffer(tensor_deg2rad(this->a));
     }
 
     /**
@@ -1322,26 +1317,12 @@ class Vector implements Tensor
      */
     public function round(const int precision = 0) -> <Vector>
     {
-        if precision === 0 {
-            return this->map("round");
-        }
-
         if unlikely precision < 0 {
             throw new InvalidArgumentException("Decimal precision cannot"
                 . " be less than 0, " . strval(precision)  . " given.");
         }
 
-        var valueA;
-
-        array b = [];
-
-        var a = this->a->toArray();
-
-        for valueA in a {
-            let b[] = round(valueA, precision);
-        }
-
-        return static::quick(b);
+        return static::fromTensorBuffer(tensor_round(this->a, (int) precision));
     }
 
     /**
@@ -1351,7 +1332,7 @@ class Vector implements Tensor
      */
     public function floor() -> <Vector>
     {
-        return this->map("floor");
+        return static::fromTensorBuffer(tensor_floor(this->a));
     }
 
     /**
@@ -1361,7 +1342,7 @@ class Vector implements Tensor
      */
     public function ceil() -> <Vector>
     {
-        return this->map("ceil");
+        return static::fromTensorBuffer(tensor_ceil(this->a));
     }
 
     /**
@@ -1380,29 +1361,7 @@ class Vector implements Tensor
                 . " greater than maximum.");
         }
 
-        var valueA;
-
-        array b = [];
-
-        var a = this->a->toArray();
-
-        for valueA in a {
-            if valueA > max {
-                let b[] = max;
-
-                continue;
-            }
-
-            if valueA < min {
-                let b[] = min;
-
-                continue;
-            }
-
-            let b[] = valueA;
-        }
-
-        return static::quick(b);
+        return static::fromTensorBuffer(tensor_clip(this->a, (double) min, (double) max));
     }
 
     /**
@@ -1413,23 +1372,7 @@ class Vector implements Tensor
      */
     public function clipLower(const float min) -> <Vector>
     {
-        var valueA;
-
-        array b = [];
-        
-        var a = this->a->toArray();
-
-        for valueA in a {
-            if valueA < min {
-                let b[] = min;
-
-                continue;
-            }
-
-            let b[] = valueA;
-        }
-
-        return static::quick(b);
+        return static::fromTensorBuffer(tensor_clip_lower(this->a, (double) min));
     }
 
     /**
@@ -1440,23 +1383,7 @@ class Vector implements Tensor
      */
     public function clipUpper(const float max) -> <Vector>
     {
-        var valueA;
-
-        array b = [];
-
-        var a = this->a->toArray();
-
-        for valueA in a {
-            if valueA > max {
-                let b[] = max;
-
-                continue;
-            }
-
-            let b[] = valueA;
-        }
-
-        return static::quick(b);
+        return static::fromTensorBuffer(tensor_clip_upper(this->a, (double) max));
     }
 
     /**
@@ -1466,23 +1393,7 @@ class Vector implements Tensor
      */
     public function sign() -> <Vector>
     {
-        var valueA;
-
-        array b = [];
-
-        var a = this->a->toArray();
-
-        for valueA in a {
-            if valueA > 0 {
-                let b[] = 1.0;
-            } elseif valueA < 0 {
-                let b[] = -1.0;
-            } else {
-                let b[] = 0.0;
-            }
-        }
-
-        return static::quick(b);
+        return static::fromTensorBuffer(tensor_sign(this->a));
     }
 
     /**
@@ -1492,17 +1403,7 @@ class Vector implements Tensor
      */
     public function negate() -> <Vector>
     {
-        var valueA;
-        
-        array b = [];
-
-        var a = this->a->toArray();
-
-        for valueA in a {
-            let b[] = -valueA;
-        }
-
-        return static::quick(b);
+        return static::fromTensorBuffer(tensor_negate(this->a));
     }
 
     /**

From 77fc773efbcdae659363e0a1befc528608f656eb Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Mon, 21 Sep 2026 23:35:25 -0500
Subject: [PATCH 16/51] Fix typo

---
 AGENTS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/AGENTS.md b/AGENTS.md
index 2c651ec..e7b2e57 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -70,7 +70,7 @@ Every public method a new `tensor/` class adds typically routes into the C backi
 1. Update the Zephir class in `tensor/`.
 2. Add/adjust the matching `optimizers/Tensor<Op>Optimizer.php` if it is a callable that the extension should route into C.
 3. Ensure the underlying C implementation exists under `ext/include/*.c` and is linked (already wired in `config.json` `extra-sources`).
-4. Bump the version in both `config.json` and `package.xml` if this is a released change, and record it in `CHANGELOG.md`.
+4. Bump the version in both `config.json` if this is a released change, and record it in `CHANGELOG.md`.
 
 Do **not** hand-edit the generated C in `ext/` (files like `*.dep`, `*.lo`, `*.o`, `Makefile*`, `config.h`). They are produced by `composer compile`. Hand-written logic belongs in `ext/include/*.c`.
 

From b828d497c28123f991ca0ff1ff4d5fa06fd1e8e9 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Tue, 22 Sep 2026 00:00:45 -0500
Subject: [PATCH 17/51] More optimizations

---
 .../ColumnVectorMatrixDivideBench.php         |   40 +
 composer.json                                 |    5 +
 ext/include/arithmetic.c                      |  129 +
 ext/include/arithmetic.h                      |   11 +
 ext/include/comparison.c                      |  130 +
 ext/include/comparison.h                      |   11 +
 ext/tensor/columnvector.zep.c                 | 2379 ++---------------
 ext/tensor/matrix.zep.c                       | 1461 ++--------
 ext/tensor/matrix.zep.h                       |    5 +
 optimizers/TensorAddColOptimizer.php          |   76 +
 optimizers/TensorDivideColOptimizer.php       |   76 +
 .../TensorDivideColReverseOptimizer.php       |   76 +
 optimizers/TensorEqualColOptimizer.php        |   76 +
 optimizers/TensorGreaterColOptimizer.php      |   76 +
 .../TensorGreaterColReverseOptimizer.php      |   76 +
 optimizers/TensorGreaterEqualColOptimizer.php |   76 +
 .../TensorGreaterEqualColReverseOptimizer.php |   76 +
 optimizers/TensorLessColOptimizer.php         |   76 +
 optimizers/TensorLessColReverseOptimizer.php  |   76 +
 optimizers/TensorLessEqualColOptimizer.php    |   76 +
 .../TensorLessEqualColReverseOptimizer.php    |   76 +
 optimizers/TensorModColOptimizer.php          |   76 +
 optimizers/TensorModColReverseOptimizer.php   |   76 +
 optimizers/TensorMultiplyColOptimizer.php     |   76 +
 optimizers/TensorNotEqualColOptimizer.php     |   76 +
 optimizers/TensorPowColOptimizer.php          |   76 +
 optimizers/TensorPowColReverseOptimizer.php   |   76 +
 optimizers/TensorSubtractColOptimizer.php     |   76 +
 .../TensorSubtractColReverseOptimizer.php     |   76 +
 tensor/columnvector.zep                       |  240 +-
 tensor/matrix.zep                             |  142 +-
 31 files changed, 2466 insertions(+), 3607 deletions(-)
 create mode 100644 benchmarks/Arithmetic/ColumnVectorMatrixDivideBench.php
 create mode 100644 optimizers/TensorAddColOptimizer.php
 create mode 100644 optimizers/TensorDivideColOptimizer.php
 create mode 100644 optimizers/TensorDivideColReverseOptimizer.php
 create mode 100644 optimizers/TensorEqualColOptimizer.php
 create mode 100644 optimizers/TensorGreaterColOptimizer.php
 create mode 100644 optimizers/TensorGreaterColReverseOptimizer.php
 create mode 100644 optimizers/TensorGreaterEqualColOptimizer.php
 create mode 100644 optimizers/TensorGreaterEqualColReverseOptimizer.php
 create mode 100644 optimizers/TensorLessColOptimizer.php
 create mode 100644 optimizers/TensorLessColReverseOptimizer.php
 create mode 100644 optimizers/TensorLessEqualColOptimizer.php
 create mode 100644 optimizers/TensorLessEqualColReverseOptimizer.php
 create mode 100644 optimizers/TensorModColOptimizer.php
 create mode 100644 optimizers/TensorModColReverseOptimizer.php
 create mode 100644 optimizers/TensorMultiplyColOptimizer.php
 create mode 100644 optimizers/TensorNotEqualColOptimizer.php
 create mode 100644 optimizers/TensorPowColOptimizer.php
 create mode 100644 optimizers/TensorPowColReverseOptimizer.php
 create mode 100644 optimizers/TensorSubtractColOptimizer.php
 create mode 100644 optimizers/TensorSubtractColReverseOptimizer.php

diff --git a/benchmarks/Arithmetic/ColumnVectorMatrixDivideBench.php b/benchmarks/Arithmetic/ColumnVectorMatrixDivideBench.php
new file mode 100644
index 0000000..4a21214
--- /dev/null
+++ b/benchmarks/Arithmetic/ColumnVectorMatrixDivideBench.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tensor\Benchmarks\Arithmetic;
+
+use Tensor\Matrix;
+use Tensor\ColumnVector;
+
+/**
+ * @Groups({"Arithmetic"})
+ * @BeforeMethods({"setUp"})
+ */
+class ColumnVectorMatrixDivideBench
+{
+    /**
+     * @var \Tensor\Vector
+     */
+    protected $a;
+
+    /**
+     * @var Matrix
+     */
+    protected $b;
+
+    public function setUp() : void
+    {
+        $this->a = ColumnVector::uniform(1000);
+
+        $this->b = Matrix::uniform(1000, 1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function divide() : void
+    {
+        $this->a->divide($this->b);
+    }
+}
diff --git a/composer.json b/composer.json
index 3ade8f4..93d7fe4 100644
--- a/composer.json
+++ b/composer.json
@@ -68,6 +68,11 @@
             "zephir generate",
             "zephir compile --no-dev"
         ],
+        "compile-ci": [
+            "zephir generate",
+            "build-ext",
+            "zephir compile --no-dev"
+        ],
         "install-ext": "zephir install",
         "fix": "php-cs-fixer fix --config=.php-cs-fixer.dist.php",
         "test": "phpunit"
diff --git a/ext/include/arithmetic.c b/ext/include/arithmetic.c
index 9aaf070..ceec2a4 100644
--- a/ext/include/arithmetic.c
+++ b/ext/include/arithmetic.c
@@ -385,4 +385,133 @@ void tensor_mod_scalar(zval * return_value, zval * a, zval * b)
 	}
 
 	zval_ptr_dtor(&c);
+}
+
+/* Scalar operation applied to every element of a matrix row. The matrix is
+ * wrapped up in `a` (m * n doubles in row-major order) and the column vector
+ * in `b` (m doubles) so that element (i, j) of the result is op(a[i * n + j],
+ * b[i]). `reverse` swaps the operands so that the same value function can
+ * serve both the matrix and the column vector as the left-hand side. */
+
+typedef double (*tensor_col_op)(double x, double y);
+
+static double tensor_col_multiply_value(double x, double y)
+{
+	return x * y;
+}
+
+static double tensor_col_divide_value(double x, double y)
+{
+	return x / y;
+}
+
+static double tensor_col_add_value(double x, double y)
+{
+	return x + y;
+}
+
+static double tensor_col_subtract_value(double x, double y)
+{
+	return x - y;
+}
+
+static double tensor_col_pow_value(double x, double y)
+{
+	return pow(x, y);
+}
+
+static double tensor_col_mod_value(double x, double y)
+{
+	return fmod(x, y);
+}
+
+static void tensor_col_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_col_op fn, int reverse)
+{
+	zend_long n = 0, m = 0, total = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &m, &ok_b);
+
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
+
+	zend_long nHat = zephir_get_intval(n_zval);
+
+	if (UNEXPECTED(nHat < 1 || total != m * nHat)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Matrix and vector dimensions must agree."));
+		return;
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	zend_long i, j;
+
+	for (i = 0; i < m; ++i) {
+		for (j = 0; j < nHat; ++j) {
+			vc[i * nHat + j] = reverse
+				? fn(vb[i], va[i * nHat + j])
+				: fn(va[i * nHat + j], vb[i]);
+		}
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+void tensor_multiply_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_multiply_value, 0);
+}
+
+void tensor_add_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_add_value, 0);
+}
+
+void tensor_divide_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_divide_value, 0);
+}
+
+void tensor_divide_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_divide_value, 1);
+}
+
+void tensor_subtract_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_subtract_value, 0);
+}
+
+void tensor_subtract_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_subtract_value, 1);
+}
+
+void tensor_pow_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_pow_value, 0);
+}
+
+void tensor_pow_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_pow_value, 1);
+}
+
+void tensor_mod_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_mod_value, 0);
+}
+
+void tensor_mod_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_mod_value, 1);
 }
\ No newline at end of file
diff --git a/ext/include/arithmetic.h b/ext/include/arithmetic.h
index 9d459db..0351042 100644
--- a/ext/include/arithmetic.h
+++ b/ext/include/arithmetic.h
@@ -17,4 +17,15 @@ void tensor_subtract_scalar(zval * return_value, zval * a, zval * b);
 void tensor_pow_scalar(zval * return_value, zval * a, zval * b);
 void tensor_mod_scalar(zval * return_value, zval * a, zval * b);
 
+void tensor_multiply_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_add_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_divide_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_divide_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_subtract_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_subtract_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_pow_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_pow_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_mod_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_mod_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
+
 #endif
diff --git a/ext/include/comparison.c b/ext/include/comparison.c
index fb2e9cd..c4f5b59 100644
--- a/ext/include/comparison.c
+++ b/ext/include/comparison.c
@@ -384,4 +384,134 @@ void tensor_less_equal_scalar(zval * return_value, zval * a, zval * b)
 	}
 
 	zval_ptr_dtor(&c);
+}
+
+/* Comparison applied to every element of a matrix row. The matrix is wrapped
+ * up in `a` (m * n doubles in row-major order) and the column vector in `b`
+ * (m doubles) so that element (i, j) of the result is 1.0 when the comparison
+ * op(a[i * n + j], b[i]) holds and 0.0 otherwise. `reverse` swaps the operands
+ * so that the same predicate can serve both the matrix and the column vector
+ * as the left-hand side. */
+
+typedef double (*tensor_col_op)(double x, double y);
+
+static double tensor_col_equal_value(double x, double y)
+{
+	return x == y ? 1.0 : 0.0;
+}
+
+static double tensor_col_not_equal_value(double x, double y)
+{
+	return x != y ? 1.0 : 0.0;
+}
+
+static double tensor_col_greater_value(double x, double y)
+{
+	return x > y ? 1.0 : 0.0;
+}
+
+static double tensor_col_greater_equal_value(double x, double y)
+{
+	return x >= y ? 1.0 : 0.0;
+}
+
+static double tensor_col_less_value(double x, double y)
+{
+	return x < y ? 1.0 : 0.0;
+}
+
+static double tensor_col_less_equal_value(double x, double y)
+{
+	return x <= y ? 1.0 : 0.0;
+}
+
+static void tensor_col_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_col_op fn, int reverse)
+{
+	zend_long n = 0, m = 0, total = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &m, &ok_b);
+
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
+
+	zend_long nHat = zephir_get_intval(n_zval);
+
+	if (UNEXPECTED(nHat < 1 || total != m * nHat)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Matrix and vector dimensions must agree."));
+		return;
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	zend_long i, j;
+
+	for (i = 0; i < m; ++i) {
+		for (j = 0; j < nHat; ++j) {
+			vc[i * nHat + j] = reverse
+				? fn(vb[i], va[i * nHat + j])
+				: fn(va[i * nHat + j], vb[i]);
+		}
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+void tensor_equal_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_equal_value, 0);
+}
+
+void tensor_not_equal_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_not_equal_value, 0);
+}
+
+void tensor_greater_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_greater_value, 0);
+}
+
+void tensor_greater_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_greater_value, 1);
+}
+
+void tensor_greater_equal_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_greater_equal_value, 0);
+}
+
+void tensor_greater_equal_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_greater_equal_value, 1);
+}
+
+void tensor_less_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_less_value, 0);
+}
+
+void tensor_less_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_less_value, 1);
+}
+
+void tensor_less_equal_col(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_less_equal_value, 0);
+}
+
+void tensor_less_equal_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_col_apply(return_value, a, b, n, tensor_col_less_equal_value, 1);
 }
\ No newline at end of file
diff --git a/ext/include/comparison.h b/ext/include/comparison.h
index 5dadc04..34ff116 100644
--- a/ext/include/comparison.h
+++ b/ext/include/comparison.h
@@ -17,4 +17,15 @@ void tensor_greater_equal_scalar(zval * return_value, zval * a, zval * b);
 void tensor_less_scalar(zval * return_value, zval * a, zval * b);
 void tensor_less_equal_scalar(zval * return_value, zval * a, zval * b);
 
+void tensor_equal_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_not_equal_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_greater_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_greater_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_greater_equal_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_greater_equal_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_less_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_less_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_less_equal_col(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_less_equal_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
+
 #endif
\ No newline at end of file
diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index f7380a7..6b0f6d4 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -18,8 +18,8 @@
 #include "kernel/object.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
-#include "kernel/string.h"
-#include "kernel/array.h"
+#include "include/arithmetic.h"
+#include "include/comparison.h"
 
 
 /**
@@ -221,40 +221,23 @@ PHP_METHOD(Tensor_ColumnVector, matmul)
 PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -293,151 +276,18 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 123);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 120);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					mul_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 117);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						mul_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 117);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 120);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 120);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						mul_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 117);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							mul_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 117);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 120);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_multiply_col(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -452,40 +302,23 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -520,155 +353,22 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 		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", 138);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 126);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 158);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 155);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					div_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 152);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						div_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 152);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 155);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 155);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						div_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 152);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							div_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 152);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 155);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_divide_col_reverse(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -683,40 +383,23 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 PHP_METHOD(Tensor_ColumnVector, addMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -751,155 +434,22 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 		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", 173);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 149);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 193);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 190);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					zephir_add_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 187);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						zephir_add_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 187);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 190);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 190);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						zephir_add_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 187);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							zephir_add_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 187);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 190);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_add_col(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -914,40 +464,23 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -982,155 +515,22 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 		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", 208);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 172);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 228);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 225);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					zephir_sub_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 222);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						zephir_sub_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 222);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 225);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 225);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						zephir_sub_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 222);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							zephir_sub_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 222);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 225);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_subtract_col_reverse(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1145,41 +545,23 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 PHP_METHOD(Tensor_ColumnVector, powMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _24, _21$$4, _31$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_19 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _23, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _20$$4, _18$$5, _22$$6, _25$$7, *_26$$7, _27$$7, *_28$$7, _30$$7, _29$$8, _32$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_23);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_20$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_22$$6);
-	ZVAL_UNDEF(&_25$$7);
-	ZVAL_UNDEF(&_27$$7);
-	ZVAL_UNDEF(&_30$$7);
-	ZVAL_UNDEF(&_29$$8);
-	ZVAL_UNDEF(&_32$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -1214,155 +596,22 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 		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", 243);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 195);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 263);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 260);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_CALL_FUNCTION(&_18$$5, "pow", &_19, 17, &valueA, &valueB);
-					zephir_check_call_status();
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 257);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_21$$4 = 1;
-				while (1) {
-					if (_21$$4) {
-						_21$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_20$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_20$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_CALL_FUNCTION(&_22$$6, "pow", &_19, 17, &valueA, &valueB);
-						zephir_check_call_status();
-						zephir_array_append(&rowC, &_22$$6, PH_SEPARATE, "tensor/columnvector.zep", 257);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 260);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_24 = 1;
-		while (1) {
-			if (_24) {
-				_24 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_23, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_23)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_25$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_25$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_27$$7);
-					zephir_string_to_char_array(&_27$$7, &rowB);
-					_26$$7 = &_27$$7;
-				} else {
-					_26$$7 = &rowB;
-				}
-				zephir_is_iterable(_26$$7, 0, "tensor/columnvector.zep", 260);
-				if (Z_TYPE_P(_26$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_26$$7), _28$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _28$$7);
-						ZEPHIR_CALL_FUNCTION(&_29$$8, "pow", &_19, 17, &valueA, &valueB);
-						zephir_check_call_status();
-						zephir_array_append(&rowC, &_29$$8, PH_SEPARATE, "tensor/columnvector.zep", 257);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _26$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_31$$7 = 1;
-					while (1) {
-						if (_31$$7) {
-							_31$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _26$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_30$$7, _26$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_30$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _26$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_CALL_FUNCTION(&_32$$9, "pow", &_19, 17, &valueA, &valueB);
-							zephir_check_call_status();
-							zephir_array_append(&rowC, &_32$$9, PH_SEPARATE, "tensor/columnvector.zep", 257);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 260);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_pow_col_reverse(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1377,40 +626,23 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 PHP_METHOD(Tensor_ColumnVector, modMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -1445,155 +677,22 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 		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", 278);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 218);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 298);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 295);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					mod_function(&_18$$5, &valueA, &valueB);
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 292);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						mod_function(&_21$$6, &valueA, &valueB);
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 292);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 295);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 295);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						mod_function(&_28$$8, &valueA, &valueB);
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 292);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							mod_function(&_31$$9, &valueA, &valueB);
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 292);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 295);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_mod_col_reverse(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1608,40 +707,23 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -1676,179 +758,22 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 		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", 313);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 241);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 333);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 330);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					if (ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 1);
-					} else {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 0);
-					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 327);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						if (ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 0);
-						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 327);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 330);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 330);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						if (ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 0);
-						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 327);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							if (ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 1);
-							} else {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 0);
-							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 327);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 330);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_equal_col(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1863,40 +788,23 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -1931,179 +839,22 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 		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", 348);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 264);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 368);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 365);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					if (!ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 1);
-					} else {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 0);
-					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 362);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						if (!ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 0);
-						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 362);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 365);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 365);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						if (!ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 0);
-						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 362);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							if (!ZEPHIR_IS_EQUAL(&valueA, &valueB)) {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 1);
-							} else {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 0);
-							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 362);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 365);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_not_equal_col(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2118,40 +869,23 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -2186,179 +920,22 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 		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", 383);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 287);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 403);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 400);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					if (ZEPHIR_GT(&valueA, &valueB)) {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 1);
-					} else {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 0);
-					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 397);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						if (ZEPHIR_GT(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 0);
-						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 397);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 400);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 400);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						if (ZEPHIR_GT(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 0);
-						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 397);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							if (ZEPHIR_GT(&valueA, &valueB)) {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 1);
-							} else {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 0);
-							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 397);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 400);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_greater_col_reverse(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2373,40 +950,23 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -2441,179 +1001,22 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 		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", 418);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 310);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 438);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 435);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					if (ZEPHIR_GE(&valueA, &valueB)) {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 1);
-					} else {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 0);
-					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 432);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						if (ZEPHIR_GE(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 0);
-						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 432);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 435);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 435);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						if (ZEPHIR_GE(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 0);
-						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 432);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							if (ZEPHIR_GE(&valueA, &valueB)) {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 1);
-							} else {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 0);
-							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 432);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 435);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_greater_equal_col_reverse(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2628,40 +1031,23 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -2696,179 +1082,22 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 		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", 453);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 333);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 473);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 470);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					if (ZEPHIR_LT(&valueA, &valueB)) {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 1);
-					} else {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 0);
-					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 467);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						if (ZEPHIR_LT(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 0);
-						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 467);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 470);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 470);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						if (ZEPHIR_LT(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 0);
-						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 467);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							if (ZEPHIR_LT(&valueA, &valueB)) {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 1);
-							} else {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 0);
-							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 467);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 470);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_less_col_reverse(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2883,40 +1112,23 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _23, _20$$4, _30$$7;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c, rowC;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, rowB, valueB, valueA, _8, *_9, _10, *_11, _22, _2$$3, _3$$3, _5$$3, _14$$4, *_15$$4, _16$$4, *_17$$4, _19$$4, _18$$5, _21$$6, _24$$7, *_25$$7, _26$$7, *_27$$7, _29$$7, _28$$8, _31$$9;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	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(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_29$$7);
-	ZVAL_UNDEF(&_28$$8);
-	ZVAL_UNDEF(&_31$$9);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -2951,179 +1163,22 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 		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", 488);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 356);
 		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();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/columnvector.zep", 508);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			zephir_read_property_cached(&_14$$4, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&valueA, &_14$$4, "get", NULL, 0, &i);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			if (Z_TYPE_P(&rowB) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_16$$4);
-				zephir_string_to_char_array(&_16$$4, &rowB);
-				_15$$4 = &_16$$4;
-			} else {
-				_15$$4 = &rowB;
-			}
-			zephir_is_iterable(_15$$4, 0, "tensor/columnvector.zep", 505);
-			if (Z_TYPE_P(_15$$4) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_15$$4), _17$$4)
-				{
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _17$$4);
-					ZEPHIR_INIT_NVAR(&_18$$5);
-					if (ZEPHIR_LE(&valueA, &valueB)) {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 1);
-					} else {
-						ZEPHIR_INIT_NVAR(&_18$$5);
-						ZVAL_LONG(&_18$$5, 0);
-					}
-					zephir_array_append(&rowC, &_18$$5, PH_SEPARATE, "tensor/columnvector.zep", 502);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _15$$4, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_20$$4 = 1;
-				while (1) {
-					if (_20$$4) {
-						_20$$4 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _15$$4, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_19$$4, _15$$4, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_19$$4)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueB, _15$$4, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_21$$6);
-						if (ZEPHIR_LE(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_21$$6);
-							ZVAL_LONG(&_21$$6, 0);
-						}
-						zephir_array_append(&rowC, &_21$$6, PH_SEPARATE, "tensor/columnvector.zep", 502);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 505);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				zephir_read_property_cached(&_24$$7, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&valueA, &_24$$7, "get", NULL, 0, &i);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				if (Z_TYPE_P(&rowB) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_26$$7);
-					zephir_string_to_char_array(&_26$$7, &rowB);
-					_25$$7 = &_26$$7;
-				} else {
-					_25$$7 = &rowB;
-				}
-				zephir_is_iterable(_25$$7, 0, "tensor/columnvector.zep", 505);
-				if (Z_TYPE_P(_25$$7) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_25$$7), _27$$7)
-					{
-						ZEPHIR_INIT_NVAR(&valueB);
-						ZVAL_COPY(&valueB, _27$$7);
-						ZEPHIR_INIT_NVAR(&_28$$8);
-						if (ZEPHIR_LE(&valueA, &valueB)) {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 1);
-						} else {
-							ZEPHIR_INIT_NVAR(&_28$$8);
-							ZVAL_LONG(&_28$$8, 0);
-						}
-						zephir_array_append(&rowC, &_28$$8, PH_SEPARATE, "tensor/columnvector.zep", 502);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _25$$7, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_30$$7 = 1;
-					while (1) {
-						if (_30$$7) {
-							_30$$7 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _25$$7, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_29$$7, _25$$7, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_29$$7)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueB, _25$$7, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_31$$9);
-							if (ZEPHIR_LE(&valueA, &valueB)) {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 1);
-							} else {
-								ZEPHIR_INIT_NVAR(&_31$$9);
-								ZVAL_LONG(&_31$$9, 0);
-							}
-							zephir_array_append(&rowC, &_31$$9, PH_SEPARATE, "tensor/columnvector.zep", 502);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/columnvector.zep", 505);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_less_equal_col_reverse(&result, &bHat, &_8, &_9);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 8854893..4384cea 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -2100,6 +2100,17 @@ PHP_METHOD(Tensor_Matrix, asVector)
 	RETURN_MM();
 }
 
+/**
+ * Return the underlying TensorBuffer of the matrix.
+ *
+ * @return \Tensor\TensorBuffer
+ */
+PHP_METHOD(Tensor_Matrix, asTensorBuffer)
+{
+
+	RETURN_MEMBER(getThis(), "a");
+}
+
 /**
  * Return the matrix as an array of arrays.
  *
@@ -2153,7 +2164,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 650);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 660);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -2161,7 +2172,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 647);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 657);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -2183,7 +2194,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 647);
+				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 657);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -2282,7 +2293,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 686);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 696);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -2290,7 +2301,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_CE_STATIC(&_7$$4, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 683);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 693);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -2312,7 +2323,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			zephir_check_call_status();
 				ZEPHIR_CALL_CE_STATIC(&_11$$5, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 683);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 693);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -2384,7 +2395,7 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 705);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 715);
 		}
 	}
 	RETURN_CTOR(&b);
@@ -2436,7 +2447,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 730);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 740);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -2444,7 +2455,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			ZVAL_COPY(&columnBuffer, _4);
 			ZEPHIR_CALL_CE_STATIC(&_5$$4, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 727);
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 737);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -2466,7 +2477,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			zephir_check_call_status();
 				ZEPHIR_CALL_CE_STATIC(&_9$$5, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 727);
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 737);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&columnBuffer);
@@ -2651,7 +2662,7 @@ PHP_METHOD(Tensor_Matrix, transpose)
 		RETURN_MM();
 	}
 	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 795);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 805);
 	ZVAL_LONG(&_1, 1);
 	ZEPHIR_CALL_FUNCTION(&_2, "array_slice", NULL, 28, &cols, &_1);
 	zephir_check_call_status();
@@ -2715,7 +2726,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 812);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 822);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2728,7 +2739,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 29, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 817);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 827);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2743,7 +2754,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 29, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 824);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 834);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2802,7 +2813,7 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 29, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 841);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 851);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2851,7 +2862,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 857);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 867);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2937,7 +2948,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 	ZEPHIR_CPY_WRT(&a, &_3);
 	pivots = 0;
 	epsilon =  (0.00000001);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 912);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 922);
 	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _4)
 	{
 		ZEPHIR_INIT_NVAR(&rowA);
@@ -2950,7 +2961,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 		} else {
 			_5$$3 = &rowA;
 		}
-		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 910);
+		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 920);
 		if (Z_TYPE_P(_5$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$3), _7$$3)
 			{
@@ -3188,7 +3199,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_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/matrix.zep", 961);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 971);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3262,7 +3273,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements 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", 981);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 991);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3360,7 +3371,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 3, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 999);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 1009);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3374,7 +3385,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 3, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 1004);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 1014);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3710,7 +3721,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1148);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1158);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3781,7 +3792,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1181);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1191);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3853,7 +3864,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1215);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1225);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3925,7 +3936,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1249);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1259);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3997,7 +4008,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1283);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1293);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4069,7 +4080,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1317);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1327);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4141,7 +4152,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1351);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1361);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4213,7 +4224,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1385);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1395);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4285,7 +4296,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1419);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1429);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4357,7 +4368,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1453);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1463);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4429,7 +4440,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1487);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1497);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4501,7 +4512,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1521);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1531);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -5208,7 +5219,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1707);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1717);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5216,7 +5227,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1704);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1714);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5238,7 +5249,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1704);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1714);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5294,7 +5305,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1725);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1735);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5302,7 +5313,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1722);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1732);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5324,7 +5335,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1722);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1732);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5380,7 +5391,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1743);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1753);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5388,7 +5399,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1740);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1750);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5410,7 +5421,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1740);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1750);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5466,7 +5477,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1761);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1771);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5474,7 +5485,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1758);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1768);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5496,7 +5507,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1758);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1768);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5600,7 +5611,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1800);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1810);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5624,7 +5635,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1797);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1807);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5662,7 +5673,7 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1797);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1807);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5748,7 +5759,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1814);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1824);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5769,7 +5780,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1842);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1852);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5785,7 +5796,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1832);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1842);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5797,7 +5808,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1839);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1849);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5827,7 +5838,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1832);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1842);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5839,7 +5850,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1839);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1849);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5914,7 +5925,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1858);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1868);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5934,7 +5945,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 3, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1864);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1874);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -6023,7 +6034,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 3, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1889);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1899);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -6129,7 +6140,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less 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", 1917);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1927);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6146,7 +6157,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_12 = &_10;
 	}
-	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1940);
+	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1950);
 	if (Z_TYPE_P(_12) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
 		{
@@ -6169,7 +6180,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1937);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1947);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
@@ -6206,7 +6217,7 @@ PHP_METHOD(Tensor_Matrix, round)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1937);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1947);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6352,7 +6363,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1976);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1986);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6624,7 +6635,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", 2042);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2052);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6721,7 +6732,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", 2062);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2072);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6825,7 +6836,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", 2082);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2092);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6868,7 +6879,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2096);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2106);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -6957,7 +6968,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", 2114);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2124);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7000,7 +7011,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2128);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2138);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -7078,7 +7089,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2152);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2162);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -7087,7 +7098,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2150);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2160);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -7110,14 +7121,14 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2150);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2160);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2155);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2165);
 		ZVAL_LONG(&_13$$6, 1);
 		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 28, &bigRows, &_13$$6);
 		zephir_check_call_status();
@@ -7203,7 +7214,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2178);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2188);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7278,7 +7289,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2197);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2207);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7353,7 +7364,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2216);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2226);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7428,7 +7439,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2235);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2245);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7504,7 +7515,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2255);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2265);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7580,7 +7591,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2275);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2285);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7656,7 +7667,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2295);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2305);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7731,7 +7742,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2314);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2324);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7807,7 +7818,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2334);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2344);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7883,7 +7894,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2354);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2364);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7958,7 +7969,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2373);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2383);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8033,7 +8044,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2392);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2402);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8118,7 +8129,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2412);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2422);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8151,7 +8162,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_multiply(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2422);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2432);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8229,7 +8240,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2440);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2450);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8262,7 +8273,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_divide(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2450);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2460);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8340,7 +8351,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2468);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2478);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8373,7 +8384,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_add(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2478);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2488);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8451,7 +8462,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2496);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2506);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8484,7 +8495,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_subtract(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2506);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2516);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8562,7 +8573,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2524);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2534);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8595,7 +8606,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_pow(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2534);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2544);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8673,7 +8684,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2552);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2562);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8706,7 +8717,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_mod(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2562);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2572);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8785,7 +8796,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2581);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2591);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8818,7 +8829,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2591);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2601);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -8896,7 +8907,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2609);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2619);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8929,7 +8940,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_not_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2619);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2629);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9007,7 +9018,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2637);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2647);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9040,7 +9051,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2647);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2657);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9118,7 +9129,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2665);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2675);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9151,7 +9162,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2675);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2685);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9229,7 +9240,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2693);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2703);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9262,7 +9273,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2703);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2713);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9341,7 +9352,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2722);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2732);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9374,7 +9385,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2732);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2742);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
@@ -9392,37 +9403,23 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -9461,79 +9458,19 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2750);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2760);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2761);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_multiply_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2758);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_multiply_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2758);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_multiply_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9548,37 +9485,23 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 PHP_METHOD(Tensor_Matrix, divideColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -9617,79 +9540,19 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2776);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2783);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2787);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_divide_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2784);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_divide_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2784);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_divide_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9704,37 +9567,23 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 PHP_METHOD(Tensor_Matrix, addColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -9773,79 +9622,19 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2802);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2806);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2813);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_add_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2810);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_add_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2810);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_add_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9860,37 +9649,23 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -9929,79 +9704,19 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2828);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2829);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2839);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_subtract_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2836);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_subtract_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2836);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_subtract_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10016,37 +9731,23 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 PHP_METHOD(Tensor_Matrix, powColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -10085,79 +9786,19 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2854);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2852);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2865);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_pow_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2862);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_pow_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2862);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_pow_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10172,37 +9813,23 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 PHP_METHOD(Tensor_Matrix, modColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -10241,79 +9868,19 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2880);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2875);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2891);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_mod_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2888);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_mod_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2888);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_mod_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10328,37 +9895,23 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 PHP_METHOD(Tensor_Matrix, equalColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -10397,79 +9950,19 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2906);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2898);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2917);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2914);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2914);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_equal_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10484,37 +9977,23 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -10553,79 +10032,19 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2932);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2921);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2943);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_not_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2940);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_not_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2940);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_not_equal_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10640,37 +10059,23 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -10709,79 +10114,19 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2958);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2944);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2969);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_greater_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2966);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_greater_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2966);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_greater_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10796,37 +10141,23 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -10865,79 +10196,19 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2984);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2967);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 2995);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_greater_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 2992);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_greater_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 2992);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_greater_equal_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10952,37 +10223,23 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 PHP_METHOD(Tensor_Matrix, lessColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -11021,79 +10278,19 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3010);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2990);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3021);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_less_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3018);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_less_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3018);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_less_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -11108,37 +10305,23 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _20;
-	zend_string *_13;
-	zend_ulong _12;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, i, valueB, _8, *_9, _10, *_11, _19, _2$$3, _3$$3, _5$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _21$$5, _22$$5, _23$$5, _24$$5, _25$$5;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&valueB);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_22$$5);
-	ZVAL_UNDEF(&_23$$5);
-	ZVAL_UNDEF(&_24$$5);
-	ZVAL_UNDEF(&_25$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -11177,79 +10360,19 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3036);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 3013);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 3047);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_9), _12, _13, _11)
-		{
-			ZEPHIR_INIT_NVAR(&i);
-			if (_13 != NULL) { 
-				ZVAL_STR_COPY(&i, _13);
-			} else {
-				ZVAL_LONG(&i, _12);
-			}
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZVAL_COPY(&valueB, _11);
-			ZEPHIR_INIT_NVAR(&_14$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_18$$4);
-			mul_function(&_18$$4, &i, &_17$$4);
-			zephir_read_property_cached(&_17$$4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "slice", NULL, 0, &_18$$4, &_17$$4);
-			zephir_check_call_status();
-			tensor_less_equal_scalar(&_14$$4, &_16$$4, &valueB);
-			zephir_array_append(&c, &_14$$4, PH_SEPARATE, "tensor/matrix.zep", 3044);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_20 = 1;
-		while (1) {
-			if (_20) {
-				_20 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_19, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_19)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&i, _9, "key", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CALL_METHOD(&valueB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_21$$5);
-				zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_INIT_NVAR(&_25$$5);
-				mul_function(&_25$$5, &i, &_24$$5);
-				zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				ZEPHIR_CALL_METHOD(&_23$$5, &_22$$5, "slice", NULL, 0, &_25$$5, &_24$$5);
-				zephir_check_call_status();
-				tensor_less_equal_scalar(&_21$$5, &_23$$5, &valueB);
-				zephir_array_append(&c, &_21$$5, PH_SEPARATE, "tensor/matrix.zep", 3044);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueB);
-	ZEPHIR_INIT_NVAR(&i);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_less_equal_col(&result, &_8, &bHat, &_9);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -11888,7 +11011,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3223);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3197);
 	return;
 }
 
@@ -11939,7 +11062,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3247);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3221);
 	return;
 }
 
@@ -11999,7 +11122,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3261);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3235);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -12016,7 +11139,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3266);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3240);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index bb423f1..dd2e935 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -26,6 +26,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector);
 PHP_METHOD(Tensor_Matrix, columnAsVector);
 PHP_METHOD(Tensor_Matrix, diagonalAsVector);
 PHP_METHOD(Tensor_Matrix, asVector);
+PHP_METHOD(Tensor_Matrix, asTensorBuffer);
 PHP_METHOD(Tensor_Matrix, asArray);
 PHP_METHOD(Tensor_Matrix, asRowBuffers);
 PHP_METHOD(Tensor_Matrix, asRowVectors);
@@ -259,6 +260,9 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_asvector, 0, 0, Tensor\\Vector, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_astensorbuffer, 0, 0, Tensor\\TensorBuffer, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asarray, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
@@ -775,6 +779,7 @@ ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, columnAsVector, arginfo_tensor_matrix_columnasvector, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, diagonalAsVector, arginfo_tensor_matrix_diagonalasvector, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asVector, arginfo_tensor_matrix_asvector, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, asTensorBuffer, arginfo_tensor_matrix_astensorbuffer, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asArray, arginfo_tensor_matrix_asarray, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asRowBuffers, arginfo_tensor_matrix_asrowbuffers, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asRowVectors, arginfo_tensor_matrix_asrowvectors, ZEND_ACC_PUBLIC)
diff --git a/optimizers/TensorAddColOptimizer.php b/optimizers/TensorAddColOptimizer.php
new file mode 100644
index 0000000..01d5d28
--- /dev/null
+++ b/optimizers/TensorAddColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorAddColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor add col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_add_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorDivideColOptimizer.php b/optimizers/TensorDivideColOptimizer.php
new file mode 100644
index 0000000..c63e47d
--- /dev/null
+++ b/optimizers/TensorDivideColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorDivideColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor divide col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_divide_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorDivideColReverseOptimizer.php b/optimizers/TensorDivideColReverseOptimizer.php
new file mode 100644
index 0000000..e3f2660
--- /dev/null
+++ b/optimizers/TensorDivideColReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorDivideColReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor divide col reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_divide_col_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorEqualColOptimizer.php b/optimizers/TensorEqualColOptimizer.php
new file mode 100644
index 0000000..2f2aee7
--- /dev/null
+++ b/optimizers/TensorEqualColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorEqualColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor equal col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_equal_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorGreaterColOptimizer.php b/optimizers/TensorGreaterColOptimizer.php
new file mode 100644
index 0000000..5fad60a
--- /dev/null
+++ b/optimizers/TensorGreaterColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorGreaterColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor greater col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_greater_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorGreaterColReverseOptimizer.php b/optimizers/TensorGreaterColReverseOptimizer.php
new file mode 100644
index 0000000..8184338
--- /dev/null
+++ b/optimizers/TensorGreaterColReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorGreaterColReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor greater col reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_greater_col_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorGreaterEqualColOptimizer.php b/optimizers/TensorGreaterEqualColOptimizer.php
new file mode 100644
index 0000000..0c1fa78
--- /dev/null
+++ b/optimizers/TensorGreaterEqualColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorGreaterEqualColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor greater equal col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_greater_equal_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorGreaterEqualColReverseOptimizer.php b/optimizers/TensorGreaterEqualColReverseOptimizer.php
new file mode 100644
index 0000000..ddc1b09
--- /dev/null
+++ b/optimizers/TensorGreaterEqualColReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorGreaterEqualColReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor greater equal col reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_greater_equal_col_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLessColOptimizer.php b/optimizers/TensorLessColOptimizer.php
new file mode 100644
index 0000000..67fb35d
--- /dev/null
+++ b/optimizers/TensorLessColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLessColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor less col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_less_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLessColReverseOptimizer.php b/optimizers/TensorLessColReverseOptimizer.php
new file mode 100644
index 0000000..268e988
--- /dev/null
+++ b/optimizers/TensorLessColReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLessColReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor less col reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_less_col_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLessEqualColOptimizer.php b/optimizers/TensorLessEqualColOptimizer.php
new file mode 100644
index 0000000..f4334e5
--- /dev/null
+++ b/optimizers/TensorLessEqualColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLessEqualColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor less equal col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_less_equal_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLessEqualColReverseOptimizer.php b/optimizers/TensorLessEqualColReverseOptimizer.php
new file mode 100644
index 0000000..e596805
--- /dev/null
+++ b/optimizers/TensorLessEqualColReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLessEqualColReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor less equal col reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_less_equal_col_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorModColOptimizer.php b/optimizers/TensorModColOptimizer.php
new file mode 100644
index 0000000..c69e61f
--- /dev/null
+++ b/optimizers/TensorModColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorModColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor mod col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_mod_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorModColReverseOptimizer.php b/optimizers/TensorModColReverseOptimizer.php
new file mode 100644
index 0000000..4c83adc
--- /dev/null
+++ b/optimizers/TensorModColReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorModColReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor mod col reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_mod_col_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMultiplyColOptimizer.php b/optimizers/TensorMultiplyColOptimizer.php
new file mode 100644
index 0000000..55bc247
--- /dev/null
+++ b/optimizers/TensorMultiplyColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMultiplyColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor multiply col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_multiply_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorNotEqualColOptimizer.php b/optimizers/TensorNotEqualColOptimizer.php
new file mode 100644
index 0000000..c2fdcbd
--- /dev/null
+++ b/optimizers/TensorNotEqualColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorNotEqualColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor not equal col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_not_equal_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorPowColOptimizer.php b/optimizers/TensorPowColOptimizer.php
new file mode 100644
index 0000000..070a342
--- /dev/null
+++ b/optimizers/TensorPowColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorPowColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor pow col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_pow_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorPowColReverseOptimizer.php b/optimizers/TensorPowColReverseOptimizer.php
new file mode 100644
index 0000000..95eb163
--- /dev/null
+++ b/optimizers/TensorPowColReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorPowColReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor pow col reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_pow_col_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorSubtractColOptimizer.php b/optimizers/TensorSubtractColOptimizer.php
new file mode 100644
index 0000000..c745b34
--- /dev/null
+++ b/optimizers/TensorSubtractColOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorSubtractColOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor subtract col accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_subtract_col($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorSubtractColReverseOptimizer.php b/optimizers/TensorSubtractColReverseOptimizer.php
new file mode 100644
index 0000000..39207a4
--- /dev/null
+++ b/optimizers/TensorSubtractColReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorSubtractColReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor subtract col reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_subtract_col_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/tensor/columnvector.zep b/tensor/columnvector.zep
index 8451961..d563a36 100644
--- a/tensor/columnvector.zep
+++ b/tensor/columnvector.zep
@@ -103,24 +103,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
+        var bHat, result;
 
-        array c = [];
-        array rowC = [];
+        let bHat = b->asTensorBuffer();
+        let result = tensor_multiply_col(bHat, this->a, b->n());
 
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
-
-            let rowC = [];
-
-            for valueB in rowB {
-                let rowC[] = valueA * valueB;
-            }
-
-            let c[] = rowC;
-        }
-
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -138,24 +126,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
-
-        array c = [];
-        array rowC = [];
-
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
-
-            let rowC = [];
+        var bHat, result;
 
-            for valueB in rowB {
-                let rowC[] = valueA / valueB;
-            }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_divide_col_reverse(bHat, this->a, b->n());
 
-            let c[] = rowC;
-        }
-
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -173,24 +149,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
-
-        array c = [];
-        array rowC = [];
-
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
+        var bHat, result;
 
-            let rowC = [];
-
-            for valueB in rowB {
-                let rowC[] = valueA + valueB;
-            }
-
-            let c[] = rowC;
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_add_col(bHat, this->a, b->n());
 
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -208,24 +172,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
+        var bHat, result;
 
-        array c = [];
-        array rowC = [];
+        let bHat = b->asTensorBuffer();
+        let result = tensor_subtract_col_reverse(bHat, this->a, b->n());
 
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
-
-            let rowC = [];
-
-            for valueB in rowB {
-                let rowC[] = valueA - valueB;
-            }
-
-            let c[] = rowC;
-        }
-
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -243,24 +195,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
-
-        array c = [];
-        array rowC = [];
-
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
-
-            let rowC = [];
+        var bHat, result;
 
-            for valueB in rowB {
-                let rowC[] = pow(valueA, valueB);
-            }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_pow_col_reverse(bHat, this->a, b->n());
 
-            let c[] = rowC;
-        }
-
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
  
     /**
@@ -278,24 +218,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
-
-        array c = [];
-        array rowC = [];
-
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
+        var bHat, result;
 
-            let rowC = [];
-
-            for valueB in rowB {
-                let rowC[] = valueA % valueB;
-            }
-
-            let c[] = rowC;
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_mod_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -313,24 +241,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
+        var bHat, result;
 
-        array c = [];
-        array rowC = [];
+        let bHat = b->asTensorBuffer();
+        let result = tensor_equal_col(bHat, this->a, b->n());
 
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
-
-            let rowC = [];
-
-            for valueB in rowB {
-                let rowC[] = valueA == valueB ? 1 : 0;
-            }
-
-            let c[] = rowC;
-        }
-
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -348,24 +264,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
-
-        array c = [];
-        array rowC = [];
-
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
-
-            let rowC = [];
+        var bHat, result;
 
-            for valueB in rowB {
-                let rowC[] = valueA != valueB ? 1 : 0;
-            }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_not_equal_col(bHat, this->a, b->n());
 
-            let c[] = rowC;
-        }
-
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -383,24 +287,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
-
-        array c = [];
-        array rowC = [];
-
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
+        var bHat, result;
 
-            let rowC = [];
-
-            for valueB in rowB {
-                let rowC[] = valueA > valueB ? 1 : 0;
-            }
-
-            let c[] = rowC;
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_greater_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -418,24 +310,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
+        var bHat, result;
 
-        array c = [];
-        array rowC = [];
+        let bHat = b->asTensorBuffer();
+        let result = tensor_greater_equal_col_reverse(bHat, this->a, b->n());
 
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
-
-            let rowC = [];
-
-            for valueB in rowB {
-                let rowC[] = valueA >= valueB ? 1 : 0;
-            }
-
-            let c[] = rowC;
-        }
-
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -453,24 +333,12 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
-
-        array c = [];
-        array rowC = [];
-
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
+        var bHat, result;
 
-            let rowC = [];
+        let bHat = b->asTensorBuffer();
+        let result = tensor_less_col_reverse(bHat, this->a, b->n());
 
-            for valueB in rowB {
-                let rowC[] = valueA < valueB ? 1 : 0;
-            }
-
-            let c[] = rowC;
-        }
-
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 
     /**
@@ -488,23 +356,11 @@ class ColumnVector extends Vector
                 . (string) b->m() . ".");
         }
 
-        var i, rowB, valueB, valueA;
-        
-        array c = [];
-        array rowC = [];
-
-        for i, rowB in b->asArray() {
-            let valueA = this->a->get(i);
+        var bHat, result;
 
-            let rowC = [];
-
-            for valueB in rowB {
-                let rowC[] = valueA <= valueB ? 1 : 0;
-            }
-
-            let c[] = rowC;
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_less_equal_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, b->m(), b->n());
     }
 }
\ No newline at end of file
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 08d2980..09ca267 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -628,6 +628,16 @@ class Matrix implements Tensor
         return Vector::fromTensorBuffer(this->a);
     }
 
+    /**
+     * Return the underlying TensorBuffer of the matrix.
+     *
+     * @return \Tensor\TensorBuffer
+     */
+    public function asTensorBuffer() -> <TensorBuffer>
+    {
+        return this->a;
+    }
+
     /**
      * Return the matrix as an array of arrays.
      *
@@ -2750,15 +2760,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
-
-        array c = [];
+        var bHat, result;
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_multiply_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_multiply_col(this->a, bHat, this->n);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2776,15 +2783,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
-
-        array c = [];
+        var bHat, result;
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_divide_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_divide_col(this->a, bHat, this->n);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2802,15 +2806,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
+        var bHat, result;
 
-        array c = [];
+        let bHat = b->asTensorBuffer();
+        let result = tensor_add_col(this->a, bHat, this->n);
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_add_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2828,15 +2829,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
+        var bHat, result;
 
-        array c = [];
-
-        for i, valueB in b->asArray() {
-            let c[] = tensor_subtract_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_subtract_col(this->a, bHat, this->n);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2854,15 +2852,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
-
-        array c = [];
+        var bHat, result;
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_pow_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_pow_col(this->a, bHat, this->n);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2880,15 +2875,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
-
-        array c = [];
+        var bHat, result;
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_mod_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_mod_col(this->a, bHat, this->n);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2906,15 +2898,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
+        var bHat, result;
 
-        array c = [];
+        let bHat = b->asTensorBuffer();
+        let result = tensor_equal_col(this->a, bHat, this->n);
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_equal_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2932,15 +2921,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
+        var bHat, result;
 
-        array c = [];
+        let bHat = b->asTensorBuffer();
+        let result = tensor_not_equal_col(this->a, bHat, this->n);
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_not_equal_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
-
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2958,15 +2944,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
+        var bHat, result;
 
-        array c = [];
-
-        for i, valueB in b->asArray() {
-            let c[] = tensor_greater_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_greater_col(this->a, bHat, this->n);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -2984,15 +2967,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
-
-        array c = [];
+        var bHat, result;
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_greater_equal_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_greater_equal_col(this->a, bHat, this->n);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3010,15 +2990,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
-
-        array c = [];
+        var bHat, result;
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_less_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_less_col(this->a, bHat, this->n);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**
@@ -3036,15 +3013,12 @@ class Matrix implements Tensor
                 . (string) b->m() . ".");
         }
 
-        var i, valueB;
-
-        array c = [];
+        var bHat, result;
 
-        for i, valueB in b->asArray() {
-            let c[] = tensor_less_equal_scalar(this->a->slice(i * this->n, this->n), valueB);
-        }
+        let bHat = b->asTensorBuffer();
+        let result = tensor_less_equal_col(this->a, bHat, this->n);
 
-        return self::quick(c);
+        return self::fromTensorBuffer(result, this->m, this->n);
     }
 
     /**

From 66ac38ab9bdf69c91388276bc6b67e75297caf7f Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Tue, 22 Sep 2026 01:30:37 -0500
Subject: [PATCH 18/51] A little nicer

---
 ext/kernel/concat.c     |  113 ---
 ext/kernel/concat.h     |    6 -
 ext/tensor/matrix.zep.c | 1509 +++++++++++++++------------------------
 ext/tensor/matrix.zep.h |   22 +-
 ext/tensor/vector.zep.c |  348 ++++-----
 tensor/matrix.zep       |  258 +++----
 tensor/vector.zep       |   57 +-
 7 files changed, 875 insertions(+), 1438 deletions(-)

diff --git a/ext/kernel/concat.c b/ext/kernel/concat.c
index f4c0795..a820634 100644
--- a/ext/kernel/concat.c
+++ b/ext/kernel/concat.c
@@ -223,119 +223,6 @@ void zephir_concat_ssvsvs(zval *result, const char *op1, uint32_t op1_len, const
 
 }
 
-void zephir_concat_ssvsvsvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, zval *op5, const char *op6, uint32_t op6_len, zval *op7, const char *op8, uint32_t op8_len, int self_var){
-
-	zval result_copy, op3_copy, op5_copy, op7_copy;
-	int use_copy = 0, use_copy3 = 0, use_copy5 = 0, use_copy7 = 0;
-	size_t offset = 0, length;
-
-	if (Z_TYPE_P(op3) != IS_STRING) {
-	   use_copy3 = zend_make_printable_zval(op3, &op3_copy);
-	   if (use_copy3) {
-	       op3 = &op3_copy;
-	   }
-	}
-
-	if (Z_TYPE_P(op5) != IS_STRING) {
-	   use_copy5 = zend_make_printable_zval(op5, &op5_copy);
-	   if (use_copy5) {
-	       op5 = &op5_copy;
-	   }
-	}
-
-	if (Z_TYPE_P(op7) != IS_STRING) {
-	   use_copy7 = zend_make_printable_zval(op7, &op7_copy);
-	   if (use_copy7) {
-	       op7 = &op7_copy;
-	   }
-	}
-
-	length = op1_len;
-	if (UNEXPECTED(op2_len > ZSTR_MAX_LEN - length)) {
-		goto zephir_concat_overflow;
-	}
-	length += op2_len;
-	if (UNEXPECTED(Z_STRLEN_P(op3) > ZSTR_MAX_LEN - length)) {
-		goto zephir_concat_overflow;
-	}
-	length += Z_STRLEN_P(op3);
-	if (UNEXPECTED(op4_len > ZSTR_MAX_LEN - length)) {
-		goto zephir_concat_overflow;
-	}
-	length += op4_len;
-	if (UNEXPECTED(Z_STRLEN_P(op5) > ZSTR_MAX_LEN - length)) {
-		goto zephir_concat_overflow;
-	}
-	length += Z_STRLEN_P(op5);
-	if (UNEXPECTED(op6_len > ZSTR_MAX_LEN - length)) {
-		goto zephir_concat_overflow;
-	}
-	length += op6_len;
-	if (UNEXPECTED(Z_STRLEN_P(op7) > ZSTR_MAX_LEN - length)) {
-		goto zephir_concat_overflow;
-	}
-	length += Z_STRLEN_P(op7);
-	if (UNEXPECTED(op8_len > ZSTR_MAX_LEN - length)) {
-		goto zephir_concat_overflow;
-	}
-	length += op8_len;
-	if (self_var) {
-
-		if (Z_TYPE_P(result) != IS_STRING) {
-			use_copy = zend_make_printable_zval(result, &result_copy);
-			if (use_copy) {
-				ZEPHIR_CPY_WRT_CTOR(result, (&result_copy));
-			}
-		}
-
-		offset = Z_STRLEN_P(result);
-		if (UNEXPECTED(offset > ZSTR_MAX_LEN - length)) {
-			goto zephir_concat_overflow;
-		}
-		length += offset;
-		Z_STR_P(result) = zend_string_realloc(Z_STR_P(result), length, 0);
-
-	} else {
-		ZVAL_STR(result, zend_string_alloc(length, 0));
-	}
-
-	memcpy(Z_STRVAL_P(result) + offset, op1, op1_len);
-	memcpy(Z_STRVAL_P(result) + offset + op1_len, op2, op2_len);
-	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len, Z_STRVAL_P(op3), Z_STRLEN_P(op3));
-	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3), op4, op4_len);
-	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len, Z_STRVAL_P(op5), Z_STRLEN_P(op5));
-	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len + Z_STRLEN_P(op5), op6, op6_len);
-	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len + Z_STRLEN_P(op5) + op6_len, Z_STRVAL_P(op7), Z_STRLEN_P(op7));
-	memcpy(Z_STRVAL_P(result) + offset + op1_len + op2_len + Z_STRLEN_P(op3) + op4_len + Z_STRLEN_P(op5) + op6_len + Z_STRLEN_P(op7), op8, op8_len);
-	Z_STRVAL_P(result)[length] = 0;
-	zend_string_forget_hash_val(Z_STR_P(result));
-	goto zephir_concat_cleanup;
-
-zephir_concat_overflow:
-	zend_throw_error(NULL, "String size overflow");
-	if (!self_var) {
-		ZVAL_UNDEF(result);
-	}
-
-zephir_concat_cleanup:
-	if (use_copy3) {
-	   zval_dtor(op3);
-	}
-
-	if (use_copy5) {
-	   zval_dtor(op5);
-	}
-
-	if (use_copy7) {
-	   zval_dtor(op7);
-	}
-
-	if (use_copy) {
-	   zval_dtor(&result_copy);
-	}
-
-}
-
 void zephir_concat_sv(zval *result, const char *op1, uint32_t op1_len, zval *op2, int self_var){
 
 	zval result_copy, op2_copy;
diff --git a/ext/kernel/concat.h b/ext/kernel/concat.h
index a98f9f7..d14d71c 100644
--- a/ext/kernel/concat.h
+++ b/ext/kernel/concat.h
@@ -19,11 +19,6 @@
 #define ZEPHIR_SCONCAT_SSVSVS(result, op1, op2, op3, op4, op5, op6) \
 	 zephir_concat_ssvsvs(result, op1, sizeof(op1)-1, op2, sizeof(op2)-1, op3, op4, sizeof(op4)-1, op5, op6, sizeof(op6)-1, 1);
 
-#define ZEPHIR_CONCAT_SSVSVSVS(result, op1, op2, op3, op4, op5, op6, op7, op8) \
-	 zephir_concat_ssvsvsvs(result, op1, sizeof(op1)-1, op2, sizeof(op2)-1, op3, op4, sizeof(op4)-1, op5, op6, sizeof(op6)-1, op7, op8, sizeof(op8)-1, 0);
-#define ZEPHIR_SCONCAT_SSVSVSVS(result, op1, op2, op3, op4, op5, op6, op7, op8) \
-	 zephir_concat_ssvsvsvs(result, op1, sizeof(op1)-1, op2, sizeof(op2)-1, op3, op4, sizeof(op4)-1, op5, op6, sizeof(op6)-1, op7, op8, sizeof(op8)-1, 1);
-
 #define ZEPHIR_CONCAT_SV(result, op1, op2) \
 	 zephir_concat_sv(result, op1, sizeof(op1)-1, op2, 0);
 #define ZEPHIR_SCONCAT_SV(result, op1, op2) \
@@ -63,7 +58,6 @@
 void zephir_concat_ss(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, int self_var);
 void zephir_concat_ssvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, int self_var);
 void zephir_concat_ssvsvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, zval *op5, const char *op6, uint32_t op6_len, int self_var);
-void zephir_concat_ssvsvsvs(zval *result, const char *op1, uint32_t op1_len, const char *op2, uint32_t op2_len, zval *op3, const char *op4, uint32_t op4_len, zval *op5, const char *op6, uint32_t op6_len, zval *op7, const char *op8, uint32_t op8_len, int self_var);
 void zephir_concat_sv(zval *result, const char *op1, uint32_t op1_len, zval *op2, int self_var);
 void zephir_concat_svsvs(zval *result, const char *op1, uint32_t op1_len, zval *op2, const char *op3, uint32_t op3_len, zval *op4, const char *op5, uint32_t op5_len, int self_var);
 void zephir_concat_vs(zval *result, zval *op1, const char *op2, uint32_t op2_len, int self_var);
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 4384cea..b1bd816 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -16,11 +16,11 @@
 #include "kernel/memory.h"
 #include "kernel/operators.h"
 #include "kernel/object.h"
+#include "kernel/array.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
-#include "kernel/array.h"
-#include "math.h"
 #include "kernel/string.h"
+#include "math.h"
 #include "kernel/math.h"
 #include "ext/spl/spl_array.h"
 #include "include/buffer.h"
@@ -67,22 +67,21 @@ ZEPHIR_INIT_CLASS(Tensor_Matrix)
 }
 
 /**
- * Factory method to build a new matrix from an array.
+ * Build a new matrix from a PHP array of arrays, validating the input.
  *
  * @param array[] a
+ * @throws \Tensor\Exceptions\InvalidArgumentException
  * @return self
  */
 PHP_METHOD(Tensor_Matrix, build)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a_param = NULL, _0, _1, _2;
+	zval *a_param = NULL, _0;
 	zval a;
 
 	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
 	ZEND_PARSE_PARAMETERS_START(0, 1)
 		Z_PARAM_OPTIONAL
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
@@ -96,17 +95,15 @@ PHP_METHOD(Tensor_Matrix, build)
 	} else {
 		zephir_get_arrval(&a, a_param);
 	}
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZVAL_LONG(&_0, 0);
-	ZVAL_LONG(&_1, 0);
-	ZVAL_BOOL(&_2, 1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &a, &_0, &_1, &_2);
+	ZVAL_BOOL(&_0, 1);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
 
 /**
- * Build a new matrix foregoing any validation for quicker instantiation.
+ * Build a new matrix from a PHP array of arrays, foregoing any row
+ * validation for quicker instantiation.
  *
  * @param array[] a
  * @return self
@@ -115,13 +112,11 @@ PHP_METHOD(Tensor_Matrix, quick)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a_param = NULL, _0, _1, _2;
+	zval *a_param = NULL, _0;
 	zval a;
 
 	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
 	ZEND_PARSE_PARAMETERS_START(0, 1)
 		Z_PARAM_OPTIONAL
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
@@ -135,11 +130,8 @@ PHP_METHOD(Tensor_Matrix, quick)
 	} else {
 		zephir_get_arrval(&a, a_param);
 	}
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZVAL_LONG(&_0, 0);
-	ZVAL_LONG(&_1, 0);
-	ZVAL_BOOL(&_2, 0);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &a, &_0, &_1, &_2);
+	ZVAL_BOOL(&_0, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -156,12 +148,11 @@ PHP_METHOD(Tensor_Matrix, fromTensorBuffer)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS;
-	zval *a, a_sub, *m_param = NULL, *n_param = NULL, _0, _1, _2;
+	zval *a, a_sub, *m_param = NULL, *n_param = NULL, _0, _1;
 
 	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
 	ZEND_PARSE_PARAMETERS_START(3, 3)
 		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
 		Z_PARAM_LONG(m)
@@ -173,8 +164,388 @@ PHP_METHOD(Tensor_Matrix, fromTensorBuffer)
 	object_init_ex(return_value, tensor_matrix_ce);
 	ZVAL_LONG(&_0, m);
 	ZVAL_LONG(&_1, n);
-	ZVAL_BOOL(&_2, 0);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, a, &_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, a, &_0, &_1);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Build a matrix by concatenating an array of TensorBuffers (each buffer
+ * representing one row) into a single contiguous buffer.
+ *
+ * @param \Tensor\TensorBuffer[] buffers
+ * @return self
+ */
+PHP_METHOD(Tensor_Matrix, fromTensorBuffers)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zephir_fcall_cache_entry *_2 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, rows;
+	zval *buffers_param = NULL, nHat, _5, b, _11, _12, zero$$3, _0$$3, _1$$3, _3$$3, _4$$3, _6$$4, _7$$5, _8$$5, _9$$5, _10$$5;
+	zval buffers;
+
+	ZVAL_UNDEF(&buffers);
+	ZVAL_UNDEF(&nHat);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&zero$$3);
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_7$$5);
+	ZVAL_UNDEF(&_8$$5);
+	ZVAL_UNDEF(&_9$$5);
+	ZVAL_UNDEF(&_10$$5);
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		ZEPHIR_Z_PARAM_ARRAY(buffers, buffers_param)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &buffers_param);
+	zephir_get_arrval(&buffers, buffers_param);
+	rows = zephir_fast_count_int(&buffers);
+	if (UNEXPECTED(rows < 1)) {
+		ZEPHIR_INIT_VAR(&zero$$3);
+		ZEPHIR_INIT_VAR(&_0$$3);
+		array_init(&_0$$3);
+		tensor_buffer_from_array(&zero$$3, &_0$$3);
+		object_init_ex(return_value, tensor_matrix_ce);
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_tensorbuffer_ce);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", &_2, 14, &zero$$3);
+		zephir_check_call_status();
+		ZVAL_LONG(&_3$$3, 0);
+		ZVAL_LONG(&_4$$3, 0);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &_1$$3, &_3$$3, &_4$$3);
+		zephir_check_call_status();
+		RETURN_MM();
+	}
+	zephir_memory_observe(&_5);
+	zephir_array_fetch_long(&_5, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 101);
+	ZEPHIR_CALL_METHOD(&nHat, &_5, "count", NULL, 0);
+	zephir_check_call_status();
+	if (UNEXPECTED(rows == 1)) {
+		zephir_memory_observe(&_6$$4);
+		zephir_array_fetch_long(&_6$$4, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 106);
+		ZEPHIR_CALL_METHOD(&b, &_6$$4, "asBuffer", NULL, 0);
+		zephir_check_call_status();
+	} else {
+		zephir_memory_observe(&_7$$5);
+		zephir_array_fetch_long(&_7$$5, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 108);
+		ZVAL_LONG(&_8$$5, 1);
+		ZEPHIR_CALL_FUNCTION(&_9$$5, "array_slice", NULL, 26, &buffers, &_8$$5);
+		zephir_check_call_status();
+		ZEPHIR_CALL_METHOD(&b, &_7$$5, "concat", NULL, 0, &_9$$5);
+		zephir_check_call_status();
+		ZEPHIR_CALL_METHOD(&_10$$5, &b, "asBuffer", NULL, 0);
+		zephir_check_call_status();
+		ZEPHIR_CPY_WRT(&b, &_10$$5);
+	}
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_INIT_VAR(&_11);
+	object_init_ex(&_11, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, &_11, "__construct", &_2, 14, &b);
+	zephir_check_call_status();
+	ZVAL_LONG(&_12, rows);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &_11, &_12, &nHat);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Build a new matrix from a PHP array of rows, each row being a PHP array
+ * of numeric elements.
+ *
+ * @param array[] a
+ * @param bool validate
+ * @throws \Tensor\Exceptions\InvalidArgumentException
+ * @return self
+ */
+PHP_METHOD(Tensor_Matrix, fromArray)
+{
+	zval _6$$4, _10$$6, _28$$11;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zephir_fcall_cache_entry *_2 = NULL, *_14 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, rows;
+	zend_bool validate, _25, _8$$5, _11$$5, _22$$5, _26$$10, _29$$10, _39$$10;
+	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, *_7, _24, buffer, _41, _42, zero$$3, _0$$3, _1$$3, _3$$3, _4$$3, _5$$4, *_17$$5, _18$$5, *_19$$5, _21$$5, _9$$6, _12$$7, _13$$7, _15$$7, _16$$7, _20$$8, _23$$9, *_34$$10, _35$$10, *_36$$10, _38$$10, _27$$11, _30$$12, _31$$12, _32$$12, _33$$12, _37$$13, _40$$14;
+	zval a, flat;
+
+	ZVAL_UNDEF(&a);
+	ZVAL_UNDEF(&flat);
+	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&firstRow);
+	ZVAL_UNDEF(&n);
+	ZVAL_UNDEF(&_24);
+	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&_41);
+	ZVAL_UNDEF(&_42);
+	ZVAL_UNDEF(&zero$$3);
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_18$$5);
+	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_9$$6);
+	ZVAL_UNDEF(&_12$$7);
+	ZVAL_UNDEF(&_13$$7);
+	ZVAL_UNDEF(&_15$$7);
+	ZVAL_UNDEF(&_16$$7);
+	ZVAL_UNDEF(&_20$$8);
+	ZVAL_UNDEF(&_23$$9);
+	ZVAL_UNDEF(&_35$$10);
+	ZVAL_UNDEF(&_38$$10);
+	ZVAL_UNDEF(&_27$$11);
+	ZVAL_UNDEF(&_30$$12);
+	ZVAL_UNDEF(&_31$$12);
+	ZVAL_UNDEF(&_32$$12);
+	ZVAL_UNDEF(&_33$$12);
+	ZVAL_UNDEF(&_37$$13);
+	ZVAL_UNDEF(&_40$$14);
+	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_10$$6);
+	ZVAL_UNDEF(&_28$$11);
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_BOOL(validate)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 1, &a_param, &validate_param);
+	zephir_get_arrval(&a, a_param);
+	if (!validate_param) {
+		validate = 1;
+	} else {
+		}
+	rows = zephir_fast_count_int(&a);
+	if (UNEXPECTED(rows < 1)) {
+		ZEPHIR_INIT_VAR(&zero$$3);
+		ZEPHIR_INIT_VAR(&_0$$3);
+		array_init(&_0$$3);
+		tensor_buffer_from_array(&zero$$3, &_0$$3);
+		object_init_ex(return_value, tensor_matrix_ce);
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_tensorbuffer_ce);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", &_2, 14, &zero$$3);
+		zephir_check_call_status();
+		ZVAL_LONG(&_3$$3, 0);
+		ZVAL_LONG(&_4$$3, 0);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &_1$$3, &_3$$3, &_4$$3);
+		zephir_check_call_status();
+		RETURN_MM();
+	}
+	ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 27, &a);
+	zephir_check_call_status();
+	if (UNEXPECTED(!(Z_TYPE_P(&firstRow) == IS_ARRAY))) {
+		ZEPHIR_INIT_VAR(&_5$$4);
+		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_6$$4);
+		ZEPHIR_CONCAT_SS(&_6$$4, "Matrix requires an", " array of arrays.");
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_6$$4);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 141);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&n);
+	ZVAL_LONG(&n, zephir_fast_count_int(&firstRow));
+	ZEPHIR_INIT_VAR(&flat);
+	array_init(&flat);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 165);
+	if (Z_TYPE_P(&a) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _7)
+		{
+			ZEPHIR_INIT_NVAR(&rowA);
+			ZVAL_COPY(&rowA, _7);
+			_8$$5 = validate;
+			if (_8$$5) {
+				_8$$5 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
+			}
+			if (UNEXPECTED(_8$$5)) {
+				ZEPHIR_INIT_NVAR(&_9$$6);
+				object_init_ex(&_9$$6, tensor_exceptions_invalidargumentexception_ce);
+				ZEPHIR_INIT_NVAR(&_10$$6);
+				ZEPHIR_CONCAT_SS(&_10$$6, "Matrix requires an", " array of arrays.");
+				ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", NULL, 3, &_10$$6);
+				zephir_check_call_status();
+				zephir_throw_exception_debug(&_9$$6, "tensor/matrix.zep", 151);
+				ZEPHIR_MM_RESTORE();
+				return;
+			}
+			_11$$5 = validate;
+			if (_11$$5) {
+				_11$$5 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
+			}
+			if (UNEXPECTED(_11$$5)) {
+				ZEPHIR_INIT_NVAR(&_12$$7);
+				object_init_ex(&_12$$7, tensor_exceptions_invalidargumentexception_ce);
+				ZEPHIR_CALL_FUNCTION(&_13$$7, "strval", &_14, 4, &n);
+				zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_15$$7);
+				ZVAL_LONG(&_15$$7, zephir_fast_count_int(&rowA));
+				ZEPHIR_INIT_NVAR(&_16$$7);
+				ZEPHIR_CONCAT_SSVSVS(&_16$$7, "The number of", " columns must be equal for all rows, ", &_13$$7, " needed but ", &_15$$7, " given.");
+				ZEPHIR_CALL_METHOD(NULL, &_12$$7, "__construct", NULL, 3, &_16$$7);
+				zephir_check_call_status();
+				zephir_throw_exception_debug(&_12$$7, "tensor/matrix.zep", 157);
+				ZEPHIR_MM_RESTORE();
+				return;
+			}
+			if (Z_TYPE_P(&rowA) == IS_STRING) {
+				ZEPHIR_INIT_NVAR(&_18$$5);
+				zephir_string_to_char_array(&_18$$5, &rowA);
+				_17$$5 = &_18$$5;
+			} else {
+				_17$$5 = &rowA;
+			}
+			zephir_is_iterable(_17$$5, 0, "tensor/matrix.zep", 163);
+			if (Z_TYPE_P(_17$$5) == IS_ARRAY) {
+				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$5), _19$$5)
+				{
+					ZEPHIR_INIT_NVAR(&valueA);
+					ZVAL_COPY(&valueA, _19$$5);
+					ZEPHIR_INIT_NVAR(&_20$$8);
+					ZVAL_DOUBLE(&_20$$8, zephir_get_doubleval(&valueA));
+					zephir_array_append(&flat, &_20$$8, PH_SEPARATE, "tensor/matrix.zep", 161);
+				} ZEND_HASH_FOREACH_END();
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _17$$5, "rewind", NULL, 0);
+				zephir_check_call_status();
+				_22$$5 = 1;
+				while (1) {
+					if (_22$$5) {
+						_22$$5 = 0;
+					} else {
+						ZEPHIR_CALL_METHOD(NULL, _17$$5, "next", NULL, 0);
+						zephir_check_call_status();
+					}
+					ZEPHIR_CALL_METHOD(&_21$$5, _17$$5, "valid", NULL, 0);
+					zephir_check_call_status();
+					if (!zend_is_true(&_21$$5)) {
+						break;
+					}
+					ZEPHIR_CALL_METHOD(&valueA, _17$$5, "current", NULL, 0);
+					zephir_check_call_status();
+						ZEPHIR_INIT_NVAR(&_23$$9);
+						ZVAL_DOUBLE(&_23$$9, zephir_get_doubleval(&valueA));
+						zephir_array_append(&flat, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 161);
+				}
+			}
+			ZEPHIR_INIT_NVAR(&valueA);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, &a, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_25 = 1;
+		while (1) {
+			if (_25) {
+				_25 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, &a, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_24, &a, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_24)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowA, &a, "current", NULL, 0);
+			zephir_check_call_status();
+				_26$$10 = validate;
+				if (_26$$10) {
+					_26$$10 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
+				}
+				if (UNEXPECTED(_26$$10)) {
+					ZEPHIR_INIT_NVAR(&_27$$11);
+					object_init_ex(&_27$$11, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_INIT_NVAR(&_28$$11);
+					ZEPHIR_CONCAT_SS(&_28$$11, "Matrix requires an", " array of arrays.");
+					ZEPHIR_CALL_METHOD(NULL, &_27$$11, "__construct", NULL, 3, &_28$$11);
+					zephir_check_call_status();
+					zephir_throw_exception_debug(&_27$$11, "tensor/matrix.zep", 151);
+					ZEPHIR_MM_RESTORE();
+					return;
+				}
+				_29$$10 = validate;
+				if (_29$$10) {
+					_29$$10 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
+				}
+				if (UNEXPECTED(_29$$10)) {
+					ZEPHIR_INIT_NVAR(&_30$$12);
+					object_init_ex(&_30$$12, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_CALL_FUNCTION(&_31$$12, "strval", &_14, 4, &n);
+					zephir_check_call_status();
+					ZEPHIR_INIT_NVAR(&_32$$12);
+					ZVAL_LONG(&_32$$12, zephir_fast_count_int(&rowA));
+					ZEPHIR_INIT_NVAR(&_33$$12);
+					ZEPHIR_CONCAT_SSVSVS(&_33$$12, "The number of", " columns must be equal for all rows, ", &_31$$12, " needed but ", &_32$$12, " given.");
+					ZEPHIR_CALL_METHOD(NULL, &_30$$12, "__construct", NULL, 3, &_33$$12);
+					zephir_check_call_status();
+					zephir_throw_exception_debug(&_30$$12, "tensor/matrix.zep", 157);
+					ZEPHIR_MM_RESTORE();
+					return;
+				}
+				if (Z_TYPE_P(&rowA) == IS_STRING) {
+					ZEPHIR_INIT_NVAR(&_35$$10);
+					zephir_string_to_char_array(&_35$$10, &rowA);
+					_34$$10 = &_35$$10;
+				} else {
+					_34$$10 = &rowA;
+				}
+				zephir_is_iterable(_34$$10, 0, "tensor/matrix.zep", 163);
+				if (Z_TYPE_P(_34$$10) == IS_ARRAY) {
+					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_34$$10), _36$$10)
+					{
+						ZEPHIR_INIT_NVAR(&valueA);
+						ZVAL_COPY(&valueA, _36$$10);
+						ZEPHIR_INIT_NVAR(&_37$$13);
+						ZVAL_DOUBLE(&_37$$13, zephir_get_doubleval(&valueA));
+						zephir_array_append(&flat, &_37$$13, PH_SEPARATE, "tensor/matrix.zep", 161);
+					} ZEND_HASH_FOREACH_END();
+				} else {
+					ZEPHIR_CALL_METHOD(NULL, _34$$10, "rewind", NULL, 0);
+					zephir_check_call_status();
+					_39$$10 = 1;
+					while (1) {
+						if (_39$$10) {
+							_39$$10 = 0;
+						} else {
+							ZEPHIR_CALL_METHOD(NULL, _34$$10, "next", NULL, 0);
+							zephir_check_call_status();
+						}
+						ZEPHIR_CALL_METHOD(&_38$$10, _34$$10, "valid", NULL, 0);
+						zephir_check_call_status();
+						if (!zend_is_true(&_38$$10)) {
+							break;
+						}
+						ZEPHIR_CALL_METHOD(&valueA, _34$$10, "current", NULL, 0);
+						zephir_check_call_status();
+							ZEPHIR_INIT_NVAR(&_40$$14);
+							ZVAL_DOUBLE(&_40$$14, zephir_get_doubleval(&valueA));
+							zephir_array_append(&flat, &_40$$14, PH_SEPARATE, "tensor/matrix.zep", 161);
+					}
+				}
+				ZEPHIR_INIT_NVAR(&valueA);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&rowA);
+	ZEPHIR_INIT_VAR(&buffer);
+	tensor_buffer_from_array(&buffer, &flat);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_INIT_VAR(&_41);
+	object_init_ex(&_41, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, &_41, "__construct", &_2, 14, &buffer);
+	zephir_check_call_status();
+	ZVAL_LONG(&_42, rows);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &_41, &_42, &n);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -217,7 +588,7 @@ PHP_METHOD(Tensor_Matrix, identity)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 92);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 181);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -263,10 +634,10 @@ PHP_METHOD(Tensor_Matrix, identity)
 						ZEPHIR_INIT_NVAR(&_10$$5);
 						ZVAL_DOUBLE(&_10$$5, 0.0);
 					}
-					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 104);
+					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 193);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 107);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 196);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
@@ -366,7 +737,7 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 	zephir_fetch_params(1, 1, 0, &elements_param);
 	zephir_get_arrval(&elements, elements_param);
 	n = zephir_fast_count_int(&elements);
-	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 26, &elements);
+	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 28, &elements);
 	zephir_check_call_status();
 	ZEPHIR_CPY_WRT(&elements, &_0);
 	ZEPHIR_INIT_VAR(&a);
@@ -406,15 +777,15 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 					ZEPHIR_INIT_NVAR(&_7$$4);
 					if (i == j) {
 						ZEPHIR_OBS_NVAR(&_7$$4);
-						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 161);
+						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 250);
 					} else {
 						ZEPHIR_INIT_NVAR(&_7$$4);
 						ZVAL_DOUBLE(&_7$$4, 0.0);
 					}
-					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 161);
+					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 250);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 164);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 253);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
@@ -471,7 +842,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 183);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 272);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -485,7 +856,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 188);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 277);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -549,7 +920,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 206);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 295);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -563,7 +934,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 211);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 300);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -588,9 +959,9 @@ PHP_METHOD(Tensor_Matrix, rand)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_12$$6);
 			ZVAL_DOUBLE(&_12$$6, zephir_safe_div_zval_long(&_10$$6, max));
-			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 223);
+			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 312);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 226);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 315);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -652,7 +1023,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 244);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 333);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -666,7 +1037,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 249);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 338);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -690,7 +1061,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZEPHIR_CALL_FUNCTION(&_10$$6, "array_pop", &_11, 9, &extras);
 			ZEPHIR_UNREF(&extras);
 			zephir_check_call_status();
-			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 264);
+			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 353);
 		}
 		while (1) {
 			if (!(zephir_fast_count_int(&rowA) < n)) {
@@ -709,20 +1080,20 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZVAL_DOUBLE(&_18$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * sin(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 272);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 361);
 			ZVAL_DOUBLE(&_20$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * cos(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 273);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 362);
 		}
 		if (zephir_fast_count_int(&rowA) > n) {
 			ZEPHIR_MAKE_REF(&rowA);
 			ZEPHIR_CALL_FUNCTION(&_21$$8, "array_pop", &_11, 9, &rowA);
 			ZEPHIR_UNREF(&rowA);
 			zephir_check_call_status();
-			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 277);
+			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 366);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 280);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 369);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -793,7 +1164,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 299);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 388);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -807,7 +1178,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 304);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 393);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -821,7 +1192,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_12$$5, "Lambda must be", " greater than or equal to 0, ", &_11$$5, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 3, &_12$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 309);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 398);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -867,9 +1238,9 @@ PHP_METHOD(Tensor_Matrix, poisson)
 			}
 			ZEPHIR_INIT_NVAR(&_21$$8);
 			ZVAL_DOUBLE(&_21$$8, (k - 1.0));
-			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 338);
+			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 427);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 341);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 430);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -924,7 +1295,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M 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", 359);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 448);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -938,7 +1309,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N 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", 364);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 453);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -965,9 +1336,9 @@ PHP_METHOD(Tensor_Matrix, uniform)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_14$$6);
 			ZVAL_DOUBLE(&_14$$6, zephir_safe_div_zval_long(&_12$$6, max));
-			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 376);
+			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 465);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 379);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 468);
 	}
 	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
 	zephir_check_call_status();
@@ -975,127 +1346,21 @@ PHP_METHOD(Tensor_Matrix, uniform)
 }
 
 /**
- * @param array[]|TensorBuffer[]|TensorBuffer a
+ * Construct a matrix from a single TensorBuffer holding the elements in
+ * row-major order together with the target dimensionality.
+ *
+ * @param \Tensor\TensorBuffer a
  * @param int m
  * @param int n
- * @param bool validate
- * @throws \Tensor\Exceptions\InvalidArgumentException
  */
 PHP_METHOD(Tensor_Matrix, __construct)
 {
-	zend_string *_8$$9, *_59$$26;
-	zend_ulong _7$$9, _58$$26;
-	zval _2$$7, _10$$12, _35$$20, _61$$29, _82$$37, _117$$48;
-	zval flat$$3;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_14 = NULL, *_27 = NULL;
-	zend_bool validate, _33$$9, _29$$10, _52$$18, _80$$26, _77$$27, _98$$35;
-	zend_long m, n, ZEPHIR_LAST_CALL_STATUS, rows$$3;
-	zval *a = NULL, a_sub, *m_param = NULL, *n_param = NULL, *validate_param = NULL, i, rowA, valueA, firstRow, nHat$$3, _0$$3, buffer$$3, _100$$3, _101$$3, _1$$7, _3$$9, *_4$$9, _5$$9, *_6$$9, _32$$9, _9$$12, _11$$11, _17$$11, _12$$13, _13$$13, _15$$13, _16$$13, _18$$15, _19$$15, _20$$15, _21$$15, *_22$$10, _23$$10, *_24$$10, _28$$10, _25$$16, _26$$16, _30$$17, _31$$17, _34$$20, _36$$19, _41$$19, _37$$21, _38$$21, _39$$21, _40$$21, _42$$23, _43$$23, _44$$23, _45$$23, *_46$$18, _47$$18, *_48$$18, _51$$18, _49$$24, _50$$24, _53$$25, _54$$25, *_55$$26, _56$$26, *_57$$26, _79$$26, _60$$29, _62$$28, _67$$28, _63$$30, _64$$30, _65$$30, _66$$30, _68$$32, _69$$32, _70$$32, _71$$32, *_72$$27, _73$$27, *_74$$27, _76$$27, _75$$33, _78$$34, _81$$37, _83$$36, _88$$36, _84$$38, _85$$38, _86$$38, _87$$38, _89$$40, _90$$40, _91$$40, _92$$40, *_93$$35, _94$$35, *_95$$35, _97$$35, _96$$41, _99$$42, _102$$45, _103$$45, _104$$45, _105$$45, _106$$46, _107$$46, _108$$46, _109$$46, _110$$44, _111$$47, _112$$47, _113$$47, _114$$47, _115$$43, _116$$48;
+	zend_long m, n;
+	zval *a, a_sub, *m_param = NULL, *n_param = NULL, _0;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&a_sub);
-	ZVAL_UNDEF(&i);
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&firstRow);
-	ZVAL_UNDEF(&nHat$$3);
-	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&buffer$$3);
-	ZVAL_UNDEF(&_100$$3);
-	ZVAL_UNDEF(&_101$$3);
-	ZVAL_UNDEF(&_1$$7);
-	ZVAL_UNDEF(&_3$$9);
-	ZVAL_UNDEF(&_5$$9);
-	ZVAL_UNDEF(&_32$$9);
-	ZVAL_UNDEF(&_9$$12);
-	ZVAL_UNDEF(&_11$$11);
-	ZVAL_UNDEF(&_17$$11);
-	ZVAL_UNDEF(&_12$$13);
-	ZVAL_UNDEF(&_13$$13);
-	ZVAL_UNDEF(&_15$$13);
-	ZVAL_UNDEF(&_16$$13);
-	ZVAL_UNDEF(&_18$$15);
-	ZVAL_UNDEF(&_19$$15);
-	ZVAL_UNDEF(&_20$$15);
-	ZVAL_UNDEF(&_21$$15);
-	ZVAL_UNDEF(&_23$$10);
-	ZVAL_UNDEF(&_28$$10);
-	ZVAL_UNDEF(&_25$$16);
-	ZVAL_UNDEF(&_26$$16);
-	ZVAL_UNDEF(&_30$$17);
-	ZVAL_UNDEF(&_31$$17);
-	ZVAL_UNDEF(&_34$$20);
-	ZVAL_UNDEF(&_36$$19);
-	ZVAL_UNDEF(&_41$$19);
-	ZVAL_UNDEF(&_37$$21);
-	ZVAL_UNDEF(&_38$$21);
-	ZVAL_UNDEF(&_39$$21);
-	ZVAL_UNDEF(&_40$$21);
-	ZVAL_UNDEF(&_42$$23);
-	ZVAL_UNDEF(&_43$$23);
-	ZVAL_UNDEF(&_44$$23);
-	ZVAL_UNDEF(&_45$$23);
-	ZVAL_UNDEF(&_47$$18);
-	ZVAL_UNDEF(&_51$$18);
-	ZVAL_UNDEF(&_49$$24);
-	ZVAL_UNDEF(&_50$$24);
-	ZVAL_UNDEF(&_53$$25);
-	ZVAL_UNDEF(&_54$$25);
-	ZVAL_UNDEF(&_56$$26);
-	ZVAL_UNDEF(&_79$$26);
-	ZVAL_UNDEF(&_60$$29);
-	ZVAL_UNDEF(&_62$$28);
-	ZVAL_UNDEF(&_67$$28);
-	ZVAL_UNDEF(&_63$$30);
-	ZVAL_UNDEF(&_64$$30);
-	ZVAL_UNDEF(&_65$$30);
-	ZVAL_UNDEF(&_66$$30);
-	ZVAL_UNDEF(&_68$$32);
-	ZVAL_UNDEF(&_69$$32);
-	ZVAL_UNDEF(&_70$$32);
-	ZVAL_UNDEF(&_71$$32);
-	ZVAL_UNDEF(&_73$$27);
-	ZVAL_UNDEF(&_76$$27);
-	ZVAL_UNDEF(&_75$$33);
-	ZVAL_UNDEF(&_78$$34);
-	ZVAL_UNDEF(&_81$$37);
-	ZVAL_UNDEF(&_83$$36);
-	ZVAL_UNDEF(&_88$$36);
-	ZVAL_UNDEF(&_84$$38);
-	ZVAL_UNDEF(&_85$$38);
-	ZVAL_UNDEF(&_86$$38);
-	ZVAL_UNDEF(&_87$$38);
-	ZVAL_UNDEF(&_89$$40);
-	ZVAL_UNDEF(&_90$$40);
-	ZVAL_UNDEF(&_91$$40);
-	ZVAL_UNDEF(&_92$$40);
-	ZVAL_UNDEF(&_94$$35);
-	ZVAL_UNDEF(&_97$$35);
-	ZVAL_UNDEF(&_96$$41);
-	ZVAL_UNDEF(&_99$$42);
-	ZVAL_UNDEF(&_102$$45);
-	ZVAL_UNDEF(&_103$$45);
-	ZVAL_UNDEF(&_104$$45);
-	ZVAL_UNDEF(&_105$$45);
-	ZVAL_UNDEF(&_106$$46);
-	ZVAL_UNDEF(&_107$$46);
-	ZVAL_UNDEF(&_108$$46);
-	ZVAL_UNDEF(&_109$$46);
-	ZVAL_UNDEF(&_110$$44);
-	ZVAL_UNDEF(&_111$$47);
-	ZVAL_UNDEF(&_112$$47);
-	ZVAL_UNDEF(&_113$$47);
-	ZVAL_UNDEF(&_114$$47);
-	ZVAL_UNDEF(&_115$$43);
-	ZVAL_UNDEF(&_116$$48);
-	ZVAL_UNDEF(&flat$$3);
-	ZVAL_UNDEF(&_2$$7);
-	ZVAL_UNDEF(&_10$$12);
-	ZVAL_UNDEF(&_35$$20);
-	ZVAL_UNDEF(&_61$$29);
-	ZVAL_UNDEF(&_82$$37);
-	ZVAL_UNDEF(&_117$$48);
+	ZVAL_UNDEF(&_0);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
@@ -1109,621 +1374,19 @@ PHP_METHOD(Tensor_Matrix, __construct)
 		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 
-	ZEND_PARSE_PARAMETERS_START(1, 4)
-		Z_PARAM_ZVAL(a)
-		Z_PARAM_OPTIONAL
+	ZEND_PARSE_PARAMETERS_START(3, 3)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
 		Z_PARAM_LONG(m)
 		Z_PARAM_LONG(n)
-		Z_PARAM_BOOL(validate)
 	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 3, &a, &m_param, &n_param, &validate_param);
-	ZEPHIR_SEPARATE_PARAM(a);
-	if (!m_param) {
-		m = 0;
-	} else {
-		}
-	if (!n_param) {
-		n = 0;
-	} else {
-		}
-	if (!validate_param) {
-		validate = 1;
-	} else {
-		}
-	if (UNEXPECTED(Z_TYPE_P(a) == IS_ARRAY)) {
-		rows$$3 = zephir_fast_count_int(a);
-		ZEPHIR_INIT_VAR(&flat$$3);
-		array_init(&flat$$3);
-		ZEPHIR_CALL_FUNCTION(&_0$$3, "current", NULL, 27, a);
-		zephir_check_call_status();
-		if (!(zephir_is_true(&_0$$3))) {
-			ZEPHIR_INIT_VAR(&firstRow);
-			array_init(&firstRow);
-		} else {
-			ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 27, a);
-			zephir_check_call_status();
-		}
-		if (Z_TYPE_P(&firstRow) == IS_OBJECT) {
-			if (UNEXPECTED(!((zephir_instance_of_ev(&firstRow, tensor_tensorbuffer_ce))))) {
-				ZEPHIR_INIT_VAR(&_1$$7);
-				object_init_ex(&_1$$7, tensor_exceptions_invalidargumentexception_ce);
-				ZEPHIR_INIT_VAR(&_2$$7);
-				ZEPHIR_CONCAT_SS(&_2$$7, "Matrix requires an", " array of arrays.");
-				ZEPHIR_CALL_METHOD(NULL, &_1$$7, "__construct", NULL, 3, &_2$$7);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_1$$7, "tensor/matrix.zep", 408);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-			ZEPHIR_CALL_METHOD(&nHat$$3, &firstRow, "count", NULL, 0);
-			zephir_check_call_status();
-			ZEPHIR_CPY_WRT(&nHat$$3, &nHat$$3);
-		} else {
-			ZEPHIR_INIT_NVAR(&nHat$$3);
-			ZVAL_LONG(&nHat$$3, zephir_fast_count_int(&firstRow));
-		}
-		if (validate) {
-			ZEPHIR_CALL_FUNCTION(&_3$$9, "array_values", NULL, 26, a);
-			zephir_check_call_status();
-			ZEPHIR_CPY_WRT(a, &_3$$9);
-			if (Z_TYPE_P(a) == IS_STRING) {
-				ZEPHIR_INIT_VAR(&_5$$9);
-				zephir_string_to_char_array(&_5$$9, a);
-				_4$$9 = &_5$$9;
-			} else {
-				_4$$9 = a;
-			}
-			zephir_is_iterable(_4$$9, 0, "tensor/matrix.zep", 447);
-			if (Z_TYPE_P(_4$$9) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_4$$9), _7$$9, _8$$9, _6$$9)
-				{
-					ZEPHIR_INIT_NVAR(&i);
-					if (_8$$9 != NULL) { 
-						ZVAL_STR_COPY(&i, _8$$9);
-					} else {
-						ZVAL_LONG(&i, _7$$9);
-					}
-					ZEPHIR_INIT_NVAR(&rowA);
-					ZVAL_COPY(&rowA, _6$$9);
-					if (Z_TYPE_P(&rowA) == IS_OBJECT) {
-						if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
-							ZEPHIR_INIT_NVAR(&_9$$12);
-							object_init_ex(&_9$$12, tensor_exceptions_invalidargumentexception_ce);
-							ZEPHIR_INIT_NVAR(&_10$$12);
-							ZEPHIR_CONCAT_SS(&_10$$12, "Matrix requires an", " array of arrays.");
-							ZEPHIR_CALL_METHOD(NULL, &_9$$12, "__construct", NULL, 3, &_10$$12);
-							zephir_check_call_status();
-							zephir_throw_exception_debug(&_9$$12, "tensor/matrix.zep", 423);
-							ZEPHIR_MM_RESTORE();
-							return;
-						}
-						ZEPHIR_CALL_METHOD(&_11$$11, &rowA, "count", NULL, 0);
-						zephir_check_call_status();
-						if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_11$$11, &nHat$$3))) {
-							ZEPHIR_INIT_NVAR(&_12$$13);
-							object_init_ex(&_12$$13, tensor_exceptions_invalidargumentexception_ce);
-							ZEPHIR_CALL_FUNCTION(&_13$$13, "strval", &_14, 4, &nHat$$3);
-							zephir_check_call_status();
-							ZEPHIR_CALL_METHOD(&_15$$13, &rowA, "count", NULL, 0);
-							zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_16$$13);
-							ZEPHIR_CONCAT_SSVSVSVS(&_16$$13, "The number of", " columns must be equal for all rows, ", &_13$$13, " needed but ", &_15$$13, " given at row offset ", &i, ".");
-							ZEPHIR_CALL_METHOD(NULL, &_12$$13, "__construct", NULL, 3, &_16$$13);
-							zephir_check_call_status();
-							zephir_throw_exception_debug(&_12$$13, "tensor/matrix.zep", 430);
-							ZEPHIR_MM_RESTORE();
-							return;
-						}
-						ZEPHIR_CALL_METHOD(&_17$$11, &rowA, "toArray", NULL, 0);
-						zephir_check_call_status();
-						ZEPHIR_CPY_WRT(&rowA, &_17$$11);
-					} else {
-						if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&nHat$$3, zephir_fast_count_int(&rowA)))) {
-							ZEPHIR_INIT_NVAR(&_18$$15);
-							object_init_ex(&_18$$15, tensor_exceptions_invalidargumentexception_ce);
-							ZEPHIR_CALL_FUNCTION(&_19$$15, "strval", &_14, 4, &nHat$$3);
-							zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_20$$15);
-							ZVAL_LONG(&_20$$15, zephir_fast_count_int(&rowA));
-							ZEPHIR_INIT_NVAR(&_21$$15);
-							ZEPHIR_CONCAT_SSVSVSVS(&_21$$15, "The number of", " columns must be equal for all rows, ", &_19$$15, " needed but ", &_20$$15, " given at row offset ", &i, ".");
-							ZEPHIR_CALL_METHOD(NULL, &_18$$15, "__construct", NULL, 3, &_21$$15);
-							zephir_check_call_status();
-							zephir_throw_exception_debug(&_18$$15, "tensor/matrix.zep", 439);
-							ZEPHIR_MM_RESTORE();
-							return;
-						}
-					}
-					if (Z_TYPE_P(&rowA) == IS_STRING) {
-						ZEPHIR_INIT_NVAR(&_23$$10);
-						zephir_string_to_char_array(&_23$$10, &rowA);
-						_22$$10 = &_23$$10;
-					} else {
-						_22$$10 = &rowA;
-					}
-					zephir_is_iterable(_22$$10, 0, "tensor/matrix.zep", 446);
-					if (Z_TYPE_P(_22$$10) == IS_ARRAY) {
-						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_22$$10), _24$$10)
-						{
-							ZEPHIR_INIT_NVAR(&valueA);
-							ZVAL_COPY(&valueA, _24$$10);
-							ZEPHIR_INIT_NVAR(&_25$$16);
-							ZEPHIR_CALL_FUNCTION(&_26$$16, "is_float", &_27, 2, &valueA);
-							zephir_check_call_status();
-							if (zephir_is_true(&_26$$16)) {
-								ZEPHIR_CPY_WRT(&_25$$16, &valueA);
-							} else {
-								ZEPHIR_INIT_NVAR(&_25$$16);
-								ZVAL_DOUBLE(&_25$$16, zephir_get_doubleval(&valueA));
-							}
-							zephir_array_append(&flat$$3, &_25$$16, PH_SEPARATE, "tensor/matrix.zep", 444);
-						} ZEND_HASH_FOREACH_END();
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _22$$10, "rewind", NULL, 0);
-						zephir_check_call_status();
-						_29$$10 = 1;
-						while (1) {
-							if (_29$$10) {
-								_29$$10 = 0;
-							} else {
-								ZEPHIR_CALL_METHOD(NULL, _22$$10, "next", NULL, 0);
-								zephir_check_call_status();
-							}
-							ZEPHIR_CALL_METHOD(&_28$$10, _22$$10, "valid", NULL, 0);
-							zephir_check_call_status();
-							if (!zend_is_true(&_28$$10)) {
-								break;
-							}
-							ZEPHIR_CALL_METHOD(&valueA, _22$$10, "current", NULL, 0);
-							zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_30$$17);
-								ZEPHIR_CALL_FUNCTION(&_31$$17, "is_float", &_27, 2, &valueA);
-								zephir_check_call_status();
-								if (zephir_is_true(&_31$$17)) {
-									ZEPHIR_CPY_WRT(&_30$$17, &valueA);
-								} else {
-									ZEPHIR_INIT_NVAR(&_30$$17);
-									ZVAL_DOUBLE(&_30$$17, zephir_get_doubleval(&valueA));
-								}
-								zephir_array_append(&flat$$3, &_30$$17, PH_SEPARATE, "tensor/matrix.zep", 444);
-						}
-					}
-					ZEPHIR_INIT_NVAR(&valueA);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _4$$9, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_33$$9 = 1;
-				while (1) {
-					if (_33$$9) {
-						_33$$9 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _4$$9, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_32$$9, _4$$9, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_32$$9)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&i, _4$$9, "key", NULL, 0);
-					zephir_check_call_status();
-					ZEPHIR_CALL_METHOD(&rowA, _4$$9, "current", NULL, 0);
-					zephir_check_call_status();
-						if (Z_TYPE_P(&rowA) == IS_OBJECT) {
-							if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
-								ZEPHIR_INIT_NVAR(&_34$$20);
-								object_init_ex(&_34$$20, tensor_exceptions_invalidargumentexception_ce);
-								ZEPHIR_INIT_NVAR(&_35$$20);
-								ZEPHIR_CONCAT_SS(&_35$$20, "Matrix requires an", " array of arrays.");
-								ZEPHIR_CALL_METHOD(NULL, &_34$$20, "__construct", NULL, 3, &_35$$20);
-								zephir_check_call_status();
-								zephir_throw_exception_debug(&_34$$20, "tensor/matrix.zep", 423);
-								ZEPHIR_MM_RESTORE();
-								return;
-							}
-							ZEPHIR_CALL_METHOD(&_36$$19, &rowA, "count", NULL, 0);
-							zephir_check_call_status();
-							if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_36$$19, &nHat$$3))) {
-								ZEPHIR_INIT_NVAR(&_37$$21);
-								object_init_ex(&_37$$21, tensor_exceptions_invalidargumentexception_ce);
-								ZEPHIR_CALL_FUNCTION(&_38$$21, "strval", &_14, 4, &nHat$$3);
-								zephir_check_call_status();
-								ZEPHIR_CALL_METHOD(&_39$$21, &rowA, "count", NULL, 0);
-								zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_40$$21);
-								ZEPHIR_CONCAT_SSVSVSVS(&_40$$21, "The number of", " columns must be equal for all rows, ", &_38$$21, " needed but ", &_39$$21, " given at row offset ", &i, ".");
-								ZEPHIR_CALL_METHOD(NULL, &_37$$21, "__construct", NULL, 3, &_40$$21);
-								zephir_check_call_status();
-								zephir_throw_exception_debug(&_37$$21, "tensor/matrix.zep", 430);
-								ZEPHIR_MM_RESTORE();
-								return;
-							}
-							ZEPHIR_CALL_METHOD(&_41$$19, &rowA, "toArray", NULL, 0);
-							zephir_check_call_status();
-							ZEPHIR_CPY_WRT(&rowA, &_41$$19);
-						} else {
-							if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&nHat$$3, zephir_fast_count_int(&rowA)))) {
-								ZEPHIR_INIT_NVAR(&_42$$23);
-								object_init_ex(&_42$$23, tensor_exceptions_invalidargumentexception_ce);
-								ZEPHIR_CALL_FUNCTION(&_43$$23, "strval", &_14, 4, &nHat$$3);
-								zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_44$$23);
-								ZVAL_LONG(&_44$$23, zephir_fast_count_int(&rowA));
-								ZEPHIR_INIT_NVAR(&_45$$23);
-								ZEPHIR_CONCAT_SSVSVSVS(&_45$$23, "The number of", " columns must be equal for all rows, ", &_43$$23, " needed but ", &_44$$23, " given at row offset ", &i, ".");
-								ZEPHIR_CALL_METHOD(NULL, &_42$$23, "__construct", NULL, 3, &_45$$23);
-								zephir_check_call_status();
-								zephir_throw_exception_debug(&_42$$23, "tensor/matrix.zep", 439);
-								ZEPHIR_MM_RESTORE();
-								return;
-							}
-						}
-						if (Z_TYPE_P(&rowA) == IS_STRING) {
-							ZEPHIR_INIT_NVAR(&_47$$18);
-							zephir_string_to_char_array(&_47$$18, &rowA);
-							_46$$18 = &_47$$18;
-						} else {
-							_46$$18 = &rowA;
-						}
-						zephir_is_iterable(_46$$18, 0, "tensor/matrix.zep", 446);
-						if (Z_TYPE_P(_46$$18) == IS_ARRAY) {
-							ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_46$$18), _48$$18)
-							{
-								ZEPHIR_INIT_NVAR(&valueA);
-								ZVAL_COPY(&valueA, _48$$18);
-								ZEPHIR_INIT_NVAR(&_49$$24);
-								ZEPHIR_CALL_FUNCTION(&_50$$24, "is_float", &_27, 2, &valueA);
-								zephir_check_call_status();
-								if (zephir_is_true(&_50$$24)) {
-									ZEPHIR_CPY_WRT(&_49$$24, &valueA);
-								} else {
-									ZEPHIR_INIT_NVAR(&_49$$24);
-									ZVAL_DOUBLE(&_49$$24, zephir_get_doubleval(&valueA));
-								}
-								zephir_array_append(&flat$$3, &_49$$24, PH_SEPARATE, "tensor/matrix.zep", 444);
-							} ZEND_HASH_FOREACH_END();
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _46$$18, "rewind", NULL, 0);
-							zephir_check_call_status();
-							_52$$18 = 1;
-							while (1) {
-								if (_52$$18) {
-									_52$$18 = 0;
-								} else {
-									ZEPHIR_CALL_METHOD(NULL, _46$$18, "next", NULL, 0);
-									zephir_check_call_status();
-								}
-								ZEPHIR_CALL_METHOD(&_51$$18, _46$$18, "valid", NULL, 0);
-								zephir_check_call_status();
-								if (!zend_is_true(&_51$$18)) {
-									break;
-								}
-								ZEPHIR_CALL_METHOD(&valueA, _46$$18, "current", NULL, 0);
-								zephir_check_call_status();
-									ZEPHIR_INIT_NVAR(&_53$$25);
-									ZEPHIR_CALL_FUNCTION(&_54$$25, "is_float", &_27, 2, &valueA);
-									zephir_check_call_status();
-									if (zephir_is_true(&_54$$25)) {
-										ZEPHIR_CPY_WRT(&_53$$25, &valueA);
-									} else {
-										ZEPHIR_INIT_NVAR(&_53$$25);
-										ZVAL_DOUBLE(&_53$$25, zephir_get_doubleval(&valueA));
-									}
-									zephir_array_append(&flat$$3, &_53$$25, PH_SEPARATE, "tensor/matrix.zep", 444);
-							}
-						}
-						ZEPHIR_INIT_NVAR(&valueA);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZEPHIR_INIT_NVAR(&i);
-		} else {
-			if (Z_TYPE_P(a) == IS_STRING) {
-				ZEPHIR_INIT_VAR(&_56$$26);
-				zephir_string_to_char_array(&_56$$26, a);
-				_55$$26 = &_56$$26;
-			} else {
-				_55$$26 = a;
-			}
-			zephir_is_iterable(_55$$26, 0, "tensor/matrix.zep", 476);
-			if (Z_TYPE_P(_55$$26) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_55$$26), _58$$26, _59$$26, _57$$26)
-				{
-					ZEPHIR_INIT_NVAR(&i);
-					if (_59$$26 != NULL) { 
-						ZVAL_STR_COPY(&i, _59$$26);
-					} else {
-						ZVAL_LONG(&i, _58$$26);
-					}
-					ZEPHIR_INIT_NVAR(&rowA);
-					ZVAL_COPY(&rowA, _57$$26);
-					if (Z_TYPE_P(&rowA) == IS_OBJECT) {
-						if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
-							ZEPHIR_INIT_NVAR(&_60$$29);
-							object_init_ex(&_60$$29, tensor_exceptions_invalidargumentexception_ce);
-							ZEPHIR_INIT_NVAR(&_61$$29);
-							ZEPHIR_CONCAT_SS(&_61$$29, "Matrix requires an", " array of arrays.");
-							ZEPHIR_CALL_METHOD(NULL, &_60$$29, "__construct", NULL, 3, &_61$$29);
-							zephir_check_call_status();
-							zephir_throw_exception_debug(&_60$$29, "tensor/matrix.zep", 452);
-							ZEPHIR_MM_RESTORE();
-							return;
-						}
-						ZEPHIR_CALL_METHOD(&_62$$28, &rowA, "count", NULL, 0);
-						zephir_check_call_status();
-						if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_62$$28, &nHat$$3))) {
-							ZEPHIR_INIT_NVAR(&_63$$30);
-							object_init_ex(&_63$$30, tensor_exceptions_invalidargumentexception_ce);
-							ZEPHIR_CALL_FUNCTION(&_64$$30, "strval", &_14, 4, &nHat$$3);
-							zephir_check_call_status();
-							ZEPHIR_CALL_METHOD(&_65$$30, &rowA, "count", NULL, 0);
-							zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_66$$30);
-							ZEPHIR_CONCAT_SSVSVSVS(&_66$$30, "The number of", " columns must be equal for all rows, ", &_64$$30, " needed but ", &_65$$30, " given at row offset ", &i, ".");
-							ZEPHIR_CALL_METHOD(NULL, &_63$$30, "__construct", NULL, 3, &_66$$30);
-							zephir_check_call_status();
-							zephir_throw_exception_debug(&_63$$30, "tensor/matrix.zep", 459);
-							ZEPHIR_MM_RESTORE();
-							return;
-						}
-						ZEPHIR_CALL_METHOD(&_67$$28, &rowA, "toArray", NULL, 0);
-						zephir_check_call_status();
-						ZEPHIR_CPY_WRT(&rowA, &_67$$28);
-					} else {
-						if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&nHat$$3, zephir_fast_count_int(&rowA)))) {
-							ZEPHIR_INIT_NVAR(&_68$$32);
-							object_init_ex(&_68$$32, tensor_exceptions_invalidargumentexception_ce);
-							ZEPHIR_CALL_FUNCTION(&_69$$32, "strval", &_14, 4, &nHat$$3);
-							zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_70$$32);
-							ZVAL_LONG(&_70$$32, zephir_fast_count_int(&rowA));
-							ZEPHIR_INIT_NVAR(&_71$$32);
-							ZEPHIR_CONCAT_SSVSVSVS(&_71$$32, "The number of", " columns must be equal for all rows, ", &_69$$32, " needed but ", &_70$$32, " given at row offset ", &i, ".");
-							ZEPHIR_CALL_METHOD(NULL, &_68$$32, "__construct", NULL, 3, &_71$$32);
-							zephir_check_call_status();
-							zephir_throw_exception_debug(&_68$$32, "tensor/matrix.zep", 468);
-							ZEPHIR_MM_RESTORE();
-							return;
-						}
-					}
-					if (Z_TYPE_P(&rowA) == IS_STRING) {
-						ZEPHIR_INIT_NVAR(&_73$$27);
-						zephir_string_to_char_array(&_73$$27, &rowA);
-						_72$$27 = &_73$$27;
-					} else {
-						_72$$27 = &rowA;
-					}
-					zephir_is_iterable(_72$$27, 0, "tensor/matrix.zep", 475);
-					if (Z_TYPE_P(_72$$27) == IS_ARRAY) {
-						ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_72$$27), _74$$27)
-						{
-							ZEPHIR_INIT_NVAR(&valueA);
-							ZVAL_COPY(&valueA, _74$$27);
-							ZEPHIR_INIT_NVAR(&_75$$33);
-							ZVAL_DOUBLE(&_75$$33, zephir_get_doubleval(&valueA));
-							zephir_array_append(&flat$$3, &_75$$33, PH_SEPARATE, "tensor/matrix.zep", 473);
-						} ZEND_HASH_FOREACH_END();
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _72$$27, "rewind", NULL, 0);
-						zephir_check_call_status();
-						_77$$27 = 1;
-						while (1) {
-							if (_77$$27) {
-								_77$$27 = 0;
-							} else {
-								ZEPHIR_CALL_METHOD(NULL, _72$$27, "next", NULL, 0);
-								zephir_check_call_status();
-							}
-							ZEPHIR_CALL_METHOD(&_76$$27, _72$$27, "valid", NULL, 0);
-							zephir_check_call_status();
-							if (!zend_is_true(&_76$$27)) {
-								break;
-							}
-							ZEPHIR_CALL_METHOD(&valueA, _72$$27, "current", NULL, 0);
-							zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_78$$34);
-								ZVAL_DOUBLE(&_78$$34, zephir_get_doubleval(&valueA));
-								zephir_array_append(&flat$$3, &_78$$34, PH_SEPARATE, "tensor/matrix.zep", 473);
-						}
-					}
-					ZEPHIR_INIT_NVAR(&valueA);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _55$$26, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_80$$26 = 1;
-				while (1) {
-					if (_80$$26) {
-						_80$$26 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _55$$26, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_79$$26, _55$$26, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_79$$26)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&i, _55$$26, "key", NULL, 0);
-					zephir_check_call_status();
-					ZEPHIR_CALL_METHOD(&rowA, _55$$26, "current", NULL, 0);
-					zephir_check_call_status();
-						if (Z_TYPE_P(&rowA) == IS_OBJECT) {
-							if (UNEXPECTED(!((zephir_instance_of_ev(&rowA, tensor_tensorbuffer_ce))))) {
-								ZEPHIR_INIT_NVAR(&_81$$37);
-								object_init_ex(&_81$$37, tensor_exceptions_invalidargumentexception_ce);
-								ZEPHIR_INIT_NVAR(&_82$$37);
-								ZEPHIR_CONCAT_SS(&_82$$37, "Matrix requires an", " array of arrays.");
-								ZEPHIR_CALL_METHOD(NULL, &_81$$37, "__construct", NULL, 3, &_82$$37);
-								zephir_check_call_status();
-								zephir_throw_exception_debug(&_81$$37, "tensor/matrix.zep", 452);
-								ZEPHIR_MM_RESTORE();
-								return;
-							}
-							ZEPHIR_CALL_METHOD(&_83$$36, &rowA, "count", NULL, 0);
-							zephir_check_call_status();
-							if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_83$$36, &nHat$$3))) {
-								ZEPHIR_INIT_NVAR(&_84$$38);
-								object_init_ex(&_84$$38, tensor_exceptions_invalidargumentexception_ce);
-								ZEPHIR_CALL_FUNCTION(&_85$$38, "strval", &_14, 4, &nHat$$3);
-								zephir_check_call_status();
-								ZEPHIR_CALL_METHOD(&_86$$38, &rowA, "count", NULL, 0);
-								zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_87$$38);
-								ZEPHIR_CONCAT_SSVSVSVS(&_87$$38, "The number of", " columns must be equal for all rows, ", &_85$$38, " needed but ", &_86$$38, " given at row offset ", &i, ".");
-								ZEPHIR_CALL_METHOD(NULL, &_84$$38, "__construct", NULL, 3, &_87$$38);
-								zephir_check_call_status();
-								zephir_throw_exception_debug(&_84$$38, "tensor/matrix.zep", 459);
-								ZEPHIR_MM_RESTORE();
-								return;
-							}
-							ZEPHIR_CALL_METHOD(&_88$$36, &rowA, "toArray", NULL, 0);
-							zephir_check_call_status();
-							ZEPHIR_CPY_WRT(&rowA, &_88$$36);
-						} else {
-							if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&nHat$$3, zephir_fast_count_int(&rowA)))) {
-								ZEPHIR_INIT_NVAR(&_89$$40);
-								object_init_ex(&_89$$40, tensor_exceptions_invalidargumentexception_ce);
-								ZEPHIR_CALL_FUNCTION(&_90$$40, "strval", &_14, 4, &nHat$$3);
-								zephir_check_call_status();
-								ZEPHIR_INIT_NVAR(&_91$$40);
-								ZVAL_LONG(&_91$$40, zephir_fast_count_int(&rowA));
-								ZEPHIR_INIT_NVAR(&_92$$40);
-								ZEPHIR_CONCAT_SSVSVSVS(&_92$$40, "The number of", " columns must be equal for all rows, ", &_90$$40, " needed but ", &_91$$40, " given at row offset ", &i, ".");
-								ZEPHIR_CALL_METHOD(NULL, &_89$$40, "__construct", NULL, 3, &_92$$40);
-								zephir_check_call_status();
-								zephir_throw_exception_debug(&_89$$40, "tensor/matrix.zep", 468);
-								ZEPHIR_MM_RESTORE();
-								return;
-							}
-						}
-						if (Z_TYPE_P(&rowA) == IS_STRING) {
-							ZEPHIR_INIT_NVAR(&_94$$35);
-							zephir_string_to_char_array(&_94$$35, &rowA);
-							_93$$35 = &_94$$35;
-						} else {
-							_93$$35 = &rowA;
-						}
-						zephir_is_iterable(_93$$35, 0, "tensor/matrix.zep", 475);
-						if (Z_TYPE_P(_93$$35) == IS_ARRAY) {
-							ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_93$$35), _95$$35)
-							{
-								ZEPHIR_INIT_NVAR(&valueA);
-								ZVAL_COPY(&valueA, _95$$35);
-								ZEPHIR_INIT_NVAR(&_96$$41);
-								ZVAL_DOUBLE(&_96$$41, zephir_get_doubleval(&valueA));
-								zephir_array_append(&flat$$3, &_96$$41, PH_SEPARATE, "tensor/matrix.zep", 473);
-							} ZEND_HASH_FOREACH_END();
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _93$$35, "rewind", NULL, 0);
-							zephir_check_call_status();
-							_98$$35 = 1;
-							while (1) {
-								if (_98$$35) {
-									_98$$35 = 0;
-								} else {
-									ZEPHIR_CALL_METHOD(NULL, _93$$35, "next", NULL, 0);
-									zephir_check_call_status();
-								}
-								ZEPHIR_CALL_METHOD(&_97$$35, _93$$35, "valid", NULL, 0);
-								zephir_check_call_status();
-								if (!zend_is_true(&_97$$35)) {
-									break;
-								}
-								ZEPHIR_CALL_METHOD(&valueA, _93$$35, "current", NULL, 0);
-								zephir_check_call_status();
-									ZEPHIR_INIT_NVAR(&_99$$42);
-									ZVAL_DOUBLE(&_99$$42, zephir_get_doubleval(&valueA));
-									zephir_array_append(&flat$$3, &_99$$42, PH_SEPARATE, "tensor/matrix.zep", 473);
-							}
-						}
-						ZEPHIR_INIT_NVAR(&valueA);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZEPHIR_INIT_NVAR(&i);
-		}
-		ZEPHIR_INIT_VAR(&buffer$$3);
-		tensor_buffer_from_array(&buffer$$3, &flat$$3);
-		ZEPHIR_INIT_VAR(&_100$$3);
-		object_init_ex(&_100$$3, tensor_tensorbuffer_ce);
-		ZEPHIR_CALL_METHOD(NULL, &_100$$3, "__construct", NULL, 14, &buffer$$3);
-		zephir_check_call_status();
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_100$$3);
-		ZVAL_UNDEF(&_101$$3);
-		ZVAL_LONG(&_101$$3, rows$$3);
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_101$$3);
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &nHat$$3);
-	} else if (zephir_instance_of_ev(a, tensor_tensorbuffer_ce)) {
-		if (UNEXPECTED(validate)) {
-			if (UNEXPECTED(m < 1)) {
-				ZEPHIR_INIT_VAR(&_102$$45);
-				object_init_ex(&_102$$45, tensor_exceptions_invalidargumentexception_ce);
-				ZVAL_LONG(&_103$$45, m);
-				ZEPHIR_CALL_FUNCTION(&_104$$45, "strval", &_14, 4, &_103$$45);
-				zephir_check_call_status();
-				ZEPHIR_INIT_VAR(&_105$$45);
-				ZEPHIR_CONCAT_SSVS(&_105$$45, "The number of rows must be", " greater than 0, ", &_104$$45, " given.");
-				ZEPHIR_CALL_METHOD(NULL, &_102$$45, "__construct", NULL, 3, &_105$$45);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_102$$45, "tensor/matrix.zep", 487);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-			if (UNEXPECTED(n < 1)) {
-				ZEPHIR_INIT_VAR(&_106$$46);
-				object_init_ex(&_106$$46, tensor_exceptions_invalidargumentexception_ce);
-				ZVAL_LONG(&_107$$46, n);
-				ZEPHIR_CALL_FUNCTION(&_108$$46, "strval", &_14, 4, &_107$$46);
-				zephir_check_call_status();
-				ZEPHIR_INIT_VAR(&_109$$46);
-				ZEPHIR_CONCAT_SSVS(&_109$$46, "The number of columns must be", " greater than 0, ", &_108$$46, " given.");
-				ZEPHIR_CALL_METHOD(NULL, &_106$$46, "__construct", NULL, 3, &_109$$46);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_106$$46, "tensor/matrix.zep", 492);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-			ZEPHIR_CALL_METHOD(&_110$$44, a, "count", NULL, 0);
-			zephir_check_call_status();
-			if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&_110$$44, (m * n)))) {
-				ZEPHIR_INIT_VAR(&_111$$47);
-				object_init_ex(&_111$$47, tensor_exceptions_invalidargumentexception_ce);
-				ZEPHIR_CALL_METHOD(&_112$$47, a, "count", NULL, 0);
-				zephir_check_call_status();
-				ZEPHIR_CALL_FUNCTION(&_113$$47, "strval", &_14, 4, &_112$$47);
-				zephir_check_call_status();
-				ZEPHIR_INIT_VAR(&_114$$47);
-				ZEPHIR_CONCAT_SSVS(&_114$$47, "The number of elements", " in the buffer must equal m times n, ", &_113$$47, " given.");
-				ZEPHIR_CALL_METHOD(NULL, &_111$$47, "__construct", NULL, 3, &_114$$47);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_111$$47, "tensor/matrix.zep", 498);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-		}
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, a);
-		ZVAL_UNDEF(&_115$$43);
-		ZVAL_LONG(&_115$$43, m);
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_115$$43);
-		ZVAL_UNDEF(&_115$$43);
-		ZVAL_LONG(&_115$$43, n);
-		zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_115$$43);
-	} else {
-		ZEPHIR_INIT_VAR(&_116$$48);
-		object_init_ex(&_116$$48, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_INIT_VAR(&_117$$48);
-		ZEPHIR_CONCAT_SS(&_117$$48, "Matrix requires an array", " or TensorBuffer object.");
-		ZEPHIR_CALL_METHOD(NULL, &_116$$48, "__construct", NULL, 3, &_117$$48);
-		zephir_check_call_status();
-		zephir_throw_exception_debug(&_116$$48, "tensor/matrix.zep", 507);
-		ZEPHIR_MM_RESTORE();
-		return;
-	}
-	ZEPHIR_MM_RESTORE();
+	zephir_fetch_params_without_memory_grow(3, 0, &a, &m_param, &n_param);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, a);
+	ZVAL_UNDEF(&_0);
+	ZVAL_LONG(&_0, m);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_0);
+	ZVAL_UNDEF(&_0);
+	ZVAL_LONG(&_0, n);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_0);
 }
 
 /**
@@ -1924,7 +1587,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Row offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 582);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 560);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1994,7 +1657,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Column offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 599);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 577);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2058,7 +1721,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 615);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 593);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2164,7 +1827,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 660);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 638);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -2172,7 +1835,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 657);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 635);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -2194,7 +1857,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 657);
+				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 635);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -2293,7 +1956,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 696);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 674);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -2301,7 +1964,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_CE_STATIC(&_7$$4, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 693);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 671);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -2323,7 +1986,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			zephir_check_call_status();
 				ZEPHIR_CALL_CE_STATIC(&_11$$5, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 693);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 671);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -2395,7 +2058,7 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 715);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 693);
 		}
 	}
 	RETURN_CTOR(&b);
@@ -2447,7 +2110,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 740);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 718);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -2455,7 +2118,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			ZVAL_COPY(&columnBuffer, _4);
 			ZEPHIR_CALL_CE_STATIC(&_5$$4, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 737);
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 715);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -2477,7 +2140,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			zephir_check_call_status();
 				ZEPHIR_CALL_CE_STATIC(&_9$$5, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 737);
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 715);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&columnBuffer);
@@ -2662,9 +2325,9 @@ PHP_METHOD(Tensor_Matrix, transpose)
 		RETURN_MM();
 	}
 	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 805);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 783);
 	ZVAL_LONG(&_1, 1);
-	ZEPHIR_CALL_FUNCTION(&_2, "array_slice", NULL, 28, &cols, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "array_slice", NULL, 26, &cols, &_1);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_0, &col, "concat", NULL, 0, &_2);
 	zephir_check_call_status();
@@ -2726,7 +2389,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 822);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 800);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2739,7 +2402,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 29, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 827);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 805);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2754,7 +2417,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 29, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 834);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 812);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2813,7 +2476,7 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 29, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 851);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 829);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2862,7 +2525,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 867);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 845);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2948,7 +2611,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 	ZEPHIR_CPY_WRT(&a, &_3);
 	pivots = 0;
 	epsilon =  (0.00000001);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 922);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 900);
 	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _4)
 	{
 		ZEPHIR_INIT_NVAR(&rowA);
@@ -2961,7 +2624,7 @@ PHP_METHOD(Tensor_Matrix, rank)
 		} else {
 			_5$$3 = &rowA;
 		}
-		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 920);
+		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 898);
 		if (Z_TYPE_P(_5$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$3), _7$$3)
 			{
@@ -3199,7 +2862,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_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/matrix.zep", 971);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 949);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3273,7 +2936,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements 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", 991);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 969);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3371,7 +3034,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 3, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 1009);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 987);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3385,7 +3048,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 3, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 1014);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 992);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3721,7 +3384,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1158);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1136);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3792,7 +3455,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1191);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1169);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3864,7 +3527,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1225);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1203);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3936,7 +3599,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1259);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1237);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4008,7 +3671,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1293);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1271);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4080,7 +3743,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1327);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1305);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4152,7 +3815,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1361);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1339);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4224,7 +3887,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1395);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1373);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4296,7 +3959,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1429);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1407);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4368,7 +4031,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1463);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1441);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4440,7 +4103,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1497);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1475);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4512,7 +4175,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1531);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1509);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -5219,7 +4882,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1717);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1695);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5227,7 +4890,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1714);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1692);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5249,7 +4912,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1714);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1692);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5305,7 +4968,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1735);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1713);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5313,7 +4976,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1732);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1710);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5335,7 +4998,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1732);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1710);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5391,7 +5054,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1753);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1731);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5399,7 +5062,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1750);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1728);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5421,7 +5084,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1750);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1728);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5477,7 +5140,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1771);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1749);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5485,7 +5148,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1768);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1746);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5507,7 +5170,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1768);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1746);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5611,7 +5274,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1810);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1788);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5635,7 +5298,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1807);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1785);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5673,7 +5336,7 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1807);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1785);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5759,7 +5422,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1824);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1802);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5780,7 +5443,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1852);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1830);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5796,7 +5459,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1842);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1820);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5808,7 +5471,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1849);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1827);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5838,7 +5501,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1842);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1820);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5850,7 +5513,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1849);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1827);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5925,7 +5588,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1868);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1846);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5945,7 +5608,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 3, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1874);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1852);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -6034,7 +5697,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 3, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1899);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1877);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -6140,7 +5803,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less 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", 1927);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1905);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6157,7 +5820,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_12 = &_10;
 	}
-	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1950);
+	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1928);
 	if (Z_TYPE_P(_12) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
 		{
@@ -6180,7 +5843,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1947);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1925);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
@@ -6217,11 +5880,11 @@ PHP_METHOD(Tensor_Matrix, round)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1947);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1925);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &b);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6363,7 +6026,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1986);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1964);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6635,7 +6298,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", 2052);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2030);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6732,7 +6395,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", 2072);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2050);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6836,7 +6499,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", 2092);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2070);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6879,10 +6542,10 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2106);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2084);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6968,7 +6631,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", 2124);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2102);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7011,10 +6674,10 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2138);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2116);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7089,7 +6752,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2162);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2140);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -7098,7 +6761,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2160);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2138);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -7121,16 +6784,16 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2160);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2138);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2165);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2143);
 		ZVAL_LONG(&_13$$6, 1);
-		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 28, &bigRows, &_13$$6);
+		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 26, &bigRows, &_13$$6);
 		zephir_check_call_status();
 		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "concat", NULL, 0, &_14$$6);
 		zephir_check_call_status();
@@ -7214,7 +6877,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2188);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2166);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7289,7 +6952,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2207);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2185);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7364,7 +7027,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2226);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2204);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7439,7 +7102,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2245);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2223);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7515,7 +7178,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2265);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2243);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7591,7 +7254,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2285);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2263);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7667,7 +7330,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2305);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2283);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7742,7 +7405,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2324);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2302);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7818,7 +7481,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2344);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2322);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7894,7 +7557,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2364);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2342);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7969,7 +7632,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2383);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2361);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8044,7 +7707,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2402);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2380);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8129,7 +7792,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2422);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2400);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8162,10 +7825,10 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_multiply(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2432);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2410);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8240,7 +7903,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2450);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2428);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8273,10 +7936,10 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_divide(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2460);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2438);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8351,7 +8014,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2478);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2456);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8384,10 +8047,10 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_add(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2488);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2466);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8462,7 +8125,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2506);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2484);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8495,10 +8158,10 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_subtract(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2516);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2494);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8573,7 +8236,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2534);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2512);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8606,10 +8269,10 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_pow(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2544);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2522);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8684,7 +8347,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2562);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2540);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8717,10 +8380,10 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_mod(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2572);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2550);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8796,7 +8459,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2591);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2569);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8829,10 +8492,10 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2601);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2579);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8907,7 +8570,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2619);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2597);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8940,10 +8603,10 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_not_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2629);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2607);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9018,7 +8681,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2647);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2625);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9051,10 +8714,10 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2657);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2635);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9129,7 +8792,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2675);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2653);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9162,10 +8825,10 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2685);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2663);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9240,7 +8903,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2703);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2681);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9273,10 +8936,10 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2713);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2691);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9352,7 +9015,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2732);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2710);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9385,10 +9048,10 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2742);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2720);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9458,7 +9121,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2760);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2738);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9540,7 +9203,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2783);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2761);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9622,7 +9285,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2806);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2784);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9704,7 +9367,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2829);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2807);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9786,7 +9449,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2852);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2830);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9868,7 +9531,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2875);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2853);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9950,7 +9613,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2898);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2876);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10032,7 +9695,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2921);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2899);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10114,7 +9777,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2944);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2922);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10196,7 +9859,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2967);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2945);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10278,7 +9941,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2990);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2968);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10360,7 +10023,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 3013);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2991);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11011,7 +10674,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3197);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3175);
 	return;
 }
 
@@ -11062,7 +10725,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3221);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3199);
 	return;
 }
 
@@ -11122,7 +10785,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3235);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3213);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -11139,7 +10802,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3240);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3218);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index dd2e935..87c0902 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -6,6 +6,8 @@ ZEPHIR_INIT_CLASS(Tensor_Matrix);
 PHP_METHOD(Tensor_Matrix, build);
 PHP_METHOD(Tensor_Matrix, quick);
 PHP_METHOD(Tensor_Matrix, fromTensorBuffer);
+PHP_METHOD(Tensor_Matrix, fromTensorBuffers);
+PHP_METHOD(Tensor_Matrix, fromArray);
 PHP_METHOD(Tensor_Matrix, identity);
 PHP_METHOD(Tensor_Matrix, zeros);
 PHP_METHOD(Tensor_Matrix, ones);
@@ -176,6 +178,15 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromtensorbuffer, 0
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromtensorbuffers, 0, 1, Tensor\\Matrix, 0)
+	ZEND_ARG_ARRAY_INFO(0, buffers, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromarray, 0, 1, Tensor\\Matrix, 0)
+	ZEND_ARG_ARRAY_INFO(0, a, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_identity, 0, 1, Tensor\\Matrix, 0)
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
@@ -221,11 +232,10 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_uniform, 0, 2, Tens
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_matrix___construct, 0, 0, 1)
-	ZEND_ARG_INFO(0, a)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, m, IS_LONG, 0, "0")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, n, IS_LONG, 0, "0")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_matrix___construct, 0, 0, 3)
+	ZEND_ARG_OBJ_INFO(0, a, Tensor\\TensorBuffer, 0)
+	ZEND_ARG_TYPE_INFO(0, m, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_shape, 0, 0, IS_ARRAY, 0)
@@ -759,6 +769,8 @@ ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, build, arginfo_tensor_matrix_build, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, quick, arginfo_tensor_matrix_quick, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, fromTensorBuffer, arginfo_tensor_matrix_fromtensorbuffer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	PHP_ME(Tensor_Matrix, fromTensorBuffers, arginfo_tensor_matrix_fromtensorbuffers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	PHP_ME(Tensor_Matrix, fromArray, arginfo_tensor_matrix_fromarray, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, identity, arginfo_tensor_matrix_identity, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, zeros, arginfo_tensor_matrix_zeros, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, ones, arginfo_tensor_matrix_ones, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 9916d35..c8921c0 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -958,27 +958,29 @@ PHP_METHOD(Tensor_Vector, asTensorBuffer)
  */
 PHP_METHOD(Tensor_Vector, asRowMatrix)
 {
-	zval _1;
-	zval _0;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&_0);
-	zephir_create_array(&_0, 1, 0);
-	zephir_memory_observe(&_1);
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC);
-	zephir_array_fast_append(&_0, &_1);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &_0);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_2, 1);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_0, &_2, &_1);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -990,77 +992,29 @@ PHP_METHOD(Tensor_Vector, asRowMatrix)
  */
 PHP_METHOD(Tensor_Vector, asColumnMatrix)
 {
-	zend_bool _6;
-	zval b, _4$$3, _7$$4;
-	zval valueA, aHat, _0, *_1, _2, *_3, _5;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_7$$4);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&aHat, &_0, "toArray", NULL, 0);
-	zephir_check_call_status();
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	if (Z_TYPE_P(&aHat) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &aHat);
-		_1 = &_2;
-	} else {
-		_1 = &aHat;
-	}
-	zephir_is_iterable(_1, 0, "tensor/vector.zep", 415);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _3);
-			ZEPHIR_INIT_NVAR(&_4$$3);
-			zephir_create_array(&_4$$3, 1, 0);
-			zephir_array_fast_append(&_4$$3, &valueA);
-			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/vector.zep", 412);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_6 = 1;
-		while (1) {
-			if (_6) {
-				_6 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_5, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_5)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_7$$4);
-				zephir_create_array(&_7$$4, 1, 0);
-				zephir_array_fast_append(&_7$$4, &valueA);
-				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 412);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueA);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &b);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_2, 1);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_0, &_1, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1076,24 +1030,21 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 PHP_METHOD(Tensor_Vector, reshape)
 {
 	zval _2$$3;
-	zval b, rowB;
 	zend_bool _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *m_param = NULL, *n_param = NULL, _3, _1$$3, _4$$4, _5$$4, _6$$4, _7$$4, _8$$6, _9$$6, _10$$6;
-	zend_long m, n, ZEPHIR_LAST_CALL_STATUS, nHat, i;
+	zval *m_param = NULL, *n_param = NULL, _3, _8, _9, _10, _1$$3, _4$$4, _5$$4, _6$$4, _7$$4;
+	zend_long m, n, ZEPHIR_LAST_CALL_STATUS, nHat;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_4$$4);
 	ZVAL_UNDEF(&_5$$4);
 	ZVAL_UNDEF(&_6$$4);
 	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_8$$6);
-	ZVAL_UNDEF(&_9$$6);
-	ZVAL_UNDEF(&_10$$6);
-	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&rowB);
 	ZVAL_UNDEF(&_2$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
@@ -1122,7 +1073,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_SS(&_2$$3, "The number of rows", " and/or columns cannot be less than 0.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 430);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 420);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1139,35 +1090,14 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_VSSVS(&_7$$4, &_6$$4, " elements", " are needed but vector only has ", &_5$$4, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 437);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 427);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	i = 0;
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	ZEPHIR_INIT_VAR(&rowB);
-	array_init(&rowB);
-	while (1) {
-		if (!(zephir_fast_count_int(&b) < m)) {
-			break;
-		}
-		ZEPHIR_INIT_NVAR(&rowB);
-		array_init(&rowB);
-		while (1) {
-			if (!(zephir_fast_count_int(&rowB) < n)) {
-				break;
-			}
-			zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			ZVAL_LONG(&_10$$6, i);
-			ZEPHIR_CALL_METHOD(&_9$$6, &_8$$6, "get", NULL, 0, &_10$$6);
-			zephir_check_call_status();
-			zephir_array_append(&rowB, &_9$$6, PH_SEPARATE, "tensor/vector.zep", 449);
-			i++;
-		}
-		zephir_array_append(&b, &rowB, PH_SEPARATE, "tensor/vector.zep", 454);
-	}
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &b);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_9, m);
+	ZVAL_LONG(&_10, n);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_8, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1343,7 +1273,7 @@ PHP_METHOD(Tensor_Vector, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " elements 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/vector.zep", 509);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 482);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1413,7 +1343,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Vector B cannot be", " larger than Vector A.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 527);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 500);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1427,7 +1357,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Stride cannot be", " less than 1, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 532);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 505);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1557,7 +1487,7 @@ PHP_METHOD(Tensor_Vector, outer)
 	} else {
 		_3 = &aHat;
 	}
-	zephir_is_iterable(_3, 0, "tensor/vector.zep", 588);
+	zephir_is_iterable(_3, 0, "tensor/vector.zep", 561);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -1565,7 +1495,7 @@ PHP_METHOD(Tensor_Vector, outer)
 			ZVAL_COPY(&valueA, _5);
 			ZEPHIR_INIT_NVAR(&rowC);
 			array_init(&rowC);
-			zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 585);
+			zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 558);
 			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _7$$3, _8$$3, _6$$3)
 			{
 				ZEPHIR_INIT_NVAR(&j);
@@ -1578,11 +1508,11 @@ PHP_METHOD(Tensor_Vector, outer)
 				ZVAL_COPY(&valueB, _6$$3);
 				ZEPHIR_INIT_NVAR(&_9$$4);
 				mul_function(&_9$$4, &valueA, &valueB);
-				zephir_array_append(&rowC, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 582);
+				zephir_array_append(&rowC, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 555);
 			} ZEND_HASH_FOREACH_END();
 			ZEPHIR_INIT_NVAR(&valueB);
 			ZEPHIR_INIT_NVAR(&j);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 585);
+			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 558);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -1604,7 +1534,7 @@ PHP_METHOD(Tensor_Vector, outer)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&rowC);
 				array_init(&rowC);
-				zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 585);
+				zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 558);
 				ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$5, _14$$5, _12$$5)
 				{
 					ZEPHIR_INIT_NVAR(&j);
@@ -1617,11 +1547,11 @@ PHP_METHOD(Tensor_Vector, outer)
 					ZVAL_COPY(&valueB, _12$$5);
 					ZEPHIR_INIT_NVAR(&_15$$6);
 					mul_function(&_15$$6, &valueA, &valueB);
-					zephir_array_append(&rowC, &_15$$6, PH_SEPARATE, "tensor/vector.zep", 582);
+					zephir_array_append(&rowC, &_15$$6, PH_SEPARATE, "tensor/vector.zep", 555);
 				} ZEND_HASH_FOREACH_END();
 				ZEPHIR_INIT_NVAR(&valueB);
 				ZEPHIR_INIT_NVAR(&j);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 585);
+				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 558);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
@@ -1722,7 +1652,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "P must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 622);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 595);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1824,7 +1754,7 @@ PHP_METHOD(Tensor_Vector, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 665);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 638);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1890,7 +1820,7 @@ PHP_METHOD(Tensor_Vector, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 695);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 668);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1957,7 +1887,7 @@ PHP_METHOD(Tensor_Vector, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 726);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 699);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2024,7 +1954,7 @@ PHP_METHOD(Tensor_Vector, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " vector from the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 757);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 730);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2091,7 +2021,7 @@ PHP_METHOD(Tensor_Vector, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " vector to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 788);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 761);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2158,7 +2088,7 @@ PHP_METHOD(Tensor_Vector, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " vector with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 819);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 792);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2225,7 +2155,7 @@ PHP_METHOD(Tensor_Vector, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 850);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 823);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2292,7 +2222,7 @@ PHP_METHOD(Tensor_Vector, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 881);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 854);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2359,7 +2289,7 @@ PHP_METHOD(Tensor_Vector, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 912);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 885);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2426,7 +2356,7 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 943);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 916);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2493,7 +2423,7 @@ PHP_METHOD(Tensor_Vector, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 974);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 947);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2560,7 +2490,7 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 1005);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 978);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2778,7 +2708,7 @@ PHP_METHOD(Tensor_Vector, log)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Log base must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1079);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1052);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3239,12 +3169,12 @@ PHP_METHOD(Tensor_Vector, median)
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
 		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1245);
+		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1218);
 	} else {
 		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1247);
+		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1220);
 		zephir_memory_observe(&_5$$4);
-		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1247);
+		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1220);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
 		ZEPHIR_INIT_NVAR(&median);
@@ -3311,7 +3241,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1264);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1237);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3329,15 +3259,15 @@ PHP_METHOD(Tensor_Vector, quantile)
 	if (ZEPHIR_LE_LONG(&_7, xHat)) {
 		zephir_memory_observe(&_8$$4);
 		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1276);
+		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1249);
 		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
 	}
 	remainder =  ((x -  (double) xHat));
 	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1281);
+	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1254);
 	t =  (zephir_get_doubleval(&_10));
 	zephir_memory_observe(&_11);
-	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1283);
+	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1256);
 	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
 }
 
@@ -3396,7 +3326,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1298);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1271);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3462,7 +3392,7 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1322);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1295);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3578,7 +3508,7 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1361);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1334);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3792,7 +3722,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1421);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1394);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3807,7 +3737,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1432);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1405);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3816,7 +3746,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1429);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1402);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3839,11 +3769,11 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1429);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1402);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3914,7 +3844,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1447);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1420);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3929,7 +3859,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1458);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1431);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3938,7 +3868,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1455);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1428);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3961,11 +3891,11 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1455);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1428);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4036,7 +3966,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1473);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1446);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4051,7 +3981,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1484);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1457);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4060,7 +3990,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1481);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1454);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4083,11 +4013,11 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1481);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1454);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4158,7 +4088,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1499);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1472);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4173,7 +4103,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1510);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1483);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4182,7 +4112,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1507);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1480);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4205,11 +4135,11 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1507);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1480);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4280,7 +4210,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1525);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1498);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4295,7 +4225,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1536);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1509);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4304,7 +4234,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1533);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1506);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4327,11 +4257,11 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1533);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1506);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4402,7 +4332,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1551);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1524);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4417,7 +4347,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1562);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1535);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4426,7 +4356,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1559);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1532);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4449,11 +4379,11 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1559);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1532);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4524,7 +4454,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1577);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1550);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4539,7 +4469,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1588);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1561);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4548,7 +4478,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1585);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1558);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4571,11 +4501,11 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1585);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1558);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4646,7 +4576,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1603);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1576);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4661,7 +4591,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1614);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1587);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4670,7 +4600,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1611);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1584);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4693,11 +4623,11 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1611);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1584);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4768,7 +4698,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1629);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1602);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4783,7 +4713,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1640);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1613);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4792,7 +4722,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1637);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1610);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4815,11 +4745,11 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1637);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1610);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4890,7 +4820,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1655);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1628);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4905,7 +4835,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1666);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1639);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4914,7 +4844,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1663);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1636);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4937,11 +4867,11 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1663);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1636);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5012,7 +4942,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1681);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1654);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5027,7 +4957,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1692);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1665);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5036,7 +4966,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1689);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1662);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5059,11 +4989,11 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1689);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1662);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5134,7 +5064,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1707);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1680);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5149,7 +5079,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1718);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1691);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5158,7 +5088,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1715);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1688);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5181,11 +5111,11 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1715);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1688);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5248,7 +5178,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1733);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1706);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5319,7 +5249,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1751);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1724);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5390,7 +5320,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1769);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1742);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5461,7 +5391,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1787);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1760);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5532,7 +5462,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1805);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1778);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5603,7 +5533,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1823);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1796);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5675,7 +5605,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1842);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1815);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5746,7 +5676,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1860);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1833);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5817,7 +5747,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1878);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1851);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5888,7 +5818,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1896);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1869);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5959,7 +5889,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1914);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1887);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6030,7 +5960,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1932);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1905);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6528,7 +6458,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2089);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2062);
 	return;
 }
 
@@ -6579,7 +6509,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2113);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2086);
 	return;
 }
 
@@ -6637,7 +6567,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 3, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2127);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2100);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 09ca267..5fc5fea 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -44,25 +44,27 @@ class Matrix implements Tensor
     protected n;
 
     /**
-     * Factory method to build a new matrix from an array.
+     * Build a new matrix from a PHP array of arrays, validating the input.
      *
      * @param array[] a
+     * @throws \Tensor\Exceptions\InvalidArgumentException
      * @return self
      */
     public static function build(const array a = []) -> <Matrix>
     {
-        return new self(a, 0, 0, true);
+        return self::fromArray(a, true);
     }
-  
+
     /**
-     * Build a new matrix foregoing any validation for quicker instantiation.
+     * Build a new matrix from a PHP array of arrays, foregoing any row
+     * validation for quicker instantiation.
      *
      * @param array[] a
      * @return self
      */
     public static function quick(const array a = []) -> <Matrix>
     {
-        return new self(a, 0, 0, false);
+        return self::fromArray(a, false);
     }
 
     /**
@@ -75,7 +77,94 @@ class Matrix implements Tensor
      */
     public static function fromTensorBuffer(<TensorBuffer> a, const int m, const int n) -> <Matrix>
     {
-        return new self(a, m, n, false);
+        return new self(a, m, n);
+    }
+
+    /**
+     * Build a matrix by concatenating an array of TensorBuffers (each buffer
+     * representing one row) into a single contiguous buffer.
+     *
+     * @param \Tensor\TensorBuffer[] buffers
+     * @return self
+     */
+    public static function fromTensorBuffers(const array buffers) -> <Matrix>
+    {
+        int rows = count(buffers);
+
+        if unlikely rows < 1 {
+            var zero = tensor_buffer_from_array([]);
+            return new self(new TensorBuffer(<Buffer> zero), 0, 0);
+        }
+
+        var nHat;
+
+        let nHat = buffers[0]->count();
+
+        var b;
+
+        if unlikely rows == 1 {
+            let b = buffers[0]->asBuffer();
+        } else {
+            let b = buffers[0]->concat(array_slice(buffers, 1));
+            let b = b->asBuffer();
+        }
+
+        return new self(new TensorBuffer(<Buffer> b), rows, nHat);
+    }
+
+    /**
+     * Build a new matrix from a PHP array of rows, each row being a PHP array
+     * of numeric elements.
+     *
+     * @param array[] a
+     * @param bool validate
+     * @throws \Tensor\Exceptions\InvalidArgumentException
+     * @return self
+     */
+    public static function fromArray(const array a, const bool validate = true) -> <Matrix>
+    {
+        int rows = count(a);
+
+        if unlikely rows < 1 {
+            var zero = tensor_buffer_from_array([]);
+            return new self(new TensorBuffer(<Buffer> zero), 0, 0);
+        }
+
+        var rowA, valueA;
+
+        var firstRow, n;
+
+        let firstRow = current(a);
+
+        if unlikely !is_array(firstRow) {
+            throw new InvalidArgumentException("Matrix requires an"
+                . " array of arrays.");
+        }
+
+        let n = count(firstRow);
+
+        array flat = [];
+
+        for rowA in a {
+            if unlikely validate && !is_array(rowA) {
+                throw new InvalidArgumentException("Matrix requires an"
+                    . " array of arrays.");
+            }
+
+            if unlikely validate && count(rowA) !== n {
+                throw new InvalidArgumentException("The number of"
+                    . " columns must be equal for all rows, "
+                    .  strval(n) . " needed but " . count(rowA) . " given.");
+            }
+
+            for valueA in rowA {
+                let flat[] = (float) valueA;
+            }
+        }
+
+        var buffer = tensor_buffer_from_array(flat);
+
+        return new self(new TensorBuffer(<Buffer> buffer), rows, n);
     }
 
     /**
@@ -383,129 +472,18 @@ class Matrix implements Tensor
     }
 
     /**
-     * @param array[]|TensorBuffer[]|TensorBuffer a
+     * Construct a matrix from a single TensorBuffer holding the elements in
+     * row-major order together with the target dimensionality.
+     *
+     * @param \Tensor\TensorBuffer a
      * @param int m
      * @param int n
-     * @param bool validate
-     * @throws \Tensor\Exceptions\InvalidArgumentException
      */
-    public function __construct(var a, const int m = 0, const int n = 0, const bool validate = true)
+    public function __construct(<TensorBuffer> a, const int m, const int n)
     {
-        var i, rowA, valueA, firstRow;
-
-        if unlikely typeof a == "array" {
-            int rows = count(a);
-
-            var nHat;
-
-            array flat = [];
-
-            let firstRow = current(a) ?: [];
-
-            if typeof firstRow == "object" {
-                if unlikely !(firstRow instanceof TensorBuffer) {
-                    throw new InvalidArgumentException("Matrix requires an"
-                        . " array of arrays.");
-                }
-
-                let nHat = firstRow->count();
-            } else {
-                let nHat = count(firstRow);
-            }
-
-            if validate {
-                let a = array_values(a);
-
-                for i, rowA in a {
-                    if typeof rowA == "object" {
-                        if unlikely !(rowA instanceof TensorBuffer) {
-                            throw new InvalidArgumentException("Matrix requires an"
-                                . " array of arrays.");
-                        }
-
-                        if unlikely rowA->count() !== nHat {
-                            throw new InvalidArgumentException("The number of"
-                                . " columns must be equal for all rows, "
-                                .  strval(nHat) . " needed but " . rowA->count()
-                                .  " given at row offset " . i . ".");
-                        }
-
-                        let rowA = rowA->toArray();
-                    } else {
-                        if unlikely count(rowA) !== nHat {
-                            throw new InvalidArgumentException("The number of"
-                                . " columns must be equal for all rows, "
-                                .  strval(nHat) . " needed but " . count(rowA)
-                                .  " given at row offset " . i . ".");
-                        }
-                    }
-
-                    for valueA in rowA {
-                        let flat[] = is_float(valueA) ? valueA : (float) valueA;
-                    }
-                }
-            } else {
-                for i, rowA in a {
-                    if typeof rowA == "object" {
-                        if unlikely !(rowA instanceof TensorBuffer) {
-                            throw new InvalidArgumentException("Matrix requires an"
-                                . " array of arrays.");
-                        }
-
-                        if unlikely rowA->count() !== nHat {
-                            throw new InvalidArgumentException("The number of"
-                                . " columns must be equal for all rows, "
-                                .  strval(nHat) . " needed but " . rowA->count()
-                                .  " given at row offset " . i . ".");
-                        }
-
-                        let rowA = rowA->toArray();
-                    } else {
-                        if unlikely count(rowA) !== nHat {
-                            throw new InvalidArgumentException("The number of"
-                                . " columns must be equal for all rows, "
-                                .  strval(nHat) . " needed but " . count(rowA)
-                                .  " given at row offset " . i . ".");
-                        }
-                    }
-
-                    for valueA in rowA {
-                        let flat[] = (float) valueA;
-                    }
-                }
-            }
-
-            var buffer = tensor_buffer_from_array(flat);
-
-            let this->a = new TensorBuffer(<Buffer> buffer);
-            let this->m = rows;
-            let this->n = nHat;
-        } elseif a instanceof TensorBuffer {
-            if unlikely validate {
-                if unlikely m < 1 {
-                    throw new InvalidArgumentException("The number of rows must be"
-                        . " greater than 0, " . strval(m) . " given.");
-                }
-
-                if unlikely n < 1 {
-                    throw new InvalidArgumentException("The number of columns must be"
-                        . " greater than 0, " . strval(n) . " given.");
-                }
-
-                if unlikely a->count() !== m * n {
-                    throw new InvalidArgumentException("The number of elements"
-                        . " in the buffer must equal m times n, "
-                        .  strval(a->count()) . " given.");
-                }
-            }
-
-            let this->a = <TensorBuffer> a;
-            let this->m = m;
-            let this->n = n;
-        } else {
-            throw new InvalidArgumentException("Matrix requires an array"
-                . " or TensorBuffer object.");
-        }
+        let this->a = a;
+        let this->m = m;
+        let this->n = n;
     }
 
     /**
@@ -1947,7 +1925,7 @@ class Matrix implements Tensor
             let b[] = rowA;
         }
 
-        return self::quick(b);
+        return self::fromTensorBuffers(b);
     }
 
     /**
@@ -2106,7 +2084,7 @@ class Matrix implements Tensor
             let c[] = bufferB->concat([bufferA]);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2138,7 +2116,7 @@ class Matrix implements Tensor
             let c[] = bufferA->concat([bufferB]);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2432,7 +2410,7 @@ class Matrix implements Tensor
             let c[] = tensor_multiply(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2460,7 +2438,7 @@ class Matrix implements Tensor
             let c[] = tensor_divide(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2488,7 +2466,7 @@ class Matrix implements Tensor
             let c[] = tensor_add(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2516,7 +2494,7 @@ class Matrix implements Tensor
             let c[] = tensor_subtract(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2544,7 +2522,7 @@ class Matrix implements Tensor
             let c[] = tensor_pow(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2572,7 +2550,7 @@ class Matrix implements Tensor
             let c[] = tensor_mod(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2601,7 +2579,7 @@ class Matrix implements Tensor
             let c[] = tensor_equal(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2629,7 +2607,7 @@ class Matrix implements Tensor
             let c[] = tensor_not_equal(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2657,7 +2635,7 @@ class Matrix implements Tensor
             let c[] = tensor_greater(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2685,7 +2663,7 @@ class Matrix implements Tensor
             let c[] = tensor_greater_equal(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2713,7 +2691,7 @@ class Matrix implements Tensor
             let c[] = tensor_less(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
@@ -2742,7 +2720,7 @@ class Matrix implements Tensor
             let c[] = tensor_less_equal(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::quick(c);
+        return self::fromTensorBuffers(c);
     }
 
     /**
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 7142282..9fb1bbe 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -392,7 +392,7 @@ class Vector implements Tensor
      */
     public function asRowMatrix() -> <Matrix>
     {
-        return Matrix::quick([this->a]);
+        return Matrix::fromTensorBuffer(this->a, 1, this->n);
     }
 
     /**
@@ -402,17 +402,7 @@ class Vector implements Tensor
      */
     public function asColumnMatrix() -> <Matrix>
     {
-        var valueA;
-
-        var aHat = this->a->toArray();
-
-        array b = [];
-
-        for valueA in aHat {
-            let b[] = [valueA];
-        }
-
-        return Matrix::quick(b);
+        return Matrix::fromTensorBuffer(this->a, this->n, 1);
     }
 
     /**
@@ -437,24 +427,7 @@ class Vector implements Tensor
                 . " are needed but vector only has " . this->n . ".");
         }
 
-        int i = 0;
-
-        array b = [];
-        array rowB = [];
-
-        while count(b) < m {
-            let rowB = [];
-
-            while count(rowB) < n {
-                let rowB[] = this->a->get(i);
-
-                let i++;
-            }
-
-            let b[] = rowB;
-        }
-
-        return Matrix::quick(b);
+        return Matrix::fromTensorBuffer(this->a, m, n);
     }
 
     /**
@@ -1429,7 +1402,7 @@ class Vector implements Tensor
             let c[] = tensor_multiply(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1455,7 +1428,7 @@ class Vector implements Tensor
             let c[] = tensor_divide(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1481,7 +1454,7 @@ class Vector implements Tensor
             let c[] = tensor_add(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1507,7 +1480,7 @@ class Vector implements Tensor
             let c[] = tensor_subtract(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1533,7 +1506,7 @@ class Vector implements Tensor
             let c[] = tensor_pow(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1559,7 +1532,7 @@ class Vector implements Tensor
             let c[] = tensor_mod(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1585,7 +1558,7 @@ class Vector implements Tensor
             let c[] = tensor_equal(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1611,7 +1584,7 @@ class Vector implements Tensor
             let c[] = tensor_not_equal(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1637,7 +1610,7 @@ class Vector implements Tensor
             let c[] = tensor_greater(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1663,7 +1636,7 @@ class Vector implements Tensor
             let c[] = tensor_greater_equal(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1689,7 +1662,7 @@ class Vector implements Tensor
             let c[] = tensor_less(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**
@@ -1715,7 +1688,7 @@ class Vector implements Tensor
             let c[] = tensor_less_equal(this->a, rowB);
         }
  
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffers(c);
     }
 
     /**

From 928d4de41aa6560bf1f271c0ae1153041b6a53c5 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Tue, 22 Sep 2026 15:28:36 -0500
Subject: [PATCH 19/51] Convert reductions and decompositions to buffer

---
 CHANGELOG.md                               |   3 +
 ext/include/linear_algebra.c               | 967 +++++++++++++++------
 ext/include/linear_algebra.h               |  16 +-
 ext/tensor/decompositions/cholesky.zep.c   |  23 +-
 ext/tensor/decompositions/eigen.zep.c      |  58 +-
 ext/tensor/decompositions/lu.zep.c         |  59 +-
 ext/tensor/decompositions/svd.zep.c        |  54 +-
 ext/tensor/matrix.zep.c                    | 380 +++-----
 ext/tensor/reductions/ref.zep.c            |  47 +-
 ext/tensor/reductions/rref.zep.c           | 216 +----
 ext/tensor/vector.zep.c                    | 298 +++----
 optimizers/TensorCholeskyOptimizer.php     |   6 +-
 optimizers/TensorEigOptimizer.php          |   6 +-
 optimizers/TensorEigSymmetricOptimizer.php |   6 +-
 optimizers/TensorIsSymmetricOptimizer.php  |  76 ++
 optimizers/TensorLuOptimizer.php           |   6 +-
 optimizers/TensorOuterOptimizer.php        |  76 ++
 optimizers/TensorRankOptimizer.php         |  76 ++
 optimizers/TensorRefOptimizer.php          |   6 +-
 optimizers/TensorRrefOptimizer.php         |  76 ++
 optimizers/TensorSvdOptimizer.php          |   6 +-
 tensor/decompositions/cholesky.zep         |   4 +-
 tensor/decompositions/eigen.zep            |   8 +-
 tensor/decompositions/lu.zep               |   8 +-
 tensor/decompositions/svd.zep              |   8 +-
 tensor/matrix.zep                          |  42 +-
 tensor/reductions/ref.zep                  |   6 +-
 tensor/reductions/rref.zep                 |  83 +-
 tensor/vector.zep                          |  22 +-
 29 files changed, 1475 insertions(+), 1167 deletions(-)
 create mode 100644 optimizers/TensorIsSymmetricOptimizer.php
 create mode 100644 optimizers/TensorOuterOptimizer.php
 create mode 100644 optimizers/TensorRankOptimizer.php
 create mode 100644 optimizers/TensorRrefOptimizer.php

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9059734..a4c31a6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Change Log
 
+- 4.0.0
+    - Performance: the linear algebra operations (REF, RREF, Cholesky, LU, eigendecomposition, SVD), `rank()`, `symmetric()`, and the vector `outer()` product now read their input from, and return their output into, `TensorBuffer`s directly instead of round-tripping through PHP arrays, eliminating the intermediate array copies
+
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
     - Implemented the Moore-Penrose pseudoinverse in the extension via SVD
diff --git a/ext/include/linear_algebra.c b/ext/include/linear_algebra.c
index 8ac960d..b9867c5 100644
--- a/ext/include/linear_algebra.c
+++ b/ext/include/linear_algebra.c
@@ -251,21 +251,19 @@ void tensor_pseudoinverse(zval * return_value, zval * a, zval * m, zval * n)
 }
 
 /**
- * Build the row echelon form of a singular matrix using row reduction,
- * mirroring the pure-PHP rowReductionMethod in REF. Pivot rows are not
- * normalised so the output matches the non-singular (LAPACK dgetrf) path.
- * 
- * @param return_value
- * @param a
+ * Reduce a (possibly singular) row echelon matrix stored in `w` in place,
+ * mirroring the pure-PHP row reduction path. Pivot rows are not normalized so
+ * the output matches the non-singular (LAPACK dgetrf) path. Returns the
+ * number of row swaps performed.
+ *
+ * @param w
  * @param m
  * @param n
+ * @return long
  */
-static void tensor_ref_singular(zval * return_value, zval * a, unsigned int m, unsigned int n)
+static long tensor_ref_singular(double * w, unsigned int m, unsigned int n)
 {
     unsigned int i, j;
-    zval * row;
-    zval rowB, b;
-    zval tuple;
 
     double epsilon = 0.00000001;
     double pivot, scale, tmp;
@@ -273,18 +271,6 @@ static void tensor_ref_singular(zval * return_value, zval * a, unsigned int m, u
     unsigned int c = 0;
     long swaps = 0;
 
-    zend_array * aa = Z_ARR_P(a);
-
-    double * w = emalloc(m * n * sizeof(double));
-
-    for (i = 0; i < m; ++i) {
-        row = zend_hash_index_find(aa, i);
-
-        for (j = 0; j < n; ++j) {
-            w[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
-    }
-
     while (r < m && c < n) {
         double * pivotRow = w + r * n;
 
@@ -326,243 +312,242 @@ static void tensor_ref_singular(zval * return_value, zval * a, unsigned int m, u
         ++c;
     }
 
-    array_init_size(&b, m);
-
-    for (i = 0; i < m; ++i) {
-        array_init_size(&rowB, n);
-
-        for (j = 0; j < n; ++j) {
-            add_next_index_double(&rowB, w[i * n + j]);
-        }
-
-        add_next_index_zval(&b, &rowB);
-    }
-
-    array_init_size(&tuple, 2);
-
-    add_next_index_zval(&tuple, &b);
-    add_next_index_long(&tuple, swaps);
-
-    RETVAL_ARR(Z_ARR(tuple));
-
-    efree(w);
+    return swaps;
 }
 
 /**
- * Compute the row echelon form (REF) of matrix A and return a tuple with the
- * reduced matrix and the number of row swaps performed.
- * 
+ * Bring a matrix in row-echelon form on a scratch buffer in place, mirroring
+ * the pure-PHP forward elimination path. Returns the number of row swaps and
+ * sets `*status` to the LAPACK result (negative on failure).
+ */
+static long tensor_ref_step(double * w, const double * orig, unsigned int m, unsigned int n, lapack_int * status);
+
+/**
+ * Compute the row echelon form (REF) of matrix A, reading A out of a
+ * TensorBuffer, and return a tuple with the reduced matrix (as a TensorBuffer)
+ * and the number of row swaps performed.
+ *
  * @param return_value
  * @param a
+ * @param m
+ * @param n
  */
-void tensor_ref(zval * return_value, zval * a)
+void tensor_ref(zval * return_value, zval * a, zval * m, zval * n)
 {
-    unsigned int i, j;
-    zval * row;
-    zval rowB, b;
-    zval tuple;
-
-    zend_array * aa = Z_ARR_P(a);
+    zend_long nbuf = 0;
+    int ok_a = 0;
+    unsigned int i;
 
-    unsigned int m = zend_array_count(aa);
-    unsigned int n = zend_array_count(Z_ARR_P(zend_hash_index_find(aa, 0)));
+    unsigned int ma = (unsigned int) zephir_get_intval(m);
+    unsigned int na = (unsigned int) zephir_get_intval(n);
 
-    double * va = emalloc(m * n * sizeof(double));
-    int * pivots = emalloc(MIN(m, n) * sizeof(int));
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
 
-    for (i = 0; i < m; ++i) {
-        row = zend_hash_index_find(aa, i);
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
 
-        for (j = 0; j < n; ++j) {
-            va[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    if (UNEXPECTED(nbuf != (zend_long) ma * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
     }
 
-    lapack_int status = LAPACKE_dgetrf(LAPACK_ROW_MAJOR, m, n, va, n, pivots);
+    double * w = emalloc(ma * na * sizeof(double));
 
-    if (status > 0) {
-        efree(va);
-        efree(pivots);
+    for (i = 0; i < ma * na; ++i) {
+        w[i] = va[i];
+    }
 
-        tensor_ref_singular(return_value, a, m, n);
+    lapack_int status;
 
-        return;
-    }
+    long swaps = tensor_ref_step(w, va, ma, na, &status);
 
-    if (status != 0) {
-        efree(va);
-        efree(pivots);
+    if (status < 0) {
+        efree(w);
 
         RETURN_NULL();
     }
-    
-    array_init_size(&b, m);
 
-    long swaps = 0;
-
-    for (i = 0; i < m; ++i) {
-        array_init_size(&rowB, n);
+    zval matrix, buf;
 
-        for (j = 0; j < i; ++j) {
-            add_next_index_double(&rowB, 0.0);
-        }
+    if (UNEXPECTED(tensor_tensorbuffer_create(&matrix, (zend_long) ma * na, &buf) == FAILURE)) {
+        efree(w);
 
-        for (j = i; j < n; ++j) {
-            add_next_index_double(&rowB, va[i * n + j]);
-        }
+        return;
+    }
 
-        add_next_index_zval(&b, &rowB);
+    {
+        double * vc = (double *) zephir_buffer_doubles(&buf);
 
-        if (i + 1 != pivots[i]) {
-            ++swaps;
+        for (i = 0; i < (zend_ulong)(ma * na); ++i) {
+            vc[i] = w[i];
         }
     }
 
+    zval_ptr_dtor(&buf);
+
+    zval tuple;
+
     array_init_size(&tuple, 2);
-    
-    add_next_index_zval(&tuple, &b);
+
+    add_next_index_zval(&tuple, &matrix);
     add_next_index_long(&tuple, swaps);
 
     RETVAL_ARR(Z_ARR(tuple));
 
-    efree(va);
-    efree(pivots);
+    efree(w);
 }
 
 /**
- * Compute the Cholesky decomposition of matrix A and return the lower triangular matrix.
- * 
+ * Compute the Cholesky decomposition of matrix A (read from a TensorBuffer)
+ * and return the lower triangular matrix as a TensorBuffer.
+ *
  * @param return_value
  * @param a
+ * @param n
  */
-void tensor_cholesky(zval * return_value, zval * a)
+void tensor_cholesky(zval * return_value, zval * a, zval * n)
 {
+    zend_long nbuf = 0;
+    int ok_a = 0;
     unsigned int i, j;
-    zval * row;
-    zval rowB, b;
 
-    zend_array * aa = Z_ARR_P(a);
+    unsigned int na = (unsigned int) zephir_get_intval(n);
 
-    unsigned int n = zend_array_count(aa);
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
+
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
 
-    double * va = emalloc(n * n * sizeof(double));
+    if (UNEXPECTED(nbuf != (zend_long) na * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
+    }
 
-    for (i = 0; i < n; ++i) {
-        row = zend_hash_index_find(aa, i);
+    double * w = emalloc(na * na * sizeof(double));
 
-        for (j = 0; j < n; ++j) {
-            va[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    for (i = 0; i < na * na; ++i) {
+        w[i] = va[i];
     }
 
-    lapack_int status = LAPACKE_dpotrf(LAPACK_ROW_MAJOR, 'L', n, va, n);
+    lapack_int status = LAPACKE_dpotrf(LAPACK_ROW_MAJOR, 'L', na, w, na);
 
     if (status != 0) {
-        efree(va);
+        efree(w);
 
         RETURN_NULL();
     }
-    
-    array_init_size(&b, n);
-
-    for (i = 0; i < n; ++i) {
-        array_init_size(&rowB, n);
 
-        for (j = 0; j <= i; ++j) {
-            add_next_index_double(&rowB, va[i * n + j]);
+    /* zero the upper triangle so the result is a proper lower triangular matrix */
+    for (i = 0; i < na; ++i) {
+        for (j = i + 1; j < na; ++j) {
+            w[i * na + j] = 0.0;
         }
+    }
 
-        for (j = i + 1; j < n; ++j) {
-            add_next_index_double(&rowB, 0.0);
-        }
+    zval l, buf;
+
+    if (UNEXPECTED(tensor_tensorbuffer_create(&l, (zend_long) na * na, &buf) == FAILURE)) {
+        efree(w);
 
-        add_next_index_zval(&b, &rowB);
+        return;
+    }
+
+    {
+        double * vc = (double *) zephir_buffer_doubles(&buf);
+
+        for (i = 0; i < (zend_ulong)(na * na); ++i) {
+            vc[i] = w[i];
+        }
     }
 
-    RETVAL_ARR(Z_ARR(b));
+    zval_ptr_dtor(&buf);
+
+    *return_value = l;
 
-    efree(va);
+    efree(w);
 }
 
 /**
- * Compute the LU factorization of matrix A and return a tuple with lower, upper, and permutation matrices.
- * 
+ * Compute the LU factorization of matrix A (read from a TensorBuffer) and
+ * return a tuple with the lower, upper, and permutation matrices (each as a
+ * TensorBuffer).
+ *
  * @param return_value
  * @param a
+ * @param n
  */
-void tensor_lu(zval * return_value, zval * a)
+void tensor_lu(zval * return_value, zval * a, zval * n)
 {
+    zend_long nbuf = 0;
+    int ok_a = 0;
     unsigned int i, j;
-    zval * row;
-    zval rowL, l, rowU, u, rowP, p;
-    zval tuple;
 
-    zend_array * aa = Z_ARR_P(a);
+    unsigned int na = (unsigned int) zephir_get_intval(n);
 
-    unsigned int n = zend_array_count(aa);
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
 
-    unsigned int * perm;
-    double * va = emalloc(n * n * sizeof(double));
-    int * pivots = emalloc(n * sizeof(int));
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
 
-    for (i = 0; i < n; ++i) {
-        row = zend_hash_index_find(aa, i);
+    if (UNEXPECTED(nbuf != (zend_long) na * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
+    }
 
-        for (j = 0; j < n; ++j) {
-            va[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    unsigned int * perm;
+    double * va_ = emalloc(na * na * sizeof(double));
+    int * pivots = emalloc(na * sizeof(int));
+
+    for (i = 0; i < na * na; ++i) {
+        va_[i] = va[i];
     }
 
-    lapack_int status = LAPACKE_dgetrf(LAPACK_ROW_MAJOR, n, n, va, n, pivots);
+    lapack_int status = LAPACKE_dgetrf(LAPACK_ROW_MAJOR, na, na, va_, na, pivots);
 
     if (status != 0) {
-        efree(va);
+        efree(va_);
         efree(pivots);
 
         RETURN_NULL();
     }
-    
-    array_init_size(&l, n);
-    array_init_size(&u, n);
-    array_init_size(&p, n);
 
-    for (i = 0; i < n; ++i) {
-        array_init_size(&rowL, n);
+    double * lbuf = emalloc(na * na * sizeof(double));
+    double * ubuf = emalloc(na * na * sizeof(double));
+    double * pbuf = emalloc(na * na * sizeof(double));
 
+    for (i = 0; i < na; ++i) {
         for (j = 0; j < i; ++j) {
-            add_next_index_double(&rowL, va[i * n + j]);
+            lbuf[i * na + j] = va_[i * na + j];
         }
 
-        add_next_index_double(&rowL, 1.0);
+        lbuf[i * na + i] = 1.0;
 
-        for (j = i + 1; j < n; ++j) {
-            add_next_index_double(&rowL, 0.0);
+        for (j = i + 1; j < na; ++j) {
+            lbuf[i * na + j] = 0.0;
         }
 
-        add_next_index_zval(&l, &rowL);
-    }
-
-    for (i = 0; i < n; ++i) {
-        array_init_size(&rowU, n);
-
         for (j = 0; j < i; ++j) {
-            add_next_index_double(&rowU, 0.0);
+            ubuf[i * na + j] = 0.0;
         }
 
-        for (j = i; j < n; ++j) {
-            add_next_index_double(&rowU, va[i * n + j]);
+        for (j = i; j < na; ++j) {
+            ubuf[i * na + j] = va_[i * na + j];
         }
-
-        add_next_index_zval(&u, &rowU);
     }
 
-    perm = emalloc(n * sizeof(unsigned int));
+    perm = emalloc(na * sizeof(unsigned int));
 
-    for (i = 0; i < n; ++i) {
+    for (i = 0; i < na; ++i) {
         perm[i] = i;
     }
 
-    for (i = 0; i < n; ++i) {
+    for (i = 0; i < na; ++i) {
         unsigned int r = (unsigned int)(pivots[i] - 1);
 
         if (r != i) {
@@ -573,22 +558,80 @@ void tensor_lu(zval * return_value, zval * a)
         }
     }
 
-    for (i = 0; i < n; ++i) {
-        array_init_size(&rowP, n);
+    for (i = 0; i < na; ++i) {
+        for (j = 0; j < na; ++j) {
+            pbuf[i * na + j] = (j == perm[i]) ? 1.0 : 0.0;
+        }
+    }
+
+    zval l, u, p, tuple;
+    zval bufL, bufU, bufP;
 
-        for (j = 0; j < n; ++j) {
-            if (j == perm[i]) {
-                add_next_index_long(&rowP, 1);
-            } else {
-                add_next_index_long(&rowP, 0);
-            }
+    if (UNEXPECTED(tensor_tensorbuffer_create(&l, (zend_long) na * na, &bufL) == FAILURE)) {
+        efree(perm);
+        efree(lbuf);
+        efree(ubuf);
+        efree(pbuf);
+        efree(va_);
+        efree(pivots);
+
+        return;
+    }
+
+    {
+        double * vc = (double *) zephir_buffer_doubles(&bufL);
+
+        for (i = 0; i < (zend_ulong)(na * na); ++i) {
+            vc[i] = lbuf[i];
         }
+    }
 
-        add_next_index_zval(&p, &rowP);
+    zval_ptr_dtor(&bufL);
+
+    if (UNEXPECTED(tensor_tensorbuffer_create(&u, (zend_long) na * na, &bufU) == FAILURE)) {
+        efree(perm);
+        efree(lbuf);
+        efree(ubuf);
+        efree(pbuf);
+        efree(va_);
+        efree(pivots);
+
+        return;
+    }
+
+    {
+        double * vc = (double *) zephir_buffer_doubles(&bufU);
+
+        for (i = 0; i < (zend_ulong)(na * na); ++i) {
+            vc[i] = ubuf[i];
+        }
     }
 
+    zval_ptr_dtor(&bufU);
+
+    if (UNEXPECTED(tensor_tensorbuffer_create(&p, (zend_long) na * na, &bufP) == FAILURE)) {
+        efree(perm);
+        efree(lbuf);
+        efree(ubuf);
+        efree(pbuf);
+        efree(va_);
+        efree(pivots);
+
+        return;
+    }
+
+    {
+        double * vc = (double *) zephir_buffer_doubles(&bufP);
+
+        for (i = 0; i < (zend_ulong)(na * na); ++i) {
+            vc[i] = pbuf[i];
+        }
+    }
+
+    zval_ptr_dtor(&bufP);
+
     array_init_size(&tuple, 3);
-    
+
     add_next_index_zval(&tuple, &l);
     add_next_index_zval(&tuple, &u);
     add_next_index_zval(&tuple, &p);
@@ -596,7 +639,10 @@ void tensor_lu(zval * return_value, zval * a)
     RETVAL_ARR(Z_ARR(tuple));
 
     efree(perm);
-    efree(va);
+    efree(lbuf);
+    efree(ubuf);
+    efree(pbuf);
+    efree(va_);
     efree(pivots);
 }
 
@@ -606,36 +652,39 @@ void tensor_lu(zval * return_value, zval * a)
  * @param return_value
  * @param a
  */
-void tensor_eig(zval * return_value, zval * a)
+void tensor_eig(zval * return_value, zval * a, zval * n)
 {
-    unsigned int i, j;
-    zval * row;
-    zval eigenvalues;
-    zval eigenvectors;
-    zval eigenvector;
-    zval tuple;
+    zend_long nbuf = 0;
+    int ok_a = 0;
+    unsigned int i;
 
-    zend_array * aa = Z_ARR_P(a);
+    unsigned int na = (unsigned int) zephir_get_intval(n);
 
-    unsigned int n = zend_array_count(aa);
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
 
-    double * va = emalloc(n * n * sizeof(double));
-    double * wr = emalloc(n * sizeof(double));
-    double * wi = emalloc(n * sizeof(double));
-    double * vr = emalloc(n * n * sizeof(double));
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
+
+    if (UNEXPECTED(nbuf != (zend_long) na * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
+    }
 
-    for (i = 0; i < n; ++i) {
-        row = zend_hash_index_find(aa, i);
+    double * w = emalloc(na * na * sizeof(double));
+    double * wr = emalloc(na * sizeof(double));
+    double * wi = emalloc(na * sizeof(double));
+    double * vr = emalloc(na * na * sizeof(double));
 
-        for (j = 0; j < n; ++j) {
-            va[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    for (i = 0; i < na * na; ++i) {
+        w[i] = va[i];
     }
 
-    lapack_int status = LAPACKE_dgeev(LAPACK_ROW_MAJOR, 'N', 'V', n, va, n, wr, wi, NULL, n, vr, n);
+    lapack_int status = LAPACKE_dgeev(LAPACK_ROW_MAJOR, 'N', 'V', na, w, na, wr, wi, NULL, na, vr, na);
 
     if (status != 0) {
-        efree(va);
+        efree(w);
         efree(wr);
         efree(wi);
         efree(vr);
@@ -643,29 +692,45 @@ void tensor_eig(zval * return_value, zval * a)
         RETURN_NULL();
     }
 
-    array_init_size(&eigenvalues, n);
-    array_init_size(&eigenvectors, n);
+    zval eigenvalues;
+
+    array_init_size(&eigenvalues, na);
 
-    for (i = 0; i < n; ++i) {
+    for (i = 0; i < na; ++i) {
         add_next_index_double(&eigenvalues, wr[i]);
+    }
 
-        array_init_size(&eigenvector, n);
+    zval eigenvectors, buf;
 
-        for (j = 0; j < n; ++j) {
-            add_next_index_double(&eigenvector, vr[i * n + j]);
-        }
+    if (UNEXPECTED(tensor_tensorbuffer_create(&eigenvectors, (zend_long) na * na, &buf) == FAILURE)) {
+        efree(w);
+        efree(wr);
+        efree(wi);
+        efree(vr);
 
-        add_next_index_zval(&eigenvectors, &eigenvector);
+        return;
     }
 
+    {
+        double * vc = (double *) zephir_buffer_doubles(&buf);
+
+        for (i = 0; i < (zend_ulong)(na * na); ++i) {
+            vc[i] = vr[i];
+        }
+    }
+
+    zval_ptr_dtor(&buf);
+
+    zval tuple;
+
     array_init_size(&tuple, 2);
-    
+
     add_next_index_zval(&tuple, &eigenvalues);
     add_next_index_zval(&tuple, &eigenvectors);
 
     RETVAL_ARR(Z_ARR(tuple));
 
-    efree(va);
+    efree(w);
     efree(wr);
     efree(wi);
     efree(vr);
@@ -677,62 +742,79 @@ void tensor_eig(zval * return_value, zval * a)
  * @param return_value
  * @param a
  */
-void tensor_eig_symmetric(zval * return_value, zval * a)
+void tensor_eig_symmetric(zval * return_value, zval * a, zval * n)
 {
-    unsigned int i, j;
-    zval * row;
-    zval eigenvalues;
-    zval eigenvectors;
-    zval eigenvector;
-    zval tuple;
+    zend_long nbuf = 0;
+    int ok_a = 0;
+    unsigned int i;
+
+    unsigned int na = (unsigned int) zephir_get_intval(n);
 
-    zend_array * aa = Z_ARR_P(a);
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
 
-    unsigned int n = zend_array_count(aa);
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
 
-    double * va = emalloc(n * n * sizeof(double));
-    double * wr = emalloc(n * sizeof(double));
+    if (UNEXPECTED(nbuf != (zend_long) na * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
+    }
 
-    for (i = 0; i < n; ++i) {
-        row = zend_hash_index_find(aa, i);
+    double * w = emalloc(na * na * sizeof(double));
+    double * wr = emalloc(na * sizeof(double));
 
-        for (j = 0; j < n; ++j) {
-            va[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    for (i = 0; i < na * na; ++i) {
+        w[i] = va[i];
     }
 
-    lapack_int status = LAPACKE_dsyev(LAPACK_ROW_MAJOR, 'V', 'U', n, va, n, wr);
+    lapack_int status = LAPACKE_dsyev(LAPACK_ROW_MAJOR, 'V', 'U', na, w, na, wr);
 
     if (status != 0) {
-        efree(va);
+        efree(w);
         efree(wr);
 
         RETURN_NULL();
     }
 
-    array_init_size(&eigenvalues, n);
-    array_init_size(&eigenvectors, n);
+    zval eigenvalues;
 
-    for (i = 0; i < n; ++i) {
+    array_init_size(&eigenvalues, na);
+
+    for (i = 0; i < na; ++i) {
         add_next_index_double(&eigenvalues, wr[i]);
+    }
 
-        array_init_size(&eigenvector, n);
+    zval eigenvectors, buf;
 
-        for (j = 0; j < n; ++j) {
-            add_next_index_double(&eigenvector, va[i * n + j]);
-        }
+    if (UNEXPECTED(tensor_tensorbuffer_create(&eigenvectors, (zend_long) na * na, &buf) == FAILURE)) {
+        efree(w);
+        efree(wr);
+
+        return;
+    }
 
-        add_next_index_zval(&eigenvectors, &eigenvector);
+    {
+        double * vc = (double *) zephir_buffer_doubles(&buf);
+
+        for (i = 0; i < (zend_ulong)(na * na); ++i) {
+            vc[i] = w[i];
+        }
     }
 
+    zval_ptr_dtor(&buf);
+
+    zval tuple;
+
     array_init_size(&tuple, 2);
-    
+
     add_next_index_zval(&tuple, &eigenvalues);
     add_next_index_zval(&tuple, &eigenvectors);
 
     RETVAL_ARR(Z_ARR(tuple));
 
-    efree(va);
+    efree(w);
     efree(wr);
 }
 
@@ -742,38 +824,41 @@ void tensor_eig_symmetric(zval * return_value, zval * a)
  * @param return_value
  * @param a
  */
-void tensor_svd(zval * return_value, zval * a)
+void tensor_svd(zval * return_value, zval * a, zval * m, zval * n)
 {
-    unsigned int i, j;
-    zval * row;
-    zval u, rowU;
-    zval s;
-    zval vt, rowVt;
-    zval tuple;
+    zend_long nbuf = 0;
+    int ok_a = 0;
+    unsigned int i;
 
-    zend_array * aa = Z_ARR_P(a);
+    unsigned int ma = (unsigned int) zephir_get_intval(m);
+    unsigned int na = (unsigned int) zephir_get_intval(n);
+    unsigned int k = MIN(ma, na);
 
-    unsigned int m = zend_array_count(aa);
-    unsigned int n = zend_array_count(Z_ARR_P(zend_hash_index_find(aa, 0)));
-    unsigned int k = MIN(m, n);
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
 
-    double * va = emalloc(m * n * sizeof(double));
-    double * vu = emalloc(m * m * sizeof(double));
-    double * vs = emalloc(k * sizeof(double));
-    double * vvt = emalloc(n * n * sizeof(double));
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
 
-    for (i = 0; i < m; ++i) {
-        row = zend_hash_index_find(aa, i);
+    if (UNEXPECTED(nbuf != (zend_long) ma * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
+    }
 
-        for (j = 0; j < n; ++j) {
-            va[i * n + j] = zephir_get_doubleval(zend_hash_index_find(Z_ARR_P(row), j));
-        }
+    double * w = emalloc(ma * na * sizeof(double));
+    double * vu = emalloc(ma * ma * sizeof(double));
+    double * vs = emalloc(k * sizeof(double));
+    double * vvt = emalloc(na * na * sizeof(double));
+
+    for (i = 0; i < ma * na; ++i) {
+        w[i] = va[i];
     }
 
-    lapack_int status = LAPACKE_dgesdd(LAPACK_ROW_MAJOR, 'A', m, n, va, n, vs, vu, m, vvt, n);
+    lapack_int status = LAPACKE_dgesdd(LAPACK_ROW_MAJOR, 'A', ma, na, w, na, vs, vu, ma, vvt, na);
 
     if (status != 0) {
-        efree(va);
+        efree(w);
         efree(vu);
         efree(vs);
         efree(vvt);
@@ -781,44 +866,388 @@ void tensor_svd(zval * return_value, zval * a)
         RETURN_NULL();
     }
 
-    array_init_size(&u, m);
-    array_init_size(&s, k);
-    array_init_size(&vt, n);
+    zval u, bufU;
+
+    if (UNEXPECTED(tensor_tensorbuffer_create(&u, (zend_long) ma * ma, &bufU) == FAILURE)) {
+        efree(w);
+        efree(vu);
+        efree(vs);
+        efree(vvt);
 
-    for (i = 0; i < m; ++i) {
-        array_init_size(&rowU, m);
+        return;
+    }
 
-        for (j = 0; j < m; ++j) {
-            add_next_index_double(&rowU, vu[i * m + j]);
-        }
+    {
+        double * vc = (double *) zephir_buffer_doubles(&bufU);
 
-        add_next_index_zval(&u, &rowU);
+        for (i = 0; i < (zend_ulong)(ma * ma); ++i) {
+            vc[i] = vu[i];
+        }
     }
-    
+
+    zval_ptr_dtor(&bufU);
+
+    zval s;
+
+    array_init_size(&s, k);
+
     for (i = 0; i < k; ++i) {
         add_next_index_double(&s, vs[i]);
     }
 
-    for (i = 0; i < n; ++i) {
-        array_init_size(&rowVt, n);
+    zval vt, bufVt;
 
-        for (j = 0; j < n; ++j) {
-            add_next_index_double(&rowVt, vvt[i * n + j]);
-        }
+    if (UNEXPECTED(tensor_tensorbuffer_create(&vt, (zend_long) na * na, &bufVt) == FAILURE)) {
+        efree(w);
+        efree(vu);
+        efree(vs);
+        efree(vvt);
 
-        add_next_index_zval(&vt, &rowVt);
+        return;
     }
 
+    {
+        double * vc = (double *) zephir_buffer_doubles(&bufVt);
+
+        for (i = 0; i < (zend_ulong)(na * na); ++i) {
+            vc[i] = vvt[i];
+        }
+    }
+
+    zval_ptr_dtor(&bufVt);
+
+    zval tuple;
+
     array_init_size(&tuple, 3);
-    
+
     add_next_index_zval(&tuple, &u);
     add_next_index_zval(&tuple, &s);
     add_next_index_zval(&tuple, &vt);
 
     RETVAL_ARR(Z_ARR(tuple));
 
-    efree(va);
+    efree(w);
     efree(vu);
     efree(vs);
     efree(vvt);
 }
+
+/**
+ * Run the forward elimination + singular row reduction used by both
+ * `tensor_ref` and `tensor_rref`. On failure (LAPACK error) sets *status to a
+ * large negative value. On success returns the number of row swaps.
+ */
+static long tensor_ref_step(double * w, const double * orig, unsigned int m, unsigned int n, lapack_int * status)
+{
+    unsigned int i, j;
+
+    int * pivots = emalloc(MIN(m, n) * sizeof(int));
+
+    *status = LAPACKE_dgetrf(LAPACK_ROW_MAJOR, m, n, w, n, pivots);
+
+    long swaps = 0;
+
+    if (*status > 0) {
+        /* Singular: `dgetrf` left `w` partially eliminated. The pure-PHP REF
+         * fallback must operate on the original (unmodified) matrix to match
+         * the previous behaviour, so restore `w` from `orig` first. */
+        for (i = 0; i < m * n; ++i) {
+            w[i] = orig[i];
+        }
+
+        swaps = tensor_ref_singular(w, m, n);
+    } else if (*status != 0) {
+        efree(pivots);
+
+        return 0;
+    } else {
+        for (i = 0; i < m; ++i) {
+            if (i + 1 != (unsigned int) pivots[i]) {
+                ++swaps;
+            }
+        }
+
+        /* `dgetrf` returns the `L + U` factor in `w`. Extract the upper
+         * triangular `U` (row-echelon form) by clearing the strictly-lower
+         * triangle, matching the original `tensor_ref` output shape. */
+        for (i = 0; i < m; ++i) {
+            unsigned int lim = i < n ? i : n;
+
+            for (j = 0; j < lim; ++j) {
+                w[i * n + j] = 0.0;
+            }
+        }
+    }
+
+    efree(pivots);
+
+    return swaps;
+}
+
+/**
+ * Compute the reduced row echelon form (RREF) of matrix A (read from a
+ * TensorBuffer). The matrix is first brought to row-echelon form via LAPACK
+ * `dgetrf` (with a singular-matrix fallback), and then Gauss-Jordan
+ * normalization and elimination are applied to produce unit pivots, matching
+ * the pure-PHP `Rref::reduce` path.
+ *
+ * @param return_value
+ * @param a
+ * @param m
+ * @param n
+ */
+void tensor_rref(zval * return_value, zval * a, zval * m, zval * n)
+{
+    zend_long nbuf = 0;
+    int ok_a = 0;
+    unsigned int i, j;
+
+    double epsilon = 0.00000001;
+
+    unsigned int ma = (unsigned int) zephir_get_intval(m);
+    unsigned int na = (unsigned int) zephir_get_intval(n);
+
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
+
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
+
+    if (UNEXPECTED(nbuf != (zend_long) ma * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
+    }
+
+    double * w = emalloc(ma * na * sizeof(double));
+
+    for (i = 0; i < ma * na; ++i) {
+        w[i] = va[i];
+    }
+
+    lapack_int status;
+
+    (void) tensor_ref_step(w, va, ma, na, &status);
+
+    if (status < 0) {
+        efree(w);
+
+        RETURN_NULL();
+    }
+
+    /* Normalize each pivot to 1 and eliminate the entries above it, matching
+     * the pure-PHP `Rref::reduce` path. */
+    unsigned int r = 0, c = 0;
+
+    while (r < ma && c < na) {
+        double pivot = w[r * na + c];
+
+        if (fabs(pivot) < epsilon) {
+            int found = 0;
+
+            for (i = c; i < na; ++i) {
+                if (fabs(w[r * na + i]) >= epsilon) {
+                    found = 1;
+                    break;
+                }
+            }
+
+            if (!found) {
+                for (j = c; j < na; ++j) {
+                    w[r * na + j] = 0.0;
+                }
+
+                ++r;
+
+                continue;
+            }
+
+            ++c;
+
+            continue;
+        }
+
+        if (pivot != 1.0) {
+            for (j = 0; j < na; ++j) {
+                w[r * na + j] /= pivot;
+            }
+        }
+
+        for (i = 0; i < r; ++i) {
+            double scale = w[i * na + c];
+
+            if (fabs(scale) >= epsilon) {
+                for (j = 0; j < na; ++j) {
+                    w[i * na + j] -= scale * w[r * na + j];
+                }
+            }
+        }
+
+        ++r;
+        ++c;
+    }
+
+    zval result, buf;
+
+    if (UNEXPECTED(tensor_tensorbuffer_create(&result, (zend_long) ma * na, &buf) == FAILURE)) {
+        efree(w);
+
+        return;
+    }
+
+    {
+        double * vc = (double *) zephir_buffer_doubles(&buf);
+
+        for (i = 0; i < (zend_ulong)(ma * na); ++i) {
+            vc[i] = w[i];
+        }
+    }
+
+    zval_ptr_dtor(&buf);
+
+    *return_value = result;
+
+    efree(w);
+}
+
+/**
+ * Return the rank of an already-reduced matrix stored in a TensorBuffer, i.e.
+ * the number of rows containing at least one non-zero element.
+ *
+ * @param return_value
+ * @param a
+ * @param m
+ * @param n
+ */
+void tensor_rank(zval * return_value, zval * a, zval * m, zval * n)
+{
+    zend_long nbuf = 0;
+    int ok_a = 0;
+    unsigned int i, j;
+
+    double epsilon = 0.00000001;
+
+    unsigned int ma = (unsigned int) zephir_get_intval(m);
+    unsigned int na = (unsigned int) zephir_get_intval(n);
+
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
+
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
+
+    if (UNEXPECTED(nbuf != (zend_long) ma * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must match the given dimensions."));
+        return;
+    }
+
+    unsigned int rank = 0;
+
+    for (i = 0; i < ma; ++i) {
+        for (j = 0; j < na; ++j) {
+            if (fabs(va[i * na + j]) >= epsilon) {
+                ++rank;
+
+                break;
+            }
+        }
+    }
+
+    RETVAL_LONG((zend_long) rank);
+}
+
+/**
+ * Return whether the square matrix A (read from a TensorBuffer) is symmetric
+ * with respect to a strict element-wise equality (matching PHP `!=`).
+ *
+ * @param return_value
+ * @param a
+ * @param n
+ */
+void tensor_is_symmetric(zval * return_value, zval * a, zval * n)
+{
+    zend_long nbuf = 0;
+    int ok_a = 0;
+
+    unsigned int i, j;
+
+    unsigned int na = (unsigned int) zephir_get_intval(n);
+
+    double * va = tensor_tensorbuffer_doubles(a, &nbuf, &ok_a);
+
+    if (UNEXPECTED(!ok_a)) {
+        return;
+    }
+
+    if (UNEXPECTED(nbuf != (zend_long) na * na)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffer must be square."));
+        return;
+    }
+
+    for (i = 0; i < na - 1; ++i) {
+        for (j = i + 1; j < na; ++j) {
+            if (va[i * na + j] != va[j * na + i]) {
+                RETVAL_FALSE;
+
+                return;
+            }
+        }
+    }
+
+    RETVAL_TRUE;
+}
+
+/**
+ * Compute the outer product of two vectors (read from TensorBuffers) and
+ * return the resulting matrix as a TensorBuffer.
+ *
+ * @param return_value
+ * @param a
+ * @param b
+ * @param na
+ * @param nb
+ */
+void tensor_outer(zval * return_value, zval * a, zval * b, zval * na, zval * nb)
+{
+    zend_long nbufa = 0, nbufb = 0;
+    int ok_a = 0, ok_b = 0;
+
+    unsigned int naHat = (unsigned int) zephir_get_intval(na);
+    unsigned int nbHat = (unsigned int) zephir_get_intval(nb);
+
+    double * va = tensor_tensorbuffer_doubles(a, &nbufa, &ok_a);
+    double * vb = tensor_tensorbuffer_doubles(b, &nbufb, &ok_b);
+
+    if (UNEXPECTED(!ok_a || !ok_b)) {
+        return;
+    }
+
+    if (UNEXPECTED(nbufa != (zend_long) naHat || nbufb != (zend_long) nbHat)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Buffer lengths must match the given dimensions."));
+        return;
+    }
+
+    zval product, buf;
+
+    if (UNEXPECTED(tensor_tensorbuffer_create(&product, (zend_long) naHat * nbHat, &buf) == FAILURE)) {
+        return;
+    }
+
+    {
+        double * vc = (double *) zephir_buffer_doubles(&buf);
+        unsigned int i, j;
+
+        for (i = 0; i < naHat; ++i) {
+            for (j = 0; j < nbHat; ++j) {
+                vc[i * nbHat + j] = va[i] * vb[j];
+            }
+        }
+    }
+
+    zval_ptr_dtor(&buf);
+
+    *return_value = product;
+}
diff --git a/ext/include/linear_algebra.h b/ext/include/linear_algebra.h
index f144aec..4f98775 100644
--- a/ext/include/linear_algebra.h
+++ b/ext/include/linear_algebra.h
@@ -9,11 +9,15 @@ void tensor_dot(zval * return_value, zval * a, zval * b);
 void tensor_inverse(zval * return_value, zval * a, zval * n);
 void tensor_pseudoinverse(zval * return_value, zval * a, zval * m, zval * n);
 
-void tensor_ref(zval * return_value, zval * a);
-void tensor_cholesky(zval * return_value, zval * a);
-void tensor_lu(zval * return_value, zval * a);
-void tensor_eig(zval * return_value, zval * a);
-void tensor_eig_symmetric(zval * return_value, zval * a);
-void tensor_svd(zval * return_value, zval * a);
+void tensor_ref(zval * return_value, zval * a, zval * m, zval * n);
+void tensor_rref(zval * return_value, zval * a, zval * m, zval * n);
+void tensor_rank(zval * return_value, zval * a, zval * m, zval * n);
+void tensor_is_symmetric(zval * return_value, zval * a, zval * n);
+void tensor_cholesky(zval * return_value, zval * a, zval * n);
+void tensor_lu(zval * return_value, zval * a, zval * n);
+void tensor_eig(zval * return_value, zval * a, zval * n);
+void tensor_eig_symmetric(zval * return_value, zval * a, zval * n);
+void tensor_svd(zval * return_value, zval * a, zval * m, zval * n);
+void tensor_outer(zval * return_value, zval * a, zval * b, zval * na, zval * nb);
 
 #endif
\ No newline at end of file
diff --git a/ext/tensor/decompositions/cholesky.zep.c b/ext/tensor/decompositions/cholesky.zep.c
index d2ec0a9..51af189 100644
--- a/ext/tensor/decompositions/cholesky.zep.c
+++ b/ext/tensor/decompositions/cholesky.zep.c
@@ -55,13 +55,16 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a, a_sub, _0, l, _4, _5, _1$$3, _2$$3, _3$$3;
+	zval *a, a_sub, _0, l, _4, _5, _6, _7, _8, _1$$3, _2$$3, _3$$3;
 
 	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&l);
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
@@ -71,12 +74,12 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (!(zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -87,17 +90,23 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&l);
-	ZEPHIR_CALL_METHOD(&_4, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, a, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	tensor_cholesky(&l, &_4);
+	ZEPHIR_CALL_METHOD(&_5, a, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_cholesky(&l, &_4, &_5);
 	if (Z_TYPE_P(&l) == IS_NULL) {
 		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_runtimeexception_ce, "Failed to decompose matrix.", "tensor/decompositions/cholesky.zep", 43);
 		return;
 	}
 	object_init_ex(return_value, tensor_decompositions_cholesky_ce);
-	ZEPHIR_CALL_CE_STATIC(&_5, tensor_matrix_ce, "quick", NULL, 0, &l);
+	ZEPHIR_CALL_METHOD(&_7, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_8, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_CE_STATIC(&_6, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &l, &_7, &_8);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/eigen.zep.c b/ext/tensor/decompositions/eigen.zep.c
index d42b223..02db1b3 100644
--- a/ext/tensor/decompositions/eigen.zep.c
+++ b/ext/tensor/decompositions/eigen.zep.c
@@ -62,27 +62,33 @@ ZEPHIR_INIT_CLASS(Tensor_Decompositions_Eigen)
  */
 PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 {
-	zval eig, _7;
+	zval eig, _9, _11;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zend_bool symmetric;
-	zval *a, a_sub, *symmetric_param = NULL, _0, result, _6, eigenvalues, eigenvectors, _8, _9, _1$$3, _2$$3, _3$$3, _4$$4, _5$$5;
+	zval *a, a_sub, *symmetric_param = NULL, _0, result, _8, eigenvalues, _10, eigenvectors, _12, _13, _14, _15, _1$$3, _2$$3, _3$$3, _4$$4, _5$$4, _6$$5, _7$$5;
 
 	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&result);
-	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&eigenvalues);
+	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&eigenvectors);
-	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_15);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&_5$$5);
+	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_6$$5);
+	ZVAL_UNDEF(&_7$$5);
 	ZVAL_UNDEF(&eig);
-	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_11);
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 		Z_PARAM_OPTIONAL
@@ -95,12 +101,12 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 		symmetric = 0;
 	} else {
 		}
-	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -112,14 +118,18 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	}
 	if (symmetric) {
 		ZEPHIR_INIT_VAR(&result);
-		ZEPHIR_CALL_METHOD(&_4$$4, a, "asarray", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_4$$4, a, "asTensorBuffer", NULL, 0);
 		zephir_check_call_status();
-		tensor_eig_symmetric(&result, &_4$$4);
+		ZEPHIR_CALL_METHOD(&_5$$4, a, "n", NULL, 0);
+		zephir_check_call_status();
+		tensor_eig_symmetric(&result, &_4$$4, &_5$$4);
 	} else {
 		ZEPHIR_INIT_NVAR(&result);
-		ZEPHIR_CALL_METHOD(&_5$$5, a, "asarray", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_6$$5, a, "asTensorBuffer", NULL, 0);
+		zephir_check_call_status();
+		ZEPHIR_CALL_METHOD(&_7$$5, a, "n", NULL, 0);
 		zephir_check_call_status();
-		tensor_eig(&result, &_5$$5);
+		tensor_eig(&result, &_6$$5, &_7$$5);
 	}
 	if (Z_TYPE_P(&result) == IS_NULL) {
 		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_runtimeexception_ce, "Failed to decompose matrix.", "tensor/decompositions/eigen.zep", 60);
@@ -127,15 +137,21 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	}
 	ZEPHIR_INIT_VAR(&eig);
 	array_init(&eig);
-	ZEPHIR_CPY_WRT(&_6, &result);
-	zephir_get_arrval(&_7, &_6);
-	ZEPHIR_CPY_WRT(&eig, &_7);
-	zephir_memory_observe(&eigenvalues);
-	zephir_array_fetch_long(&eigenvalues, &eig, 0, PH_NOISY, "tensor/decompositions/eigen.zep", 67);
-	zephir_array_fetch_long(&_9, &eig, 1, PH_NOISY | PH_READONLY, "tensor/decompositions/eigen.zep", 68);
-	ZEPHIR_CALL_CE_STATIC(&_8, tensor_matrix_ce, "quick", NULL, 0, &_9);
+	ZEPHIR_CPY_WRT(&_8, &result);
+	zephir_get_arrval(&_9, &_8);
+	ZEPHIR_CPY_WRT(&eig, &_9);
+	zephir_memory_observe(&_10);
+	zephir_array_fetch_long(&_10, &eig, 0, PH_NOISY, "tensor/decompositions/eigen.zep", 67);
+	zephir_get_arrval(&_11, &_10);
+	ZEPHIR_CPY_WRT(&eigenvalues, &_11);
+	zephir_array_fetch_long(&_13, &eig, 1, PH_NOISY | PH_READONLY, "tensor/decompositions/eigen.zep", 68);
+	ZEPHIR_CALL_METHOD(&_14, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_15, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_CE_STATIC(&_12, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_13, &_14, &_15);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&eigenvectors, &_8, "transpose", NULL, 0);
+	ZEPHIR_CALL_METHOD(&eigenvectors, &_12, "transpose", NULL, 0);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_eigen_ce);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 22, &eigenvalues, &eigenvectors);
diff --git a/ext/tensor/decompositions/lu.zep.c b/ext/tensor/decompositions/lu.zep.c
index fe2704e..4ecc9aa 100644
--- a/ext/tensor/decompositions/lu.zep.c
+++ b/ext/tensor/decompositions/lu.zep.c
@@ -67,39 +67,46 @@ ZEPHIR_INIT_CLASS(Tensor_Decompositions_Lu)
  */
 PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 {
-	zval lup, _6;
+	zval lup, _7;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a, a_sub, _0, result, _4, _5, l, _7, u, _8, p, _9, _1$$3, _2$$3, _3$$3;
+	zval *a, a_sub, _0, result, _4, _5, _6, l, _8, _9, _10, u, _11, _12, _13, p, _14, _15, _16, _1$$3, _2$$3, _3$$3;
 
 	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
 	ZVAL_UNDEF(&l);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&u);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&p);
 	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&u);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&p);
+	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_16);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&lup);
-	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	ZEPHIR_CALL_METHOD(&_0, a, "issquare", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "isSquare", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(!zephir_is_true(&_0))) {
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapestring", NULL, 0);
+		ZEPHIR_CALL_METHOD(&_2$$3, a, "shapeString", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
@@ -110,26 +117,40 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 		return;
 	}
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_4, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_4, a, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	tensor_lu(&result, &_4);
+	ZEPHIR_CALL_METHOD(&_5, a, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_lu(&result, &_4, &_5);
 	if (Z_TYPE_P(&result) == IS_NULL) {
 		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_runtimeexception_ce, "Failed to decompose matrix.", "tensor/decompositions/lu.zep", 58);
 		return;
 	}
 	ZEPHIR_INIT_VAR(&lup);
 	array_init(&lup);
-	ZEPHIR_CPY_WRT(&_5, &result);
-	zephir_get_arrval(&_6, &_5);
-	ZEPHIR_CPY_WRT(&lup, &_6);
-	zephir_array_fetch_long(&_7, &lup, 0, PH_NOISY | PH_READONLY, "tensor/decompositions/lu.zep", 65);
-	ZEPHIR_CALL_CE_STATIC(&l, tensor_matrix_ce, "quick", NULL, 0, &_7);
+	ZEPHIR_CPY_WRT(&_6, &result);
+	zephir_get_arrval(&_7, &_6);
+	ZEPHIR_CPY_WRT(&lup, &_7);
+	zephir_array_fetch_long(&_8, &lup, 0, PH_NOISY | PH_READONLY, "tensor/decompositions/lu.zep", 65);
+	ZEPHIR_CALL_METHOD(&_9, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_10, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_CE_STATIC(&l, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_8, &_9, &_10);
+	zephir_check_call_status();
+	zephir_array_fetch_long(&_11, &lup, 1, PH_NOISY | PH_READONLY, "tensor/decompositions/lu.zep", 66);
+	ZEPHIR_CALL_METHOD(&_12, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_13, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_CE_STATIC(&u, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_11, &_12, &_13);
+	zephir_check_call_status();
+	zephir_array_fetch_long(&_14, &lup, 2, PH_NOISY | PH_READONLY, "tensor/decompositions/lu.zep", 67);
+	ZEPHIR_CALL_METHOD(&_15, a, "n", NULL, 0);
 	zephir_check_call_status();
-	zephir_array_fetch_long(&_8, &lup, 1, PH_NOISY | PH_READONLY, "tensor/decompositions/lu.zep", 66);
-	ZEPHIR_CALL_CE_STATIC(&u, tensor_matrix_ce, "quick", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(&_16, a, "n", NULL, 0);
 	zephir_check_call_status();
-	zephir_array_fetch_long(&_9, &lup, 2, PH_NOISY | PH_READONLY, "tensor/decompositions/lu.zep", 67);
-	ZEPHIR_CALL_CE_STATIC(&p, tensor_matrix_ce, "quick", NULL, 0, &_9);
+	ZEPHIR_CALL_CE_STATIC(&p, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_14, &_15, &_16);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_lu_ce);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &l, &u, &p);
diff --git a/ext/tensor/decompositions/svd.zep.c b/ext/tensor/decompositions/svd.zep.c
index bb34fce..338e28e 100644
--- a/ext/tensor/decompositions/svd.zep.c
+++ b/ext/tensor/decompositions/svd.zep.c
@@ -62,22 +62,30 @@ ZEPHIR_INIT_CLASS(Tensor_Decompositions_Svd)
  */
 PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 {
-	zval usvT, _2;
+	zval usvT, _4, _9;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a, a_sub, result, _0, _1, u, _3, singularValues, vT, _4;
+	zval *a, a_sub, result, _0, _1, _2, _3, u, _5, _6, _7, singularValues, _8, vT, _10, _11, _12;
 
 	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&u);
+	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&u);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&singularValues);
+	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&vT);
-	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_12);
 	ZVAL_UNDEF(&usvT);
-	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_9);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
@@ -85,25 +93,39 @@ PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_0, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	tensor_svd(&result, &_0);
+	ZEPHIR_CALL_METHOD(&_1, a, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_2, a, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_svd(&result, &_0, &_1, &_2);
 	if (Z_TYPE_P(&result) == IS_NULL) {
 		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_runtimeexception_ce, "Failed to decompose matrix.", "tensor/decompositions/svd.zep", 48);
 		return;
 	}
 	ZEPHIR_INIT_VAR(&usvT);
 	array_init(&usvT);
-	ZEPHIR_CPY_WRT(&_1, &result);
-	zephir_get_arrval(&_2, &_1);
-	ZEPHIR_CPY_WRT(&usvT, &_2);
-	zephir_array_fetch_long(&_3, &usvT, 0, PH_NOISY | PH_READONLY, "tensor/decompositions/svd.zep", 55);
-	ZEPHIR_CALL_CE_STATIC(&u, tensor_matrix_ce, "quick", NULL, 0, &_3);
+	ZEPHIR_CPY_WRT(&_3, &result);
+	zephir_get_arrval(&_4, &_3);
+	ZEPHIR_CPY_WRT(&usvT, &_4);
+	zephir_array_fetch_long(&_5, &usvT, 0, PH_NOISY | PH_READONLY, "tensor/decompositions/svd.zep", 55);
+	ZEPHIR_CALL_METHOD(&_6, a, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_7, a, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_CE_STATIC(&u, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_5, &_6, &_7);
+	zephir_check_call_status();
+	zephir_memory_observe(&_8);
+	zephir_array_fetch_long(&_8, &usvT, 1, PH_NOISY, "tensor/decompositions/svd.zep", 56);
+	zephir_get_arrval(&_9, &_8);
+	ZEPHIR_CPY_WRT(&singularValues, &_9);
+	zephir_array_fetch_long(&_10, &usvT, 2, PH_NOISY | PH_READONLY, "tensor/decompositions/svd.zep", 57);
+	ZEPHIR_CALL_METHOD(&_11, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_12, a, "n", NULL, 0);
 	zephir_check_call_status();
-	zephir_memory_observe(&singularValues);
-	zephir_array_fetch_long(&singularValues, &usvT, 1, PH_NOISY, "tensor/decompositions/svd.zep", 56);
-	zephir_array_fetch_long(&_4, &usvT, 2, PH_NOISY | PH_READONLY, "tensor/decompositions/svd.zep", 57);
-	ZEPHIR_CALL_CE_STATIC(&vT, tensor_matrix_ce, "quick", NULL, 0, &_4);
+	ZEPHIR_CALL_CE_STATIC(&vT, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_10, &_11, &_12);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_svd_ce);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 24, &u, &singularValues, &vT);
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index b1bd816..bfcdf9d 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -2576,103 +2576,31 @@ PHP_METHOD(Tensor_Matrix, trace)
  */
 PHP_METHOD(Tensor_Matrix, rank)
 {
-	double epsilon;
-	zend_bool stop = 0, _11$$3;
-	zval a, _3;
-	zval rowA, valueA, _0, _1, _2, *_4, *_5$$3, _6$$3, *_7$$3, _10$$3, _8$$4, _12$$7;
+	zval rref, _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_9 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, pivots;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&rref);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_10$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_12$$7);
-	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_3);
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&a);
-	array_init(&a);
 	ZEPHIR_CALL_METHOD(&_0, this_ptr, "rref", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_1, &_0, "a", NULL, 0);
+	ZEPHIR_CALL_METHOD(&rref, &_0, "a", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_2, &_1, "asArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_1, &rref, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_get_arrval(&_3, &_2);
-	ZEPHIR_CPY_WRT(&a, &_3);
-	pivots = 0;
-	epsilon =  (0.00000001);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 900);
-	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _4)
-	{
-		ZEPHIR_INIT_NVAR(&rowA);
-		ZVAL_COPY(&rowA, _4);
-		stop = 0;
-		if (Z_TYPE_P(&rowA) == IS_STRING) {
-			ZEPHIR_INIT_NVAR(&_6$$3);
-			zephir_string_to_char_array(&_6$$3, &rowA);
-			_5$$3 = &_6$$3;
-		} else {
-			_5$$3 = &rowA;
-		}
-		zephir_is_iterable(_5$$3, 0, "tensor/matrix.zep", 898);
-		if (Z_TYPE_P(_5$$3) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_5$$3), _7$$3)
-			{
-				ZEPHIR_INIT_NVAR(&valueA);
-				ZVAL_COPY(&valueA, _7$$3);
-				if (stop) {
-					continue;
-				}
-				ZEPHIR_CALL_FUNCTION(&_8$$4, "abs", &_9, 12, &valueA);
-				zephir_check_call_status();
-				if (!ZEPHIR_LT_DOUBLE(&_8$$4, epsilon)) {
-					pivots++;
-					stop = 1;
-				}
-			} ZEND_HASH_FOREACH_END();
-		} else {
-			ZEPHIR_CALL_METHOD(NULL, _5$$3, "rewind", NULL, 0);
-			zephir_check_call_status();
-			_11$$3 = 1;
-			while (1) {
-				if (_11$$3) {
-					_11$$3 = 0;
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _5$$3, "next", NULL, 0);
-					zephir_check_call_status();
-				}
-				ZEPHIR_CALL_METHOD(&_10$$3, _5$$3, "valid", NULL, 0);
-				zephir_check_call_status();
-				if (!zend_is_true(&_10$$3)) {
-					break;
-				}
-				ZEPHIR_CALL_METHOD(&valueA, _5$$3, "current", NULL, 0);
-				zephir_check_call_status();
-					if (stop) {
-						continue;
-					}
-					ZEPHIR_CALL_FUNCTION(&_12$$7, "abs", &_9, 12, &valueA);
-					zephir_check_call_status();
-					if (!ZEPHIR_LT_DOUBLE(&_12$$7, epsilon)) {
-						pivots++;
-						stop = 1;
-					}
-			}
-		}
-		ZEPHIR_INIT_NVAR(&valueA);
-	} ZEND_HASH_FOREACH_END();
-	ZEPHIR_INIT_NVAR(&rowA);
-	RETURN_MM_LONG(pivots);
+	ZEPHIR_CALL_METHOD(&_2, &rref, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_3, &rref, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_rank(return_value, &_1, &_2, &_3);
+	RETURN_MM();
 }
 
 /**
@@ -2709,34 +2637,22 @@ PHP_METHOD(Tensor_Matrix, fullRank)
  */
 PHP_METHOD(Tensor_Matrix, symmetric)
 {
-	zend_bool _2, _6$$4;
-	zval _0, _1, _5$$4, _9$$5, _10$$5, _11$$5, _12$$5, _13$$5, _14$$5, _15$$5;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0, j = 0, _3, _4, _7$$4, _8$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_9$$5);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_11$$5);
-	ZVAL_UNDEF(&_12$$5);
-	ZVAL_UNDEF(&_13$$5);
-	ZVAL_UNDEF(&_14$$5);
-	ZVAL_UNDEF(&_15$$5);
+	ZVAL_UNDEF(&_2);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
-	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("m", 1, 1);
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
-	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
@@ -2745,54 +2661,10 @@ PHP_METHOD(Tensor_Matrix, symmetric)
 	if (!(zephir_is_true(&_0))) {
 		RETURN_MM_BOOL(0);
 	}
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
-	_4 = (zephir_get_numberval(&_1) - 2);
-	_3 = 0;
-	_2 = 0;
-	if (_3 <= _4) {
-		while (1) {
-			if (_2) {
-				_3++;
-				if (!(_3 <= _4)) {
-					break;
-				}
-			} else {
-				_2 = 1;
-			}
-			i = _3;
-			zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-			_8$$4 = (zephir_get_numberval(&_5$$4) - 1);
-			_7$$4 = (i + 1);
-			_6$$4 = 0;
-			if (_7$$4 <= _8$$4) {
-				while (1) {
-					if (_6$$4) {
-						_7$$4++;
-						if (!(_7$$4 <= _8$$4)) {
-							break;
-						}
-					} else {
-						_6$$4 = 1;
-					}
-					j = _7$$4;
-					zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-					zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-					ZVAL_LONG(&_12$$5, ((i * (zend_long) zephir_get_numberval(&_11$$5)) + j));
-					ZEPHIR_CALL_METHOD(&_10$$5, &_9$$5, "get", NULL, 0, &_12$$5);
-					zephir_check_call_status();
-					zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-					zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-					ZVAL_LONG(&_15$$5, ((j * (zend_long) zephir_get_numberval(&_14$$5)) + i));
-					ZEPHIR_CALL_METHOD(&_13$$5, &_12$$5, "get", NULL, 0, &_15$$5);
-					zephir_check_call_status();
-					if (!ZEPHIR_IS_EQUAL(&_10$$5, &_13$$5)) {
-						RETURN_MM_BOOL(0);
-					}
-				}
-			}
-		}
-	}
-	RETURN_MM_BOOL(1);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_is_symmetric(return_value, &_1, &_2);
+	RETURN_MM();
 }
 
 /**
@@ -2862,7 +2734,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_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/matrix.zep", 949);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 913);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2936,7 +2808,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements 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", 969);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 933);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3034,7 +2906,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 3, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 987);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 951);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3048,7 +2920,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 3, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 992);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 956);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3384,7 +3256,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1136);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1100);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3455,7 +3327,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1169);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1133);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3527,7 +3399,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1203);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1167);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3599,7 +3471,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1237);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1201);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3671,7 +3543,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1271);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1235);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3743,7 +3615,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1305);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1269);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3815,7 +3687,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1339);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1303);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3887,7 +3759,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1373);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1337);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3959,7 +3831,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1407);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1371);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4031,7 +3903,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1441);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1405);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4103,7 +3975,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1475);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1439);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4175,7 +4047,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1509);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1473);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4882,7 +4754,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1695);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1659);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4890,7 +4762,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1692);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1656);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4912,7 +4784,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1692);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1656);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4968,7 +4840,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1713);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1677);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4976,7 +4848,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1710);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1674);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4998,7 +4870,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1710);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1674);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5054,7 +4926,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1731);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1695);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5062,7 +4934,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1728);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1692);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5084,7 +4956,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1728);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1692);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5140,7 +5012,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1749);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1713);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5148,7 +5020,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1746);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1710);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5170,7 +5042,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1746);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1710);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5274,7 +5146,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1788);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1752);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5298,7 +5170,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1785);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1749);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5336,7 +5208,7 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1785);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1749);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5422,7 +5294,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1802);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1766);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5443,7 +5315,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1830);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1794);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5459,7 +5331,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1820);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1784);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5471,7 +5343,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1827);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1791);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5501,7 +5373,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1820);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1784);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5513,7 +5385,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1827);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1791);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5588,7 +5460,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1846);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1810);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5608,7 +5480,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 3, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1852);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1816);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5697,7 +5569,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 3, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1877);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1841);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5803,7 +5675,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less 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", 1905);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1869);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5820,7 +5692,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_12 = &_10;
 	}
-	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1928);
+	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1892);
 	if (Z_TYPE_P(_12) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
 		{
@@ -5843,7 +5715,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1925);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1889);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
@@ -5880,7 +5752,7 @@ PHP_METHOD(Tensor_Matrix, round)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1925);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1889);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -6026,7 +5898,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1964);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1928);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6298,7 +6170,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", 2030);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1994);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6395,7 +6267,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", 2050);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2014);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6499,7 +6371,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", 2070);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2034);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6542,7 +6414,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2084);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2048);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -6631,7 +6503,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", 2102);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2066);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6674,7 +6546,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2116);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2080);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -6752,7 +6624,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2140);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2104);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -6761,7 +6633,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2138);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2102);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -6784,14 +6656,14 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2138);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2102);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2143);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2107);
 		ZVAL_LONG(&_13$$6, 1);
 		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 26, &bigRows, &_13$$6);
 		zephir_check_call_status();
@@ -6877,7 +6749,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2166);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2130);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6952,7 +6824,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2185);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2149);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7027,7 +6899,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2204);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2168);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7102,7 +6974,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2223);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2187);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7178,7 +7050,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2243);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2207);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7254,7 +7126,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2263);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2227);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7330,7 +7202,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2283);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2247);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7405,7 +7277,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2302);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2266);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7481,7 +7353,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2322);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2286);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7557,7 +7429,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2342);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2306);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7632,7 +7504,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2361);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2325);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7707,7 +7579,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected 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", 2380);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2344);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7792,7 +7664,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2400);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2364);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7825,7 +7697,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_multiply(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2410);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2374);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -7903,7 +7775,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2428);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2392);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7936,7 +7808,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_divide(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2438);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2402);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8014,7 +7886,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2456);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2420);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8047,7 +7919,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_add(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2466);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2430);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8125,7 +7997,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2484);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2448);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8158,7 +8030,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_subtract(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2494);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2458);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8236,7 +8108,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2512);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2476);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8269,7 +8141,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_pow(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2522);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2486);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8347,7 +8219,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2540);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2504);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8380,7 +8252,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_mod(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2550);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2514);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8459,7 +8331,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2569);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2533);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8492,7 +8364,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2579);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2543);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8570,7 +8442,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2597);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2561);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8603,7 +8475,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_not_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2607);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2571);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8681,7 +8553,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2625);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2589);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8714,7 +8586,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2635);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2599);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8792,7 +8664,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2653);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2617);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8825,7 +8697,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2663);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2627);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8903,7 +8775,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2681);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2645);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8936,7 +8808,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2691);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2655);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -9015,7 +8887,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2710);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2674);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9048,7 +8920,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2720);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2684);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -9121,7 +8993,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2738);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2702);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9203,7 +9075,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2761);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2725);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9285,7 +9157,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2784);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2748);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9367,7 +9239,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2807);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2771);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9449,7 +9321,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2830);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2794);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9531,7 +9403,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2853);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2817);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9613,7 +9485,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2876);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2840);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9695,7 +9567,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2899);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2863);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9777,7 +9649,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2922);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2886);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9859,7 +9731,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2945);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2909);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9941,7 +9813,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2968);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2932);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10023,7 +9895,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_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", 2991);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2955);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10674,7 +10546,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3175);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3139);
 	return;
 }
 
@@ -10725,7 +10597,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3199);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3163);
 	return;
 }
 
@@ -10785,7 +10657,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3213);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3177);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10802,7 +10674,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3218);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3182);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index b418f23..ea06283 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -59,20 +59,25 @@ ZEPHIR_INIT_CLASS(Tensor_Reductions_Ref)
  */
 PHP_METHOD(Tensor_Reductions_Ref, reduce)
 {
-	zval ref, _2;
+	zval ref, _4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a, a_sub, result, _0, _1, b, _3, swaps;
+	zend_long ZEPHIR_LAST_CALL_STATUS, swaps;
+	zval *a, a_sub, result, _0, _1, _2, _3, b, _5, _6, _7, _8, _9;
 
 	ZVAL_UNDEF(&a_sub);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
-	ZVAL_UNDEF(&swaps);
+	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&ref);
-	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_4);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
@@ -80,25 +85,35 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
 	ZEPHIR_INIT_VAR(&result);
-	ZEPHIR_CALL_METHOD(&_0, a, "asarray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, a, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	tensor_ref(&result, &_0);
+	ZEPHIR_CALL_METHOD(&_1, a, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_2, a, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_ref(&result, &_0, &_1, &_2);
 	if (Z_TYPE_P(&result) == IS_NULL) {
 		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_runtimeexception_ce, "Failed to decompose matrix.", "tensor/reductions/ref.zep", 44);
 		return;
 	}
 	ZEPHIR_INIT_VAR(&ref);
 	array_init(&ref);
-	ZEPHIR_CPY_WRT(&_1, &result);
-	zephir_get_arrval(&_2, &_1);
-	ZEPHIR_CPY_WRT(&ref, &_2);
-	zephir_array_fetch_long(&_3, &ref, 0, PH_NOISY | PH_READONLY, "tensor/reductions/ref.zep", 51);
-	ZEPHIR_CALL_CE_STATIC(&b, tensor_matrix_ce, "quick", NULL, 0, &_3);
+	ZEPHIR_CPY_WRT(&_3, &result);
+	zephir_get_arrval(&_4, &_3);
+	ZEPHIR_CPY_WRT(&ref, &_4);
+	zephir_array_fetch_long(&_5, &ref, 0, PH_NOISY | PH_READONLY, "tensor/reductions/ref.zep", 51);
+	ZEPHIR_CALL_METHOD(&_6, a, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_7, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_CE_STATIC(&b, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_5, &_6, &_7);
 	zephir_check_call_status();
-	zephir_memory_observe(&swaps);
-	zephir_array_fetch_long(&swaps, &ref, 1, PH_NOISY, "tensor/reductions/ref.zep", 52);
+	zephir_memory_observe(&_8);
+	zephir_array_fetch_long(&_8, &ref, 1, PH_NOISY, "tensor/reductions/ref.zep", 52);
+	swaps = zephir_get_intval(&_8);
 	object_init_ex(return_value, tensor_reductions_ref_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b, &swaps);
+	ZVAL_LONG(&_9, swaps);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index d1ef9f4..3753af8 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -14,9 +14,9 @@
 #include "kernel/main.h"
 #include "kernel/memory.h"
 #include "kernel/fcall.h"
-#include "kernel/operators.h"
-#include "kernel/array.h"
+#include "kernel/exception.h"
 #include "kernel/object.h"
+#include "include/linear_algebra.h"
 
 
 /**
@@ -49,222 +49,44 @@ ZEPHIR_INIT_CLASS(Tensor_Reductions_Rref)
  */
 PHP_METHOD(Tensor_Reductions_Rref, reduce)
 {
-	zval b, rowB, t, _5, _8$$3, _31$$11;
-	zend_bool hasPivot = 0, _6, _27$$3, _12$$4, _17$$7, _22$$9, _35$$12;
-	double scale = 0, divisor = 0, epsilon;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_11 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, i = 0, j = 0, m, n, row, col, _28$$3, _29$$3, _13$$4, _14$$4, _18$$7, _19$$7, _23$$9, _24$$9, _36$$12, _37$$12;
-	zval *a, a_sub, _0, _1, _2, _3, _4, _41, _7$$3, _9$$3, _10$$3, _21$$3, _15$$5, _16$$5, _20$$8, _25$$10, _26$$10, _30$$11, _32$$11, _33$$11, _34$$11, _38$$13, _39$$13, _40$$13;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *a, a_sub, result, _0, _1, _2, _3, _4, _5;
 
 	ZVAL_UNDEF(&a_sub);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_41);
-	ZVAL_UNDEF(&_7$$3);
-	ZVAL_UNDEF(&_9$$3);
-	ZVAL_UNDEF(&_10$$3);
-	ZVAL_UNDEF(&_21$$3);
-	ZVAL_UNDEF(&_15$$5);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_20$$8);
-	ZVAL_UNDEF(&_25$$10);
-	ZVAL_UNDEF(&_26$$10);
-	ZVAL_UNDEF(&_30$$11);
-	ZVAL_UNDEF(&_32$$11);
-	ZVAL_UNDEF(&_33$$11);
-	ZVAL_UNDEF(&_34$$11);
-	ZVAL_UNDEF(&_38$$13);
-	ZVAL_UNDEF(&_39$$13);
-	ZVAL_UNDEF(&_40$$13);
-	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&rowB);
-	ZVAL_UNDEF(&t);
 	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_8$$3);
-	ZVAL_UNDEF(&_31$$11);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	epsilon =  (0.00000001);
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	ZEPHIR_INIT_VAR(&rowB);
-	array_init(&rowB);
-	ZEPHIR_INIT_VAR(&t);
-	array_init(&t);
-	ZEPHIR_CALL_METHOD(&_0, a, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	ZEPHIR_CALL_METHOD(&_0, a, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	m = zephir_get_intval(&_0);
-	ZEPHIR_CALL_METHOD(&_1, a, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_1, a, "m", NULL, 0);
 	zephir_check_call_status();
-	n = zephir_get_intval(&_1);
-	row = 0;
-	col = 0;
-	ZEPHIR_CALL_METHOD(&_2, a, "ref", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_2, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_3, &_2, "a", NULL, 0);
-	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_4, &_3, "asarray", NULL, 0);
-	zephir_check_call_status();
-	zephir_get_arrval(&_5, &_4);
-	ZEPHIR_CPY_WRT(&b, &_5);
-	while (1) {
-		_6 = row < m;
-		if (_6) {
-			_6 = col < n;
-		}
-		if (!(_6)) {
-			break;
-		}
-		ZEPHIR_OBS_NVAR(&_7$$3);
-		zephir_array_fetch_long(&_7$$3, &b, row, PH_NOISY, "tensor/reductions/rref.zep", 52);
-		zephir_get_arrval(&_8$$3, &_7$$3);
-		ZEPHIR_CPY_WRT(&t, &_8$$3);
-		zephir_array_fetch_long(&_9$$3, &t, col, PH_NOISY | PH_READONLY, "tensor/reductions/rref.zep", 54);
-		ZEPHIR_CALL_FUNCTION(&_10$$3, "abs", &_11, 12, &_9$$3);
-		zephir_check_call_status();
-		if (ZEPHIR_LT_DOUBLE(&_10$$3, epsilon)) {
-			hasPivot = 0;
-			_14$$4 = (n - 1);
-			_13$$4 = col;
-			_12$$4 = 0;
-			if (_13$$4 <= _14$$4) {
-				while (1) {
-					if (_12$$4) {
-						_13$$4++;
-						if (!(_13$$4 <= _14$$4)) {
-							break;
-						}
-					} else {
-						_12$$4 = 1;
-					}
-					i = _13$$4;
-					zephir_array_fetch_long(&_15$$5, &t, i, PH_NOISY | PH_READONLY, "tensor/reductions/rref.zep", 58);
-					ZEPHIR_CALL_FUNCTION(&_16$$5, "abs", &_11, 12, &_15$$5);
-					zephir_check_call_status();
-					if (!ZEPHIR_LT_DOUBLE(&_16$$5, epsilon)) {
-						hasPivot = 1;
-						break;
-					}
-				}
-			}
-			if (hasPivot == 0) {
-				_19$$7 = (n - 1);
-				_18$$7 = col;
-				_17$$7 = 0;
-				if (_18$$7 <= _19$$7) {
-					while (1) {
-						if (_17$$7) {
-							_18$$7++;
-							if (!(_18$$7 <= _19$$7)) {
-								break;
-							}
-						} else {
-							_17$$7 = 1;
-						}
-						i = _18$$7;
-						ZEPHIR_INIT_NVAR(&_20$$8);
-						ZVAL_DOUBLE(&_20$$8, 0.0);
-						zephir_array_update_long(&t, i, &_20$$8, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
-					}
-				}
-				zephir_array_update_long(&b, row, &t, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
-				row++;
-				continue;
-			}
-			col++;
-			continue;
-		}
-		ZEPHIR_OBS_NVAR(&_21$$3);
-		zephir_array_fetch_long(&_21$$3, &t, col, PH_NOISY, "tensor/reductions/rref.zep", 82);
-		divisor =  (zephir_get_doubleval(&_21$$3));
-		if (divisor != 1.0) {
-			_24$$9 = (n - 1);
-			_23$$9 = 0;
-			_22$$9 = 0;
-			if (_23$$9 <= _24$$9) {
-				while (1) {
-					if (_22$$9) {
-						_23$$9++;
-						if (!(_23$$9 <= _24$$9)) {
-							break;
-						}
-					} else {
-						_22$$9 = 1;
-					}
-					i = _23$$9;
-					zephir_array_fetch_long(&_25$$10, &t, i, PH_NOISY | PH_READONLY, "tensor/reductions/rref.zep", 86);
-					ZEPHIR_INIT_NVAR(&_26$$10);
-					ZVAL_DOUBLE(&_26$$10, zephir_safe_div_zval_double(&_25$$10, divisor));
-					zephir_array_update_long(&t, i, &_26$$10, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
-				}
-			}
-		}
-		_29$$3 = (row - 1);
-		_28$$3 = _29$$3;
-		_27$$3 = 0;
-		if (_28$$3 >= 0) {
-			while (1) {
-				if (_27$$3) {
-					_28$$3--;
-					if (!(_28$$3 >= 0)) {
-						break;
-					}
-				} else {
-					_27$$3 = 1;
-				}
-				i = _28$$3;
-				ZEPHIR_OBS_NVAR(&_30$$11);
-				zephir_array_fetch_long(&_30$$11, &b, i, PH_NOISY, "tensor/reductions/rref.zep", 91);
-				zephir_get_arrval(&_31$$11, &_30$$11);
-				ZEPHIR_CPY_WRT(&rowB, &_31$$11);
-				ZEPHIR_OBS_NVAR(&_32$$11);
-				zephir_array_fetch_long(&_32$$11, &rowB, col, PH_NOISY, "tensor/reductions/rref.zep", 93);
-				scale =  (zephir_get_doubleval(&_32$$11));
-				ZVAL_DOUBLE(&_33$$11, scale);
-				ZEPHIR_CALL_FUNCTION(&_34$$11, "abs", &_11, 12, &_33$$11);
-				zephir_check_call_status();
-				if (!ZEPHIR_LT_DOUBLE(&_34$$11, epsilon)) {
-					_37$$12 = (n - 1);
-					_36$$12 = 0;
-					_35$$12 = 0;
-					if (_36$$12 <= _37$$12) {
-						while (1) {
-							if (_35$$12) {
-								_36$$12++;
-								if (!(_36$$12 <= _37$$12)) {
-									break;
-								}
-							} else {
-								_35$$12 = 1;
-							}
-							j = _36$$12;
-							zephir_array_fetch_long(&_38$$13, &rowB, j, PH_NOISY | PH_READONLY, "tensor/reductions/rref.zep", 97);
-							zephir_array_fetch_long(&_39$$13, &t, j, PH_NOISY | PH_READONLY, "tensor/reductions/rref.zep", 97);
-							ZEPHIR_INIT_NVAR(&_40$$13);
-							ZVAL_LONG(&_40$$13, (zephir_get_numberval(&_38$$13) - (scale * (zend_long) zephir_get_numberval(&_39$$13))));
-							zephir_array_update_long(&rowB, j, &_40$$13, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
-						}
-					}
-				}
-				zephir_array_update_long(&b, i, &rowB, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
-			}
-		}
-		zephir_array_update_long(&b, row, &t, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
-		row++;
-		col++;
+	tensor_rref(&result, &_0, &_1, &_2);
+	if (Z_TYPE_P(&result) == IS_NULL) {
+		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_runtimeexception_ce, "Failed to reduce matrix.", "tensor/reductions/rref.zep", 36);
+		return;
 	}
 	object_init_ex(return_value, tensor_reductions_rref_ce);
-	ZEPHIR_CALL_CE_STATIC(&_41, tensor_matrix_ce, "quick", NULL, 0, &b);
+	ZEPHIR_CALL_METHOD(&_4, a, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_5, a, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_CE_STATIC(&_3, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_4, &_5);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &_41);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index c8921c0..1527c26 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -20,8 +20,8 @@
 #include "kernel/concat.h"
 #include "kernel/array.h"
 #include "math.h"
-#include "kernel/string.h"
 #include "kernel/math.h"
+#include "kernel/string.h"
 #include "ext/spl/spl_array.h"
 #include "include/buffer.h"
 #include "include/linear_algebra.h"
@@ -1432,34 +1432,27 @@ PHP_METHOD(Tensor_Vector, inner)
  */
 PHP_METHOD(Tensor_Vector, outer)
 {
-	zend_string *_8$$3, *_14$$5;
-	zend_ulong _7$$3, _13$$5;
-	zend_bool _11;
-	zval bHat, c, rowC, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, j, valueA, valueB, aHat, _0, _1, *_3, _4, *_5, _10, *_6$$3, _9$$4, *_12$$5, _15$$6;
+	zval *b, b_sub, result, _0, _1, _2, _3, _4, _5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
-	ZVAL_UNDEF(&j);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&valueB);
-	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&_15$$6);
-	ZVAL_UNDEF(&bHat);
-	ZVAL_UNDEF(&c);
-	ZVAL_UNDEF(&rowC);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
@@ -1467,95 +1460,18 @@ PHP_METHOD(Tensor_Vector, outer)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b);
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&aHat, &_0, "toArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_1, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_INIT_VAR(&bHat);
-	array_init(&bHat);
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_INIT_VAR(&rowC);
-	array_init(&rowC);
-	ZEPHIR_CALL_METHOD(&_1, b, "asArray", NULL, 0);
-	zephir_check_call_status();
-	zephir_get_arrval(&_2, &_1);
-	ZEPHIR_CPY_WRT(&bHat, &_2);
-	if (Z_TYPE_P(&aHat) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &aHat);
-		_3 = &_4;
-	} else {
-		_3 = &aHat;
-	}
-	zephir_is_iterable(_3, 0, "tensor/vector.zep", 561);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _5);
-			ZEPHIR_INIT_NVAR(&rowC);
-			array_init(&rowC);
-			zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 558);
-			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _7$$3, _8$$3, _6$$3)
-			{
-				ZEPHIR_INIT_NVAR(&j);
-				if (_8$$3 != NULL) { 
-					ZVAL_STR_COPY(&j, _8$$3);
-				} else {
-					ZVAL_LONG(&j, _7$$3);
-				}
-				ZEPHIR_INIT_NVAR(&valueB);
-				ZVAL_COPY(&valueB, _6$$3);
-				ZEPHIR_INIT_NVAR(&_9$$4);
-				mul_function(&_9$$4, &valueA, &valueB);
-				zephir_array_append(&rowC, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 555);
-			} ZEND_HASH_FOREACH_END();
-			ZEPHIR_INIT_NVAR(&valueB);
-			ZEPHIR_INIT_NVAR(&j);
-			zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 558);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_11 = 1;
-		while (1) {
-			if (_11) {
-				_11 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_10, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_10)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&rowC);
-				array_init(&rowC);
-				zephir_is_iterable(&bHat, 0, "tensor/vector.zep", 558);
-				ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bHat), _13$$5, _14$$5, _12$$5)
-				{
-					ZEPHIR_INIT_NVAR(&j);
-					if (_14$$5 != NULL) { 
-						ZVAL_STR_COPY(&j, _14$$5);
-					} else {
-						ZVAL_LONG(&j, _13$$5);
-					}
-					ZEPHIR_INIT_NVAR(&valueB);
-					ZVAL_COPY(&valueB, _12$$5);
-					ZEPHIR_INIT_NVAR(&_15$$6);
-					mul_function(&_15$$6, &valueA, &valueB);
-					zephir_array_append(&rowC, &_15$$6, PH_SEPARATE, "tensor/vector.zep", 555);
-				} ZEND_HASH_FOREACH_END();
-				ZEPHIR_INIT_NVAR(&valueB);
-				ZEPHIR_INIT_NVAR(&j);
-				zephir_array_append(&c, &rowC, PH_SEPARATE, "tensor/vector.zep", 558);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&valueA);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "quick", NULL, 0, &c);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_3, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_outer(&result, &_0, &_1, &_2, &_3);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_5, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_4, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1652,7 +1568,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "P must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 595);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 577);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1754,7 +1670,7 @@ PHP_METHOD(Tensor_Vector, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 638);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 620);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1820,7 +1736,7 @@ PHP_METHOD(Tensor_Vector, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 668);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 650);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1887,7 +1803,7 @@ PHP_METHOD(Tensor_Vector, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 699);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 681);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1954,7 +1870,7 @@ PHP_METHOD(Tensor_Vector, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " vector from the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 730);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 712);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2021,7 +1937,7 @@ PHP_METHOD(Tensor_Vector, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " vector to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 761);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 743);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2088,7 +2004,7 @@ PHP_METHOD(Tensor_Vector, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " vector with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 792);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 774);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2155,7 +2071,7 @@ PHP_METHOD(Tensor_Vector, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 823);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 805);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2222,7 +2138,7 @@ PHP_METHOD(Tensor_Vector, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 854);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 836);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2289,7 +2205,7 @@ PHP_METHOD(Tensor_Vector, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 885);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 867);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2356,7 +2272,7 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 916);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 898);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2423,7 +2339,7 @@ PHP_METHOD(Tensor_Vector, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 947);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 929);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2490,7 +2406,7 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 978);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 960);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2708,7 +2624,7 @@ PHP_METHOD(Tensor_Vector, log)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Log base must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1052);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1034);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3169,12 +3085,12 @@ PHP_METHOD(Tensor_Vector, median)
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
 		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1218);
+		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1200);
 	} else {
 		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1220);
+		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1202);
 		zephir_memory_observe(&_5$$4);
-		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1220);
+		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1202);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
 		ZEPHIR_INIT_NVAR(&median);
@@ -3241,7 +3157,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1237);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1219);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3259,15 +3175,15 @@ PHP_METHOD(Tensor_Vector, quantile)
 	if (ZEPHIR_LE_LONG(&_7, xHat)) {
 		zephir_memory_observe(&_8$$4);
 		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1249);
+		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1231);
 		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
 	}
 	remainder =  ((x -  (double) xHat));
 	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1254);
+	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1236);
 	t =  (zephir_get_doubleval(&_10));
 	zephir_memory_observe(&_11);
-	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1256);
+	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1238);
 	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
 }
 
@@ -3326,7 +3242,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1271);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1253);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3392,7 +3308,7 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1295);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1277);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3508,7 +3424,7 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1334);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1316);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3722,7 +3638,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1394);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1376);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3737,7 +3653,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1405);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1387);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3746,7 +3662,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1402);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1384);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3769,7 +3685,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1402);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1384);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3844,7 +3760,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1420);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1402);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3859,7 +3775,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1431);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1413);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3868,7 +3784,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1428);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1410);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3891,7 +3807,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1428);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1410);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3966,7 +3882,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1446);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1428);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3981,7 +3897,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1457);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1439);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3990,7 +3906,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1454);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1436);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4013,7 +3929,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1454);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1436);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4088,7 +4004,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1472);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1454);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4103,7 +4019,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1483);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1465);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4112,7 +4028,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1480);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1462);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4135,7 +4051,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1480);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1462);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4210,7 +4126,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1498);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1480);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4225,7 +4141,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1509);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1491);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4234,7 +4150,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1506);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1488);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4257,7 +4173,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1506);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1488);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4332,7 +4248,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1524);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1506);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4347,7 +4263,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1535);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1517);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4356,7 +4272,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1532);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1514);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4379,7 +4295,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1532);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1514);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4454,7 +4370,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1550);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1532);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4469,7 +4385,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1561);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1543);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4478,7 +4394,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1558);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1540);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4501,7 +4417,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1558);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1540);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4576,7 +4492,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1576);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1558);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4591,7 +4507,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1587);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1569);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4600,7 +4516,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1584);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1566);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4623,7 +4539,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1584);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1566);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4698,7 +4614,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1602);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1584);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4713,7 +4629,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1613);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1595);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4722,7 +4638,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1610);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1592);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4745,7 +4661,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1610);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1592);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4820,7 +4736,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1628);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1610);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4835,7 +4751,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1639);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1621);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4844,7 +4760,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1636);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1618);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4867,7 +4783,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1636);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1618);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4942,7 +4858,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1654);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1636);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4957,7 +4873,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1665);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1647);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4966,7 +4882,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1662);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1644);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4989,7 +4905,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1662);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1644);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5064,7 +4980,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns 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/vector.zep", 1680);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1662);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5079,7 +4995,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1691);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1673);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5088,7 +5004,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1688);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1670);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5111,7 +5027,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1688);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1670);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5178,7 +5094,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1706);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1688);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5249,7 +5165,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1724);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1706);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5320,7 +5236,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1742);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1724);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5391,7 +5307,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1760);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1742);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5462,7 +5378,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1778);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1760);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5533,7 +5449,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1796);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1778);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5605,7 +5521,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1815);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1797);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5676,7 +5592,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1833);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1815);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5747,7 +5663,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1851);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1833);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5818,7 +5734,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1869);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1851);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5889,7 +5805,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1887);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1869);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5960,7 +5876,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements 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/vector.zep", 1905);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1887);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6458,7 +6374,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2062);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2044);
 	return;
 }
 
@@ -6509,7 +6425,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2086);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2068);
 	return;
 }
 
@@ -6567,7 +6483,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 3, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2100);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2082);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/optimizers/TensorCholeskyOptimizer.php b/optimizers/TensorCholeskyOptimizer.php
index e5e237a..c3a8270 100644
--- a/optimizers/TensorCholeskyOptimizer.php
+++ b/optimizers/TensorCholeskyOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 2) {
             throw new CompilerException(
-                'Cholesky accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Cholesky accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_cholesky($symbol, {$resolvedParams[0]});"
+            "tensor_cholesky($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorEigOptimizer.php b/optimizers/TensorEigOptimizer.php
index ce41d01..6965554 100644
--- a/optimizers/TensorEigOptimizer.php
+++ b/optimizers/TensorEigOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 2) {
             throw new CompilerException(
-                'Eig accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Eig accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_eig($symbol, {$resolvedParams[0]});"
+            "tensor_eig($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorEigSymmetricOptimizer.php b/optimizers/TensorEigSymmetricOptimizer.php
index 1f9d970..e1f770d 100644
--- a/optimizers/TensorEigSymmetricOptimizer.php
+++ b/optimizers/TensorEigSymmetricOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 2) {
             throw new CompilerException(
-                'Eig symmetric accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Eig symmetric accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_eig_symmetric($symbol, {$resolvedParams[0]});"
+            "tensor_eig_symmetric($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorIsSymmetricOptimizer.php b/optimizers/TensorIsSymmetricOptimizer.php
new file mode 100644
index 0000000..b8c5086
--- /dev/null
+++ b/optimizers/TensorIsSymmetricOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorIsSymmetricOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'IsSymmetric accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/linear_algebra',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_is_symmetric($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLuOptimizer.php b/optimizers/TensorLuOptimizer.php
index 762720e..6559bf8 100644
--- a/optimizers/TensorLuOptimizer.php
+++ b/optimizers/TensorLuOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 2) {
             throw new CompilerException(
-                'Lu accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Lu accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_lu($symbol, {$resolvedParams[0]});"
+            "tensor_lu($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorOuterOptimizer.php b/optimizers/TensorOuterOptimizer.php
new file mode 100644
index 0000000..a6d66dd
--- /dev/null
+++ b/optimizers/TensorOuterOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorOuterOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 4) {
+            throw new CompilerException(
+                'Outer accepts exactly four arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/linear_algebra',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_outer($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]}, {$resolvedParams[3]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorRankOptimizer.php b/optimizers/TensorRankOptimizer.php
new file mode 100644
index 0000000..dce61f4
--- /dev/null
+++ b/optimizers/TensorRankOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorRankOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Rank accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/linear_algebra',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_rank($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorRefOptimizer.php b/optimizers/TensorRefOptimizer.php
index 7fddde5..372fa13 100644
--- a/optimizers/TensorRefOptimizer.php
+++ b/optimizers/TensorRefOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 3) {
             throw new CompilerException(
-                'REF accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'REF accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_ref($symbol, {$resolvedParams[0]});"
+            "tensor_ref($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorRrefOptimizer.php b/optimizers/TensorRrefOptimizer.php
new file mode 100644
index 0000000..9001dbc
--- /dev/null
+++ b/optimizers/TensorRrefOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorRrefOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'RREF accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/linear_algebra',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_rref($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorSvdOptimizer.php b/optimizers/TensorSvdOptimizer.php
index 3dd8529..ebde30e 100644
--- a/optimizers/TensorSvdOptimizer.php
+++ b/optimizers/TensorSvdOptimizer.php
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 3) {
             throw new CompilerException(
-                'SVD accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'SVD accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_svd($symbol, {$resolvedParams[0]});"
+            "tensor_svd($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
         );
 
         return new CompiledExpression(
diff --git a/tensor/decompositions/cholesky.zep b/tensor/decompositions/cholesky.zep
index e3dbf1c..f4c2b93 100644
--- a/tensor/decompositions/cholesky.zep
+++ b/tensor/decompositions/cholesky.zep
@@ -37,13 +37,13 @@ class Cholesky
                 . " square, " . $a->shapeString() . " given.");
         }
 
-        var l = tensor_cholesky(a->asArray());
+        var l = tensor_cholesky(a->asTensorBuffer(), a->n());
 
         if is_null(l) {
             throw new RuntimeException("Failed to decompose matrix.");
         }
 
-        return new self(Matrix::quick(l));
+        return new self(Matrix::fromTensorBuffer(l, a->n(), a->n()));
     }
 
     /**
diff --git a/tensor/decompositions/eigen.zep b/tensor/decompositions/eigen.zep
index 528f7da..4377235 100644
--- a/tensor/decompositions/eigen.zep
+++ b/tensor/decompositions/eigen.zep
@@ -51,9 +51,9 @@ class Eigen
         var result;
 
         if symmetric {
-            let result = tensor_eig_symmetric(a->asArray());
+            let result = tensor_eig_symmetric(a->asTensorBuffer(), a->n());
         } else {
-            let result = tensor_eig(a->asArray());
+            let result = tensor_eig(a->asTensorBuffer(), a->n());
         }
 
         if is_null(result) {
@@ -64,8 +64,8 @@ class Eigen
 
         let eig = (array) result;
 
-        var eigenvalues = eig[0];
-        var eigenvectors = Matrix::quick(eig[1])->transpose();
+        var eigenvalues = (array) eig[0];
+        var eigenvectors = Matrix::fromTensorBuffer(eig[1], a->n(), a->n())->transpose();
 
         return new self(eigenvalues, eigenvectors);
     }
diff --git a/tensor/decompositions/lu.zep b/tensor/decompositions/lu.zep
index 07d5e44..91e888e 100644
--- a/tensor/decompositions/lu.zep
+++ b/tensor/decompositions/lu.zep
@@ -52,7 +52,7 @@ class Lu
                 . " square, " . $a->shapeString() . " given.");
         }
 
-        var result = tensor_lu(a->asArray());
+        var result = tensor_lu(a->asTensorBuffer(), a->n());
 
         if is_null(result) {
             throw new RuntimeException("Failed to decompose matrix.");
@@ -62,9 +62,9 @@ class Lu
 
         let lup = (array) result;
 
-        var l = Matrix::quick(lup[0]);
-        var u = Matrix::quick(lup[1]);
-        var p = Matrix::quick(lup[2]);
+        var l = Matrix::fromTensorBuffer(lup[0], a->n(), a->n());
+        var u = Matrix::fromTensorBuffer(lup[1], a->n(), a->n());
+        var p = Matrix::fromTensorBuffer(lup[2], a->n(), a->n());
 
         return new self(l, u, p);
     }
diff --git a/tensor/decompositions/svd.zep b/tensor/decompositions/svd.zep
index 321e130..21fdffb 100644
--- a/tensor/decompositions/svd.zep
+++ b/tensor/decompositions/svd.zep
@@ -42,7 +42,7 @@ class Svd
      */
     public static function decompose(const <Matrix> a) -> <Svd>
     {
-        var result = tensor_svd(a->asArray());
+        var result = tensor_svd(a->asTensorBuffer(), a->m(), a->n());
 
         if is_null(result) {
             throw new RuntimeException("Failed to decompose matrix.");
@@ -52,9 +52,9 @@ class Svd
 
         let usvT = (array) result;
 
-        var u = Matrix::quick(usvT[0]);
-        var singularValues = usvT[1];
-        var vT = Matrix::quick(usvT[2]);
+        var u = Matrix::fromTensorBuffer(usvT[0], a->m(), a->m());
+        var singularValues = (array) usvT[1];
+        var vT = Matrix::fromTensorBuffer(usvT[2], a->n(), a->n());
 
         return new self(u, singularValues, vT);
     }
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 5fc5fea..8041ca7 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -869,35 +869,9 @@ class Matrix implements Tensor
      */
     public function rank() -> int
     {
-        var rowA, valueA;
-        
-        array a = [];
-
-        let a = (array) this->rref()->a()->asArray();
-
-        int pivots = 0;
-
-        bool stop;
-
-        float epsilon = (float) self::EPSILON;
-
-        for rowA in a {
-            let stop = false;
-
-            for valueA in rowA {
-                if stop {
-                    continue;
-                }
+        var rref = this->rref()->a();
 
-                if abs(valueA) >= epsilon {
-                    let pivots++;
-
-                    let stop = true;
-                }
-            }
-        }
-
-        return pivots;
+        return tensor_rank(rref->asTensorBuffer(), rref->m(), rref->n());
     }
 
     /**
@@ -921,17 +895,7 @@ class Matrix implements Tensor
             return false;
         }
 
-        int i, j;
-
-        for i in range(0, this->m - 2) {
-            for j in range(i + 1, this->n - 1) {
-                if this->a->get(i * this->n + j) != this->a->get(j * this->n + i) {
-                    return false;
-                }
-            }
-        }
-
-        return true;
+        return tensor_is_symmetric(this->a, this->n);
     }
 
     /**
diff --git a/tensor/reductions/ref.zep b/tensor/reductions/ref.zep
index 2f003bb..9ea6c68 100644
--- a/tensor/reductions/ref.zep
+++ b/tensor/reductions/ref.zep
@@ -38,7 +38,7 @@ class Ref
      */
     public static function reduce(const <Matrix> a) -> <Ref>
     {
-        var result = tensor_ref(a->asArray());
+        var result = tensor_ref(a->asTensorBuffer(), a->m(), a->n());
 
         if is_null(result) {
             throw new RuntimeException("Failed to decompose matrix.");
@@ -48,8 +48,8 @@ class Ref
 
         let ref = (array) result;
 
-        var b = Matrix::quick(ref[0]);
-        var swaps = ref[1];
+        var b = Matrix::fromTensorBuffer(ref[0], a->m(), a->n());
+        var swaps = (int) ref[1];
 
         return new self(b, swaps);
     }
diff --git a/tensor/reductions/rref.zep b/tensor/reductions/rref.zep
index 50f0a13..91636b1 100644
--- a/tensor/reductions/rref.zep
+++ b/tensor/reductions/rref.zep
@@ -1,9 +1,8 @@
 namespace Tensor\Reductions;
 
 use Tensor\Matrix;
-use Tensor\Tensor;
-use InvalidArgumentException;
-use RuntimeException;
+use Tensor\Exceptions\InvalidArgumentException;
+use Tensor\Exceptions\RuntimeException;
 
 /**
  * RREF
@@ -31,83 +30,13 @@ class Rref
      */
     public static function reduce(const <Matrix> a) -> <Rref>
     {
-        int i, j;
-        float scale, divisor;
-        bool hasPivot;
-        float epsilon = (float) Tensor::EPSILON;
-        
-        array b = [];
-        array rowB = [];
-        array t = [];
+        var result = tensor_rref(a->asTensorBuffer(), a->m(), a->n());
 
-        int m = (int) a->m();
-        int n = (int) a->n();
-
-        int row = 0;
-        int col = 0;
-
-        let b = (array) a->ref()->a()->asArray();
-
-        while row < m && col < n {
-            let t = (array) b[row];
-
-            if abs(t[col]) < epsilon {
-                let hasPivot = false;
-
-                for i in range(col, n - 1) {
-                    if abs(t[i]) >= epsilon {
-                        let hasPivot = true;
-
-                        break;
-                    }
-                }
-
-                if hasPivot == false {
-                    for i in range(col, n - 1) {
-                        let t[i] = 0.0;
-                    }
-
-                    let b[row] = t;
-
-                    let row++;
-
-                    continue;
-                }
-
-                let col++;
-
-                continue;
-            }
-
-            let divisor = (float) t[col];
-
-            if divisor !== 1.0 {
-                for i in range(0, n - 1) {
-                    let t[i] = t[i] / divisor;
-                }
-            }
-
-            for i in reverse range(0, row - 1) {
-                let rowB = (array) b[i];
-
-                let scale = (float) rowB[col];
-
-                if abs(scale) >= epsilon {
-                    for j in range(0, n - 1) {
-                        let rowB[j] = rowB[j] - scale * t[j];
-                    }
-                }
-
-                let b[i] = rowB;
-            }
-
-            let b[row] = t;
-
-            let row++;
-            let col++;
+        if is_null(result) {
+            throw new RuntimeException("Failed to reduce matrix.");
         }
 
-        return new self(Matrix::quick(b));
+        return new self(Matrix::fromTensorBuffer(result, a->m(), a->n()));
     }
 
     /**
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 9fb1bbe..2084317 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -538,27 +538,9 @@ class Vector implements Tensor
      */
     public function outer(const <Vector> b) -> <Matrix>
     {
-        var j, valueA, valueB;
-        
-        var aHat = this->a->toArray();
-
-        array bHat = [];
-        array c = [];
-        array rowC = [];
-
-        let bHat = (array) b->asArray();
-
-        for valueA in aHat {
-            let rowC = [];
-
-            for j, valueB in bHat {
-                let rowC[] = valueA * valueB;
-            }
-
-            let c[] = rowC;
-        }
+        var result = tensor_outer(this->a, b->asTensorBuffer(), this->n, b->n());
 
-        return Matrix::quick(c);
+        return Matrix::fromTensorBuffer(result, this->n, b->n());
     }
 
     /**

From 612c145b8376fbb3abb975cd4f7fe56d094113fb Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Tue, 22 Sep 2026 16:58:05 -0500
Subject: [PATCH 20/51] A little bit nicer

---
 CHANGELOG.md                             |    2 +
 docs/Matrix.md                           |   22 +-
 docs/Vector.md                           |   24 +-
 docs/getting-started.md                  |    4 +-
 ext/tensor/columnvector.zep.c            |  186 ++--
 ext/tensor/columnvector.zep.h            |   18 -
 ext/tensor/decompositions/cholesky.zep.c |    8 +-
 ext/tensor/decompositions/eigen.zep.c    |   10 +-
 ext/tensor/decompositions/lu.zep.c       |   16 +-
 ext/tensor/decompositions/svd.zep.c      |   10 +-
 ext/tensor/matrix.zep.c                  | 1014 +++++++++++-----------
 ext/tensor/matrix.zep.h                  |   20 -
 ext/tensor/reductions/ref.zep.c          |   10 +-
 ext/tensor/reductions/rref.zep.c         |    6 +-
 ext/tensor/settings.zep.c                |    4 +-
 ext/tensor/tensorbuffer.zep.c            |   12 +-
 ext/tensor/vector.zep.c                  |  678 +++++++--------
 ext/tensor/vector.zep.h                  |   19 -
 tensor/columnvector.zep                  |   59 +-
 tensor/decompositions/cholesky.zep       |    2 +-
 tensor/decompositions/eigen.zep          |    2 +-
 tensor/decompositions/lu.zep             |    6 +-
 tensor/decompositions/svd.zep            |    4 +-
 tensor/matrix.zep                        |  219 ++---
 tensor/reductions/ref.zep                |    2 +-
 tensor/reductions/rref.zep               |    2 +-
 tensor/vector.zep                        |  164 ++--
 tests/ColumnVectorTest.php               |  106 +--
 tests/Decompositions/CholeskyTest.php    |   30 +-
 tests/Decompositions/EigenTest.php       |   22 +-
 tests/Decompositions/LUTest.php          |   36 +-
 tests/Decompositions/SVDTest.php         |   22 +-
 tests/MatrixTest.php                     |  664 +++++++-------
 tests/Reductions/REFTest.php             |   36 +-
 tests/Reductions/RREFTest.php            |   30 +-
 tests/VectorTest.php                     |  456 +++++-----
 36 files changed, 1826 insertions(+), 2099 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a4c31a6..bdccfb2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,8 @@
 
 - 4.0.0
     - Performance: the linear algebra operations (REF, RREF, Cholesky, LU, eigendecomposition, SVD), `rank()`, `symmetric()`, and the vector `outer()` product now read their input from, and return their output into, `TensorBuffer`s directly instead of round-tripping through PHP arrays, eliminating the intermediate array copies
+    - Breaking: removed the `Vector::build()`, `Vector::quick()`, `Vector::fromTensorBuffer()`, `Matrix::build()`, `Matrix::quick()`, `Matrix::fromTensorBuffer()`, and `ColumnVector::build()`, `ColumnVector::quick()`, and `ColumnVector::fromTensorBuffer()` factory methods. Construct directly with `new Vector(...)` / `new ColumnVector(...)`, or build a `Matrix` with `Matrix::fromArray(...)` (or `new Matrix(...)` from a `TensorBuffer`)
+    - Breaking: `Vector::__construct()` no longer accepts a `validate` argument; pass an array of elements (or a `TensorBuffer`) and it will be constructed directly
 
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
diff --git a/docs/Matrix.md b/docs/Matrix.md
index 9addf5a..2b45acd 100644
--- a/docs/Matrix.md
+++ b/docs/Matrix.md
@@ -17,23 +17,23 @@ Interface methods are implemented by Matrices with **row-wise** semantics:
 
 ## Constructors & Factories
 
-### `__construct(array $a, bool $validate = true)`
+### `__construct(\Tensor\TensorBuffer $a, int $m, int $n)`
 
-Instantiate a matrix directly.
+Instantiate a matrix from a row-major `TensorBuffer` of its elements and its target dimensions.
 
 - **Parameters:**
-  - `$a` — the 2-dimensional element array `array<array<int|float>>`
-  - `$validate` — whether to validate rectangularity and cast elements to floats (default `true`)
-- **Throws:** `Tensor\Exceptions\InvalidArgumentException` if rows have unequal column counts
-- **Note:** Prefer the factory methods below.
+  - `$a` — the row-major `TensorBuffer` of elements
+  - `$m` — number of rows, `$n` — number of columns
 
-### `Matrix::build(array $a = []) : Matrix`
+### `Matrix::fromArray(array $a, bool $validate = true) : Matrix`
 
-Factory method to build a new matrix from an array, running validation.
+Build a matrix from a PHP array of rows, casting elements to floats.
 
-### `Matrix::quick(array $a = []) : Matrix`
-
-Build a new matrix foregoing any validation for quicker instantiation.
+- **Parameters:**
+  - `$a` — `array<array<int|float>>`, i.e. rows of numeric elements
+  - `$validate` — whether to validate that every row has the same column count (default `true`)
+- **Returns:** `Matrix`
+- **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$a` is not an array of arrays, or (when validating) if rows have unequal column counts
 
 ### `Matrix::identity(int $n) : Matrix`
 
diff --git a/docs/Vector.md b/docs/Vector.md
index 45cd0ef..7cfc2bd 100644
--- a/docs/Vector.md
+++ b/docs/Vector.md
@@ -14,28 +14,12 @@ Interface methods are implemented by Vectors with scalar-level semantics — red
 
 ## Constructors & Factories
 
-### `__construct(array $a, bool $validate = true)`
+### `__construct(array $a)`
 
-Instantiate a vector directly.
+Instantiate a vector directly from an array of elements.
 
-- **Parameters:**
-  - `$a` — the 1-dimensional element array `(int|float)[]`
-  - `$validate` — whether to validate and cast elements to floats (default `true`)
-- **Note:** Prefer the factory methods below.
-
-### `Vector::build(array $a = [])`
-
-Factory method to build a new vector from an array, running validation.
-
-- **Parameters:** `$a` — `(int|float)[]`
-- **Returns:** `mixed` (a `Vector`/`static`)
-
-### `Vector::quick(array $a = [])`
-
-Build a vector foregoing any validation for quicker instantiation.
-
-- **Parameters:** `$a` — `(int|float)[]`
-- **Returns:** `mixed` (a `Vector`/`static`)
+- **Parameters:** `$a` — the 1-dimensional element array `(int|float)[]`
+- **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$a` is not an array or a `TensorBuffer`
 
 ### `Vector::zeros(int $n) : Vector`
 
diff --git a/docs/getting-started.md b/docs/getting-started.md
index e94f884..2afa6fa 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -42,13 +42,13 @@ use Tensor\Matrix;
 use Tensor\Vector;
 
 // Build a 2 x 3 matrix.
-$a = Matrix::build([
+$a = Matrix::fromArray([
     [1.0, 2.0, 3.0],
     [4.0, 5.0, 6.0],
 ]);
 
 // Build a 3 x 2 matrix.
-$b = Matrix::build([
+$b = Matrix::fromArray([
     [7.0, 8.0],
     [9.0, 10.0],
     [11.0, 12.0],
diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index 6b0f6d4..383054a 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -12,10 +12,10 @@
 #include <Zend/zend_interfaces.h>
 
 #include "kernel/main.h"
+#include "kernel/object.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 "include/arithmetic.h"
@@ -38,103 +38,6 @@ ZEPHIR_INIT_CLASS(Tensor_ColumnVector)
 	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_UNDEF(&a);
-	ZVAL_UNDEF(&_0);
-	ZEND_PARSE_PARAMETERS_START(0, 1)
-		Z_PARAM_OPTIONAL
-		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	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_UNDEF(&a);
-	ZVAL_UNDEF(&_0);
-	ZEND_PARSE_PARAMETERS_START(0, 1)
-		Z_PARAM_OPTIONAL
-		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	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();
-}
-
-/**
- * Build a column vector from a TensorBuffer object.
- *
- * @param \Tensor\TensorBuffer a
- * @return self
- */
-PHP_METHOD(Tensor_ColumnVector, fromTensorBuffer)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a, a_sub, _0;
-
-	ZVAL_UNDEF(&a_sub);
-	ZVAL_UNDEF(&_0);
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 0, &a);
-	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.
  *
@@ -177,8 +80,9 @@ PHP_METHOD(Tensor_ColumnVector, transpose)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_vector_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 3, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -270,9 +174,9 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 103);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 70);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -283,11 +187,12 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_multiply_col(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -351,9 +256,9 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 126);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 93);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -364,11 +269,12 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_divide_col_reverse(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -432,9 +338,9 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 149);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 116);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -445,11 +351,12 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_add_col(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -513,9 +420,9 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 172);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 139);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -526,11 +433,12 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_subtract_col_reverse(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -594,9 +502,9 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 195);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 162);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -607,11 +515,12 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_pow_col_reverse(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -675,9 +584,9 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 218);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 185);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -688,11 +597,12 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_mod_col_reverse(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -756,9 +666,9 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 241);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 208);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -769,11 +679,12 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_equal_col(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -837,9 +748,9 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 264);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 231);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -850,11 +761,12 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_not_equal_col(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -918,9 +830,9 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 287);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 254);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -931,11 +843,12 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_greater_col_reverse(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -999,9 +912,9 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 310);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 277);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1012,11 +925,12 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_greater_equal_col_reverse(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1080,9 +994,9 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 333);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 300);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1093,11 +1007,12 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_less_col_reverse(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1161,9 +1076,9 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 		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_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 356);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 323);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1174,11 +1089,12 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 	ZEPHIR_CALL_METHOD(&_9, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_less_equal_col_reverse(&result, &bHat, &_8, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/columnvector.zep.h b/ext/tensor/columnvector.zep.h
index 5ed2d04..2cb3521 100644
--- a/ext/tensor/columnvector.zep.h
+++ b/ext/tensor/columnvector.zep.h
@@ -3,9 +3,6 @@ extern zend_class_entry *tensor_columnvector_ce;
 
 ZEPHIR_INIT_CLASS(Tensor_ColumnVector);
 
-PHP_METHOD(Tensor_ColumnVector, build);
-PHP_METHOD(Tensor_ColumnVector, quick);
-PHP_METHOD(Tensor_ColumnVector, fromTensorBuffer);
 PHP_METHOD(Tensor_ColumnVector, m);
 PHP_METHOD(Tensor_ColumnVector, n);
 PHP_METHOD(Tensor_ColumnVector, transpose);
@@ -23,18 +20,6 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix);
 PHP_METHOD(Tensor_ColumnVector, lessMatrix);
 PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix);
 
-ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_columnvector_build, 0, 0, 0)
-ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, a, IS_ARRAY, 0, "[]")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_columnvector_quick, 0, 0, 0)
-ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, a, IS_ARRAY, 0, "[]")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_columnvector_fromtensorbuffer, 0, 0, 1)
-	ZEND_ARG_OBJ_INFO(0, a, Tensor\\TensorBuffer, 0)
-ZEND_END_ARG_INFO()
-
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_columnvector_m, 0, 0, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
@@ -97,9 +82,6 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_columnvector_lessequalmatr
 ZEND_END_ARG_INFO()
 
 ZEPHIR_INIT_FUNCS(tensor_columnvector_method_entry) {
-	PHP_ME(Tensor_ColumnVector, build, arginfo_tensor_columnvector_build, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	PHP_ME(Tensor_ColumnVector, quick, arginfo_tensor_columnvector_quick, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	PHP_ME(Tensor_ColumnVector, fromTensorBuffer, arginfo_tensor_columnvector_fromtensorbuffer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_ColumnVector, m, arginfo_tensor_columnvector_m, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_ColumnVector, n, arginfo_tensor_columnvector_n, ZEND_ACC_PUBLIC)
 PHP_ME(Tensor_ColumnVector, transpose, arginfo_tensor_columnvector_transpose, ZEND_ACC_PUBLIC)
diff --git a/ext/tensor/decompositions/cholesky.zep.c b/ext/tensor/decompositions/cholesky.zep.c
index 51af189..3da199d 100644
--- a/ext/tensor/decompositions/cholesky.zep.c
+++ b/ext/tensor/decompositions/cholesky.zep.c
@@ -83,7 +83,7 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_1$$3, "tensor/decompositions/cholesky.zep", 37);
 		ZEPHIR_MM_RESTORE();
@@ -100,13 +100,15 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 		return;
 	}
 	object_init_ex(return_value, tensor_decompositions_cholesky_ce);
+	ZEPHIR_INIT_VAR(&_6);
+	object_init_ex(&_6, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_7, a, "n", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_8, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_CE_STATIC(&_6, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &l, &_7, &_8);
+	ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 15, &l, &_7, &_8);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_6);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 22, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/eigen.zep.c b/ext/tensor/decompositions/eigen.zep.c
index 02db1b3..de6b764 100644
--- a/ext/tensor/decompositions/eigen.zep.c
+++ b/ext/tensor/decompositions/eigen.zep.c
@@ -110,7 +110,7 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_1$$3, "tensor/decompositions/eigen.zep", 48);
 		ZEPHIR_MM_RESTORE();
@@ -144,17 +144,19 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	zephir_array_fetch_long(&_10, &eig, 0, PH_NOISY, "tensor/decompositions/eigen.zep", 67);
 	zephir_get_arrval(&_11, &_10);
 	ZEPHIR_CPY_WRT(&eigenvalues, &_11);
+	ZEPHIR_INIT_VAR(&_12);
+	object_init_ex(&_12, tensor_matrix_ce);
 	zephir_array_fetch_long(&_13, &eig, 1, PH_NOISY | PH_READONLY, "tensor/decompositions/eigen.zep", 68);
 	ZEPHIR_CALL_METHOD(&_14, a, "n", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_15, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_CE_STATIC(&_12, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_13, &_14, &_15);
+	ZEPHIR_CALL_METHOD(NULL, &_12, "__construct", NULL, 15, &_13, &_14, &_15);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&eigenvectors, &_12, "transpose", NULL, 0);
+	ZEPHIR_CALL_METHOD(&eigenvectors, &_12, "transpose", NULL, 23);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_eigen_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 22, &eigenvalues, &eigenvectors);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 24, &eigenvalues, &eigenvectors);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/lu.zep.c b/ext/tensor/decompositions/lu.zep.c
index 4ecc9aa..bdc667b 100644
--- a/ext/tensor/decompositions/lu.zep.c
+++ b/ext/tensor/decompositions/lu.zep.c
@@ -110,7 +110,7 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_1$$3, "tensor/decompositions/lu.zep", 52);
 		ZEPHIR_MM_RESTORE();
@@ -131,29 +131,35 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 	ZEPHIR_CPY_WRT(&_6, &result);
 	zephir_get_arrval(&_7, &_6);
 	ZEPHIR_CPY_WRT(&lup, &_7);
+	ZEPHIR_INIT_VAR(&l);
+	object_init_ex(&l, tensor_matrix_ce);
 	zephir_array_fetch_long(&_8, &lup, 0, PH_NOISY | PH_READONLY, "tensor/decompositions/lu.zep", 65);
 	ZEPHIR_CALL_METHOD(&_9, a, "n", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_10, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_CE_STATIC(&l, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_8, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, &l, "__construct", NULL, 15, &_8, &_9, &_10);
 	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&u);
+	object_init_ex(&u, tensor_matrix_ce);
 	zephir_array_fetch_long(&_11, &lup, 1, PH_NOISY | PH_READONLY, "tensor/decompositions/lu.zep", 66);
 	ZEPHIR_CALL_METHOD(&_12, a, "n", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_13, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_CE_STATIC(&u, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_11, &_12, &_13);
+	ZEPHIR_CALL_METHOD(NULL, &u, "__construct", NULL, 15, &_11, &_12, &_13);
 	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&p);
+	object_init_ex(&p, tensor_matrix_ce);
 	zephir_array_fetch_long(&_14, &lup, 2, PH_NOISY | PH_READONLY, "tensor/decompositions/lu.zep", 67);
 	ZEPHIR_CALL_METHOD(&_15, a, "n", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_16, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_CE_STATIC(&p, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_14, &_15, &_16);
+	ZEPHIR_CALL_METHOD(NULL, &p, "__construct", NULL, 15, &_14, &_15, &_16);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_lu_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &l, &u, &p);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &l, &u, &p);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/svd.zep.c b/ext/tensor/decompositions/svd.zep.c
index 338e28e..6c48761 100644
--- a/ext/tensor/decompositions/svd.zep.c
+++ b/ext/tensor/decompositions/svd.zep.c
@@ -109,26 +109,30 @@ PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 	ZEPHIR_CPY_WRT(&_3, &result);
 	zephir_get_arrval(&_4, &_3);
 	ZEPHIR_CPY_WRT(&usvT, &_4);
+	ZEPHIR_INIT_VAR(&u);
+	object_init_ex(&u, tensor_matrix_ce);
 	zephir_array_fetch_long(&_5, &usvT, 0, PH_NOISY | PH_READONLY, "tensor/decompositions/svd.zep", 55);
 	ZEPHIR_CALL_METHOD(&_6, a, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_7, a, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_CE_STATIC(&u, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_5, &_6, &_7);
+	ZEPHIR_CALL_METHOD(NULL, &u, "__construct", NULL, 15, &_5, &_6, &_7);
 	zephir_check_call_status();
 	zephir_memory_observe(&_8);
 	zephir_array_fetch_long(&_8, &usvT, 1, PH_NOISY, "tensor/decompositions/svd.zep", 56);
 	zephir_get_arrval(&_9, &_8);
 	ZEPHIR_CPY_WRT(&singularValues, &_9);
+	ZEPHIR_INIT_VAR(&vT);
+	object_init_ex(&vT, tensor_matrix_ce);
 	zephir_array_fetch_long(&_10, &usvT, 2, PH_NOISY | PH_READONLY, "tensor/decompositions/svd.zep", 57);
 	ZEPHIR_CALL_METHOD(&_11, a, "n", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_12, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_CE_STATIC(&vT, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_10, &_11, &_12);
+	ZEPHIR_CALL_METHOD(NULL, &vT, "__construct", NULL, 15, &_10, &_11, &_12);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_svd_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 24, &u, &singularValues, &vT);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 26, &u, &singularValues, &vT);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index bfcdf9d..9096abe 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -12,11 +12,11 @@
 #include <Zend/zend_interfaces.h>
 
 #include "kernel/main.h"
-#include "kernel/fcall.h"
 #include "kernel/memory.h"
+#include "kernel/fcall.h"
+#include "kernel/array.h"
 #include "kernel/operators.h"
 #include "kernel/object.h"
-#include "kernel/array.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
 #include "kernel/string.h"
@@ -66,109 +66,6 @@ ZEPHIR_INIT_CLASS(Tensor_Matrix)
 	return SUCCESS;
 }
 
-/**
- * Build a new matrix from a PHP array of arrays, validating the input.
- *
- * @param array[] a
- * @throws \Tensor\Exceptions\InvalidArgumentException
- * @return self
- */
-PHP_METHOD(Tensor_Matrix, build)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a_param = NULL, _0;
-	zval a;
-
-	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&_0);
-	ZEND_PARSE_PARAMETERS_START(0, 1)
-		Z_PARAM_OPTIONAL
-		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	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);
-	}
-	ZVAL_BOOL(&_0, 1);
-	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_0);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
-/**
- * Build a new matrix from a PHP array of arrays, foregoing any row
- * validation for quicker instantiation.
- *
- * @param array[] a
- * @return self
- */
-PHP_METHOD(Tensor_Matrix, quick)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a_param = NULL, _0;
-	zval a;
-
-	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&_0);
-	ZEND_PARSE_PARAMETERS_START(0, 1)
-		Z_PARAM_OPTIONAL
-		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	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);
-	}
-	ZVAL_BOOL(&_0, 0);
-	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_0);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
-/**
- * Build a matrix from a TensorBuffer object.
- *
- * @param \Tensor\TensorBuffer a
- * @param int m
- * @param int n
- * @return self
- */
-PHP_METHOD(Tensor_Matrix, fromTensorBuffer)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long m, n, ZEPHIR_LAST_CALL_STATUS;
-	zval *a, a_sub, *m_param = NULL, *n_param = NULL, _0, _1;
-
-	ZVAL_UNDEF(&a_sub);
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZEND_PARSE_PARAMETERS_START(3, 3)
-		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
-		Z_PARAM_LONG(m)
-		Z_PARAM_LONG(n)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 3, 0, &a, &m_param, &n_param);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZVAL_LONG(&_0, m);
-	ZVAL_LONG(&_1, n);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, a, &_0, &_1);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
 /**
  * Build a matrix by concatenating an array of TensorBuffers (each buffer
  * representing one row) into a single contiguous buffer.
@@ -220,24 +117,24 @@ PHP_METHOD(Tensor_Matrix, fromTensorBuffers)
 		zephir_check_call_status();
 		ZVAL_LONG(&_3$$3, 0);
 		ZVAL_LONG(&_4$$3, 0);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &_1$$3, &_3$$3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_1$$3, &_3$$3, &_4$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
 	zephir_memory_observe(&_5);
-	zephir_array_fetch_long(&_5, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 101);
+	zephir_array_fetch_long(&_5, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 64);
 	ZEPHIR_CALL_METHOD(&nHat, &_5, "count", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(rows == 1)) {
 		zephir_memory_observe(&_6$$4);
-		zephir_array_fetch_long(&_6$$4, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 106);
+		zephir_array_fetch_long(&_6$$4, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 69);
 		ZEPHIR_CALL_METHOD(&b, &_6$$4, "asBuffer", NULL, 0);
 		zephir_check_call_status();
 	} else {
 		zephir_memory_observe(&_7$$5);
-		zephir_array_fetch_long(&_7$$5, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 108);
+		zephir_array_fetch_long(&_7$$5, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 71);
 		ZVAL_LONG(&_8$$5, 1);
-		ZEPHIR_CALL_FUNCTION(&_9$$5, "array_slice", NULL, 26, &buffers, &_8$$5);
+		ZEPHIR_CALL_FUNCTION(&_9$$5, "array_slice", NULL, 27, &buffers, &_8$$5);
 		zephir_check_call_status();
 		ZEPHIR_CALL_METHOD(&b, &_7$$5, "concat", NULL, 0, &_9$$5);
 		zephir_check_call_status();
@@ -251,7 +148,7 @@ PHP_METHOD(Tensor_Matrix, fromTensorBuffers)
 	ZEPHIR_CALL_METHOD(NULL, &_11, "__construct", &_2, 14, &b);
 	zephir_check_call_status();
 	ZVAL_LONG(&_12, rows);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &_11, &_12, &nHat);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_11, &_12, &nHat);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -338,20 +235,20 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 		zephir_check_call_status();
 		ZVAL_LONG(&_3$$3, 0);
 		ZVAL_LONG(&_4$$3, 0);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &_1$$3, &_3$$3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_1$$3, &_3$$3, &_4$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 27, &a);
+	ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 28, &a);
 	zephir_check_call_status();
 	if (UNEXPECTED(!(Z_TYPE_P(&firstRow) == IS_ARRAY))) {
 		ZEPHIR_INIT_VAR(&_5$$4);
 		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		ZEPHIR_CONCAT_SS(&_6$$4, "Matrix requires an", " array of arrays.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_6$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 141);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 104);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -359,7 +256,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZVAL_LONG(&n, zephir_fast_count_int(&firstRow));
 	ZEPHIR_INIT_VAR(&flat);
 	array_init(&flat);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 165);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 128);
 	if (Z_TYPE_P(&a) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _7)
 		{
@@ -374,9 +271,9 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 				object_init_ex(&_9$$6, tensor_exceptions_invalidargumentexception_ce);
 				ZEPHIR_INIT_NVAR(&_10$$6);
 				ZEPHIR_CONCAT_SS(&_10$$6, "Matrix requires an", " array of arrays.");
-				ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", NULL, 3, &_10$$6);
+				ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", NULL, 2, &_10$$6);
 				zephir_check_call_status();
-				zephir_throw_exception_debug(&_9$$6, "tensor/matrix.zep", 151);
+				zephir_throw_exception_debug(&_9$$6, "tensor/matrix.zep", 114);
 				ZEPHIR_MM_RESTORE();
 				return;
 			}
@@ -387,15 +284,15 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 			if (UNEXPECTED(_11$$5)) {
 				ZEPHIR_INIT_NVAR(&_12$$7);
 				object_init_ex(&_12$$7, tensor_exceptions_invalidargumentexception_ce);
-				ZEPHIR_CALL_FUNCTION(&_13$$7, "strval", &_14, 4, &n);
+				ZEPHIR_CALL_FUNCTION(&_13$$7, "strval", &_14, 3, &n);
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_15$$7);
 				ZVAL_LONG(&_15$$7, zephir_fast_count_int(&rowA));
 				ZEPHIR_INIT_NVAR(&_16$$7);
 				ZEPHIR_CONCAT_SSVSVS(&_16$$7, "The number of", " columns must be equal for all rows, ", &_13$$7, " needed but ", &_15$$7, " given.");
-				ZEPHIR_CALL_METHOD(NULL, &_12$$7, "__construct", NULL, 3, &_16$$7);
+				ZEPHIR_CALL_METHOD(NULL, &_12$$7, "__construct", NULL, 2, &_16$$7);
 				zephir_check_call_status();
-				zephir_throw_exception_debug(&_12$$7, "tensor/matrix.zep", 157);
+				zephir_throw_exception_debug(&_12$$7, "tensor/matrix.zep", 120);
 				ZEPHIR_MM_RESTORE();
 				return;
 			}
@@ -406,7 +303,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 			} else {
 				_17$$5 = &rowA;
 			}
-			zephir_is_iterable(_17$$5, 0, "tensor/matrix.zep", 163);
+			zephir_is_iterable(_17$$5, 0, "tensor/matrix.zep", 126);
 			if (Z_TYPE_P(_17$$5) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$5), _19$$5)
 				{
@@ -414,7 +311,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 					ZVAL_COPY(&valueA, _19$$5);
 					ZEPHIR_INIT_NVAR(&_20$$8);
 					ZVAL_DOUBLE(&_20$$8, zephir_get_doubleval(&valueA));
-					zephir_array_append(&flat, &_20$$8, PH_SEPARATE, "tensor/matrix.zep", 161);
+					zephir_array_append(&flat, &_20$$8, PH_SEPARATE, "tensor/matrix.zep", 124);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _17$$5, "rewind", NULL, 0);
@@ -436,7 +333,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 					zephir_check_call_status();
 						ZEPHIR_INIT_NVAR(&_23$$9);
 						ZVAL_DOUBLE(&_23$$9, zephir_get_doubleval(&valueA));
-						zephir_array_append(&flat, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 161);
+						zephir_array_append(&flat, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 124);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
@@ -468,9 +365,9 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 					object_init_ex(&_27$$11, tensor_exceptions_invalidargumentexception_ce);
 					ZEPHIR_INIT_NVAR(&_28$$11);
 					ZEPHIR_CONCAT_SS(&_28$$11, "Matrix requires an", " array of arrays.");
-					ZEPHIR_CALL_METHOD(NULL, &_27$$11, "__construct", NULL, 3, &_28$$11);
+					ZEPHIR_CALL_METHOD(NULL, &_27$$11, "__construct", NULL, 2, &_28$$11);
 					zephir_check_call_status();
-					zephir_throw_exception_debug(&_27$$11, "tensor/matrix.zep", 151);
+					zephir_throw_exception_debug(&_27$$11, "tensor/matrix.zep", 114);
 					ZEPHIR_MM_RESTORE();
 					return;
 				}
@@ -481,15 +378,15 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 				if (UNEXPECTED(_29$$10)) {
 					ZEPHIR_INIT_NVAR(&_30$$12);
 					object_init_ex(&_30$$12, tensor_exceptions_invalidargumentexception_ce);
-					ZEPHIR_CALL_FUNCTION(&_31$$12, "strval", &_14, 4, &n);
+					ZEPHIR_CALL_FUNCTION(&_31$$12, "strval", &_14, 3, &n);
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_32$$12);
 					ZVAL_LONG(&_32$$12, zephir_fast_count_int(&rowA));
 					ZEPHIR_INIT_NVAR(&_33$$12);
 					ZEPHIR_CONCAT_SSVSVS(&_33$$12, "The number of", " columns must be equal for all rows, ", &_31$$12, " needed but ", &_32$$12, " given.");
-					ZEPHIR_CALL_METHOD(NULL, &_30$$12, "__construct", NULL, 3, &_33$$12);
+					ZEPHIR_CALL_METHOD(NULL, &_30$$12, "__construct", NULL, 2, &_33$$12);
 					zephir_check_call_status();
-					zephir_throw_exception_debug(&_30$$12, "tensor/matrix.zep", 157);
+					zephir_throw_exception_debug(&_30$$12, "tensor/matrix.zep", 120);
 					ZEPHIR_MM_RESTORE();
 					return;
 				}
@@ -500,7 +397,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 				} else {
 					_34$$10 = &rowA;
 				}
-				zephir_is_iterable(_34$$10, 0, "tensor/matrix.zep", 163);
+				zephir_is_iterable(_34$$10, 0, "tensor/matrix.zep", 126);
 				if (Z_TYPE_P(_34$$10) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_34$$10), _36$$10)
 					{
@@ -508,7 +405,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 						ZVAL_COPY(&valueA, _36$$10);
 						ZEPHIR_INIT_NVAR(&_37$$13);
 						ZVAL_DOUBLE(&_37$$13, zephir_get_doubleval(&valueA));
-						zephir_array_append(&flat, &_37$$13, PH_SEPARATE, "tensor/matrix.zep", 161);
+						zephir_array_append(&flat, &_37$$13, PH_SEPARATE, "tensor/matrix.zep", 124);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _34$$10, "rewind", NULL, 0);
@@ -530,7 +427,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 						zephir_check_call_status();
 							ZEPHIR_INIT_NVAR(&_40$$14);
 							ZVAL_DOUBLE(&_40$$14, zephir_get_doubleval(&valueA));
-							zephir_array_append(&flat, &_40$$14, PH_SEPARATE, "tensor/matrix.zep", 161);
+							zephir_array_append(&flat, &_40$$14, PH_SEPARATE, "tensor/matrix.zep", 124);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
@@ -545,7 +442,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZEPHIR_CALL_METHOD(NULL, &_41, "__construct", &_2, 14, &buffer);
 	zephir_check_call_status();
 	ZVAL_LONG(&_42, rows);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &_41, &_42, &n);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_41, &_42, &n);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -562,13 +459,14 @@ PHP_METHOD(Tensor_Matrix, identity)
 	zend_bool _4, _7$$4;
 	zval a, rowA;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *n_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _10$$5;
+	zval *n_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _11, _10$$5;
 	zend_long n, ZEPHIR_LAST_CALL_STATUS, i = 0, j = 0, _5, _6, _8$$4, _9$$4;
 
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_10$$5);
 	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&rowA);
@@ -582,13 +480,13 @@ PHP_METHOD(Tensor_Matrix, identity)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, n);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 181);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 144);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -634,13 +532,14 @@ PHP_METHOD(Tensor_Matrix, identity)
 						ZEPHIR_INIT_NVAR(&_10$$5);
 						ZVAL_DOUBLE(&_10$$5, 0.0);
 					}
-					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 193);
+					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 156);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 196);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 159);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
+	ZVAL_BOOL(&_11, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -721,13 +620,14 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 	zend_bool _1, _4$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, n, i = 0, j = 0, _2, _3, _5$$3, _6$$3;
-	zval *elements_param = NULL, _0, _7$$4;
+	zval *elements_param = NULL, _0, _8, _7$$4;
 	zval elements, a, rowA;
 
 	ZVAL_UNDEF(&elements);
 	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_7$$4);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		ZEPHIR_Z_PARAM_ARRAY(elements, elements_param)
@@ -737,7 +637,7 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 	zephir_fetch_params(1, 1, 0, &elements_param);
 	zephir_get_arrval(&elements, elements_param);
 	n = zephir_fast_count_int(&elements);
-	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 28, &elements);
+	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 29, &elements);
 	zephir_check_call_status();
 	ZEPHIR_CPY_WRT(&elements, &_0);
 	ZEPHIR_INIT_VAR(&a);
@@ -777,18 +677,19 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 					ZEPHIR_INIT_NVAR(&_7$$4);
 					if (i == j) {
 						ZEPHIR_OBS_NVAR(&_7$$4);
-						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 250);
+						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 213);
 					} else {
 						ZEPHIR_INIT_NVAR(&_7$$4);
 						ZVAL_DOUBLE(&_7$$4, 0.0);
 					}
-					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 250);
+					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 213);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 253);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 216);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
+	ZVAL_BOOL(&_8, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -836,13 +737,13 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, m);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 272);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 235);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -850,26 +751,27 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_INIT_VAR(&_5$$4);
 		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_6$$4, n);
-		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 4, &_6$$4);
+		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 3, &_6$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_8$$4);
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_8$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 277);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 240);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZVAL_LONG(&_9, 0);
 	ZVAL_LONG(&_10, n);
 	ZVAL_DOUBLE(&_11, value);
-	ZEPHIR_CALL_FUNCTION(&_12, "array_fill", &_13, 5, &_9, &_10, &_11);
+	ZEPHIR_CALL_FUNCTION(&_12, "array_fill", &_13, 4, &_9, &_10, &_11);
 	zephir_check_call_status();
 	ZVAL_LONG(&_9, 0);
 	ZVAL_LONG(&_10, m);
-	ZEPHIR_CALL_FUNCTION(&_14, "array_fill", &_13, 5, &_9, &_10, &_12);
+	ZEPHIR_CALL_FUNCTION(&_14, "array_fill", &_13, 4, &_9, &_10, &_12);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_14);
+	ZVAL_BOOL(&_9, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &_14, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -887,7 +789,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 	zval a, rowA;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_3 = NULL, *_11 = NULL;
-	zval *m_param = NULL, *n_param = NULL, _0$$3, _1$$3, _2$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, _9, _10$$6, _12$$6;
+	zval *m_param = NULL, *n_param = NULL, _0$$3, _1$$3, _2$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, _9, _13, _10$$6, _12$$6;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS, max;
 
 	ZVAL_UNDEF(&_0$$3);
@@ -899,6 +801,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 	ZVAL_UNDEF(&_7$$4);
 	ZVAL_UNDEF(&_8$$4);
 	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_10$$6);
 	ZVAL_UNDEF(&_12$$6);
 	ZVAL_UNDEF(&a);
@@ -914,13 +817,13 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, m);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 295);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 258);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -928,13 +831,13 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_INIT_VAR(&_5$$4);
 		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_6$$4, n);
-		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 4, &_6$$4);
+		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 3, &_6$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_8$$4);
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_8$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 300);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 263);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -959,11 +862,12 @@ PHP_METHOD(Tensor_Matrix, rand)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_12$$6);
 			ZVAL_DOUBLE(&_12$$6, zephir_safe_div_zval_long(&_10$$6, max));
-			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 312);
+			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 275);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 315);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 278);
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
+	ZVAL_BOOL(&_13, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_13);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -982,7 +886,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 	double r = 0, phi = 0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_3 = NULL, *_11 = NULL, *_13 = NULL, *_16 = NULL;
-	zval *m_param = NULL, *n_param = NULL, _0$$3, _1$$3, _2$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, _9, _10$$6, _12$$7, _14$$7, _15$$7, _17$$7, _18$$7, _19$$7, _20$$7, _21$$8;
+	zval *m_param = NULL, *n_param = NULL, _0$$3, _1$$3, _2$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, _9, _22, _10$$6, _12$$7, _14$$7, _15$$7, _17$$7, _18$$7, _19$$7, _20$$7, _21$$8;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS, max;
 
 	ZVAL_UNDEF(&_0$$3);
@@ -994,6 +898,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 	ZVAL_UNDEF(&_7$$4);
 	ZVAL_UNDEF(&_8$$4);
 	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_22);
 	ZVAL_UNDEF(&_10$$6);
 	ZVAL_UNDEF(&_12$$7);
 	ZVAL_UNDEF(&_14$$7);
@@ -1017,13 +922,13 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, m);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 333);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 296);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1031,13 +936,13 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_INIT_VAR(&_5$$4);
 		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_6$$4, n);
-		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 4, &_6$$4);
+		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 3, &_6$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_8$$4);
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_8$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 338);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 301);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1061,7 +966,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZEPHIR_CALL_FUNCTION(&_10$$6, "array_pop", &_11, 9, &extras);
 			ZEPHIR_UNREF(&extras);
 			zephir_check_call_status();
-			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 353);
+			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 316);
 		}
 		while (1) {
 			if (!(zephir_fast_count_int(&rowA) < n)) {
@@ -1080,22 +985,23 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZVAL_DOUBLE(&_18$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * sin(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 361);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 324);
 			ZVAL_DOUBLE(&_20$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * cos(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 362);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 325);
 		}
 		if (zephir_fast_count_int(&rowA) > n) {
 			ZEPHIR_MAKE_REF(&rowA);
 			ZEPHIR_CALL_FUNCTION(&_21$$8, "array_pop", &_11, 9, &rowA);
 			ZEPHIR_UNREF(&rowA);
 			zephir_check_call_status();
-			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 366);
+			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 329);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 369);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 332);
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
+	ZVAL_BOOL(&_22, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_22);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1158,13 +1064,13 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, m);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 388);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 351);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1172,13 +1078,13 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_INIT_VAR(&_5$$4);
 		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_6$$4, n);
-		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 4, &_6$$4);
+		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 3, &_6$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_8$$4);
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_8$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 393);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 356);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1186,13 +1092,13 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_INIT_VAR(&_9$$5);
 		object_init_ex(&_9$$5, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_DOUBLE(&_10$$5, lambda);
-		ZEPHIR_CALL_FUNCTION(&_11$$5, "strval", &_3, 4, &_10$$5);
+		ZEPHIR_CALL_FUNCTION(&_11$$5, "strval", &_3, 3, &_10$$5);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_12$$5);
 		ZEPHIR_CONCAT_SSVS(&_12$$5, "Lambda must be", " greater than or equal to 0, ", &_11$$5, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 3, &_12$$5);
+		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 2, &_12$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 398);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 361);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1238,11 +1144,12 @@ PHP_METHOD(Tensor_Matrix, poisson)
 			}
 			ZEPHIR_INIT_NVAR(&_21$$8);
 			ZVAL_DOUBLE(&_21$$8, (k - 1.0));
-			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 427);
+			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 390);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 430);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 393);
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
+	ZVAL_BOOL(&_16, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_16);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1260,7 +1167,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 	zval a, rowA;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_3 = NULL, *_13 = NULL;
-	zval *m_param = NULL, *n_param = NULL, _0$$3, _1$$3, _2$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, _9, _10$$6, _11$$6, _12$$6, _14$$6;
+	zval *m_param = NULL, *n_param = NULL, _0$$3, _1$$3, _2$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, _9, _15, _10$$6, _11$$6, _12$$6, _14$$6;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS, max;
 
 	ZVAL_UNDEF(&_0$$3);
@@ -1272,6 +1179,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 	ZVAL_UNDEF(&_7$$4);
 	ZVAL_UNDEF(&_8$$4);
 	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_15);
 	ZVAL_UNDEF(&_10$$6);
 	ZVAL_UNDEF(&_11$$6);
 	ZVAL_UNDEF(&_12$$6);
@@ -1289,13 +1197,13 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, m);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 448);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 411);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1303,13 +1211,13 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_INIT_VAR(&_5$$4);
 		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_6$$4, n);
-		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 4, &_6$$4);
+		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 3, &_6$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_8$$4);
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_8$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 453);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 416);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1336,11 +1244,12 @@ PHP_METHOD(Tensor_Matrix, uniform)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_14$$6);
 			ZVAL_DOUBLE(&_14$$6, zephir_safe_div_zval_long(&_12$$6, max));
-			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 465);
+			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 428);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 468);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 431);
 	}
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
+	ZVAL_BOOL(&_15, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_15);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1585,19 +1494,20 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 		object_init_ex(&_2$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SS(&_3$$3, "Row offset out of", " bounds.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 560);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 523);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, tensor_vector_ce);
 	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_8, (index * (zend_long) zephir_get_numberval(&_6)));
 	ZEPHIR_CALL_METHOD(&_5, &_4, "slice", NULL, 0, &_8, &_7);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1655,19 +1565,20 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 		object_init_ex(&_2$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SS(&_3$$3, "Column offset out of", " bounds.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 577);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 540);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, tensor_columnvector_ce);
 	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_8, index);
 	ZEPHIR_CALL_METHOD(&_5, &_4, "sliceStrided", NULL, 0, &_8, &_6, &_7);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromTensorBuffer", NULL, 0, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1719,12 +1630,13 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 593);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 556);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, tensor_vector_ce);
 	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
@@ -1732,7 +1644,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 	ZVAL_LONG(&_9, (zephir_get_numberval(&_7) + 1));
 	ZEPHIR_CALL_METHOD(&_5, &_4, "sliceStrided", NULL, 0, &_8, &_6, &_9);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1757,8 +1669,9 @@ PHP_METHOD(Tensor_Matrix, asVector)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_vector_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1827,7 +1740,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 638);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 601);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -1835,7 +1748,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 635);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 598);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -1857,7 +1770,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 635);
+				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 598);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -1956,15 +1869,17 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 674);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 637);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
 			ZEPHIR_INIT_NVAR(&rowBuffer);
 			ZVAL_COPY(&rowBuffer, _6);
-			ZEPHIR_CALL_CE_STATIC(&_7$$4, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
+			ZEPHIR_INIT_NVAR(&_7$$4);
+			object_init_ex(&_7$$4, tensor_vector_ce);
+			ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", &_8, 5, &rowBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 671);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 634);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -1984,9 +1899,11 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			}
 			ZEPHIR_CALL_METHOD(&rowBuffer, _4, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_CALL_CE_STATIC(&_11$$5, tensor_vector_ce, "fromTensorBuffer", &_8, 0, &rowBuffer);
+				ZEPHIR_INIT_NVAR(&_11$$5);
+				object_init_ex(&_11$$5, tensor_vector_ce);
+				ZEPHIR_CALL_METHOD(NULL, &_11$$5, "__construct", &_8, 5, &rowBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 671);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 634);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -2058,7 +1975,7 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 693);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 656);
 		}
 	}
 	RETURN_CTOR(&b);
@@ -2110,15 +2027,17 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 718);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 681);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
 			ZEPHIR_INIT_NVAR(&columnBuffer);
 			ZVAL_COPY(&columnBuffer, _4);
-			ZEPHIR_CALL_CE_STATIC(&_5$$4, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
+			ZEPHIR_INIT_NVAR(&_5$$4);
+			object_init_ex(&_5$$4, tensor_columnvector_ce);
+			ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_6, 5, &columnBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 715);
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 678);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -2138,9 +2057,11 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			}
 			ZEPHIR_CALL_METHOD(&columnBuffer, _2, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_CALL_CE_STATIC(&_9$$5, tensor_columnvector_ce, "fromTensorBuffer", &_6, 0, &columnBuffer);
+				ZEPHIR_INIT_NVAR(&_9$$5);
+				object_init_ex(&_9$$5, tensor_columnvector_ce);
+				ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", &_6, 5, &columnBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 715);
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 678);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&columnBuffer);
@@ -2185,8 +2106,9 @@ PHP_METHOD(Tensor_Matrix, flatten)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_vector_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2230,12 +2152,13 @@ PHP_METHOD(Tensor_Matrix, map)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &callback);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_1, &_0, "map", NULL, 0, callback);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_1, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_1, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2283,7 +2206,7 @@ PHP_METHOD(Tensor_Matrix, reduce)
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_2, initial);
-	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 16, &_1, callback, &_2);
+	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 17, &_1, callback, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2295,17 +2218,19 @@ PHP_METHOD(Tensor_Matrix, reduce)
  */
 PHP_METHOD(Tensor_Matrix, transpose)
 {
-	zval col, cols, _0, _1, _2, _3;
+	zval col, cols, _2, _3, _4, _5, _0$$3, _1$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&col);
 	ZVAL_UNDEF(&cols);
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_1$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -2320,21 +2245,25 @@ PHP_METHOD(Tensor_Matrix, transpose)
 	ZEPHIR_CALL_METHOD(&cols, this_ptr, "asColumnBuffers", NULL, 0);
 	zephir_check_call_status();
 	if (UNEXPECTED(zephir_fast_count_int(&cols) < 1)) {
-		ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0);
+		ZEPHIR_INIT_VAR(&_0$$3);
+		array_init(&_0$$3);
+		ZVAL_BOOL(&_1$$3, 0);
+		ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &_0$$3, &_1$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
 	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 783);
-	ZVAL_LONG(&_1, 1);
-	ZEPHIR_CALL_FUNCTION(&_2, "array_slice", NULL, 26, &cols, &_1);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 746);
+	ZVAL_LONG(&_3, 1);
+	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 27, &cols, &_3);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_0, &col, "concat", NULL, 0, &_2);
+	ZEPHIR_CALL_METHOD(&_2, &col, "concat", NULL, 0, &_4);
 	zephir_check_call_status();
-	ZEPHIR_CPY_WRT(&col, &_0);
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &col, &_1, &_3);
+	ZEPHIR_CPY_WRT(&col, &_2);
+	object_init_ex(return_value, tensor_matrix_ce);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &col, &_3, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2387,9 +2316,9 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 800);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 763);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2400,9 +2329,9 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_5$$4, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 29, &_6$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 30, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 805);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 768);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2415,15 +2344,16 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_9$$5, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_10$$5);
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 29, &_10$$5);
+		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 30, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 812);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 775);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_11, &_12);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_11, &_12);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2474,15 +2404,16 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		object_init_ex(&_3$$3, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 29, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 30, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 829);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 792);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_5, &_6);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_5, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2523,9 +2454,9 @@ PHP_METHOD(Tensor_Matrix, det)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 845);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 808);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2540,7 +2471,7 @@ PHP_METHOD(Tensor_Matrix, det)
 	ZEPHIR_CALL_METHOD(&_6, &ref, "swaps", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_7, -1.0);
-	ZEPHIR_CALL_FUNCTION(&_8, "pow", NULL, 17, &_7, &_6);
+	ZEPHIR_CALL_FUNCTION(&_8, "pow", NULL, 18, &_7, &_6);
 	zephir_check_call_status();
 	mul_function(return_value, &pi, &_8);
 	RETURN_MM();
@@ -2625,7 +2556,7 @@ PHP_METHOD(Tensor_Matrix, fullRank)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_1, this_ptr, "shape", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 30, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 31, &_1);
 	zephir_check_call_status();
 	RETURN_MM_BOOL(ZEPHIR_IS_IDENTICAL(&_0, &_2));
 }
@@ -2732,9 +2663,9 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 913);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 876);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2746,10 +2677,11 @@ PHP_METHOD(Tensor_Matrix, matmul)
 	ZEPHIR_CALL_METHOD(&_12, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_matmul(&result, &_8, &_9, &_10, &_11, &_12);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_14, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_13, &_14);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_13, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2806,9 +2738,9 @@ PHP_METHOD(Tensor_Matrix, dot)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 933);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 896);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2904,9 +2836,9 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		object_init_ex(&_5$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_6$$3);
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 3, &_6$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 2, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 951);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 914);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2914,13 +2846,13 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_INIT_VAR(&_7$$4);
 		object_init_ex(&_7$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_8$$4, stride);
-		ZEPHIR_CALL_FUNCTION(&_9$$4, "strval", NULL, 4, &_8$$4);
+		ZEPHIR_CALL_FUNCTION(&_9$$4, "strval", NULL, 3, &_8$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_10$$4);
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 3, &_10$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 2, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 956);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 919);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2938,18 +2870,19 @@ PHP_METHOD(Tensor_Matrix, convolve)
 	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_19, ((zephir_get_numberval(&_18) + stride) - 1));
 	ZVAL_LONG(&_20, stride);
-	ZEPHIR_CALL_FUNCTION(&_21, "intdiv", NULL, 18, &_19, &_20);
+	ZEPHIR_CALL_FUNCTION(&_21, "intdiv", NULL, 19, &_19, &_20);
 	zephir_check_call_status();
 	outM = zephir_get_intval(&_21);
 	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_20, ((zephir_get_numberval(&_19) + stride) - 1));
 	ZVAL_LONG(&_22, stride);
-	ZEPHIR_CALL_FUNCTION(&_23, "intdiv", NULL, 18, &_20, &_22);
+	ZEPHIR_CALL_FUNCTION(&_23, "intdiv", NULL, 19, &_20, &_22);
 	zephir_check_call_status();
 	outN = zephir_get_intval(&_23);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZVAL_LONG(&_20, outM);
 	ZVAL_LONG(&_22, outN);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_20, &_22);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_20, &_22);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3254,9 +3187,9 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1100);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1063);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3325,9 +3258,9 @@ PHP_METHOD(Tensor_Matrix, divide)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1133);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1096);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3397,9 +3330,9 @@ PHP_METHOD(Tensor_Matrix, add)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1167);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1130);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3469,9 +3402,9 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1201);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1164);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3541,9 +3474,9 @@ PHP_METHOD(Tensor_Matrix, pow)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1235);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1198);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3613,9 +3546,9 @@ PHP_METHOD(Tensor_Matrix, mod)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1269);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1232);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3685,9 +3618,9 @@ PHP_METHOD(Tensor_Matrix, equal)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1303);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1266);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3757,9 +3690,9 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1337);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1300);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3829,9 +3762,9 @@ PHP_METHOD(Tensor_Matrix, greater)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1371);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1334);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3901,9 +3834,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1405);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1368);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3973,9 +3906,9 @@ PHP_METHOD(Tensor_Matrix, less)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1439);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1402);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4045,9 +3978,9 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1473);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1436);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4118,12 +4051,13 @@ PHP_METHOD(Tensor_Matrix, abs)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_abs(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4177,12 +4111,13 @@ PHP_METHOD(Tensor_Matrix, sqrt)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_sqrt(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4218,12 +4153,13 @@ PHP_METHOD(Tensor_Matrix, exp)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_exp(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4259,12 +4195,13 @@ PHP_METHOD(Tensor_Matrix, expm1)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_expm1(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4318,22 +4255,24 @@ PHP_METHOD(Tensor_Matrix, log)
 		base = zephir_get_doubleval(base_param);
 	}
 	if (base == 2.7182818284590452354) {
+		object_init_ex(return_value, tensor_matrix_ce);
 		ZEPHIR_INIT_VAR(&_0$$3);
 		zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 		tensor_log(&_0$$3, &_1$$3);
 		zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 		zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-		ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0$$3, &_2$$3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0$$3, &_2$$3, &_3$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_4);
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_6, base);
 	tensor_log_base(&_4, &_5, &_6);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_4, &_7, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_4, &_7, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4369,12 +4308,13 @@ PHP_METHOD(Tensor_Matrix, log1p)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_log1p(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4410,12 +4350,13 @@ PHP_METHOD(Tensor_Matrix, sin)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_sin(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4451,12 +4392,13 @@ PHP_METHOD(Tensor_Matrix, asin)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_asin(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4492,12 +4434,13 @@ PHP_METHOD(Tensor_Matrix, cos)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_cos(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4533,12 +4476,13 @@ PHP_METHOD(Tensor_Matrix, acos)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_acos(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4574,12 +4518,13 @@ PHP_METHOD(Tensor_Matrix, tan)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_tan(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4615,12 +4560,13 @@ PHP_METHOD(Tensor_Matrix, atan)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_atan(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4656,12 +4602,13 @@ PHP_METHOD(Tensor_Matrix, rad2deg)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_rad2deg(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4697,12 +4644,13 @@ PHP_METHOD(Tensor_Matrix, deg2rad)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_deg2rad(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4754,7 +4702,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1659);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1622);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4762,7 +4710,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1656);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1619);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4784,11 +4732,12 @@ PHP_METHOD(Tensor_Matrix, sum)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1656);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1619);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4840,7 +4789,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1677);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1640);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4848,7 +4797,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1674);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1637);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4870,11 +4819,12 @@ PHP_METHOD(Tensor_Matrix, product)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1674);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1637);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4926,7 +4876,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1695);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1658);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4934,7 +4884,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1692);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1655);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4956,11 +4906,12 @@ PHP_METHOD(Tensor_Matrix, min)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1692);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1655);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5012,7 +4963,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1713);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1676);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -5020,7 +4971,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1710);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1673);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -5042,11 +4993,12 @@ PHP_METHOD(Tensor_Matrix, max)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1710);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1673);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5130,7 +5082,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_1, 2);
-	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 18, &_0, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 19, &_0, &_1);
 	zephir_check_call_status();
 	mid = zephir_get_intval(&_2);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
@@ -5146,7 +5098,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1752);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1715);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5170,7 +5122,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1749);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1712);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5208,11 +5160,12 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1749);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1712);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5288,13 +5241,13 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_DOUBLE(&_2$$3, q);
-		ZEPHIR_CALL_FUNCTION(&_3$$3, "strval", NULL, 4, &_2$$3);
+		ZEPHIR_CALL_FUNCTION(&_3$$3, "strval", NULL, 3, &_2$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1766);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1729);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5315,7 +5268,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1794);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1757);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5331,7 +5284,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1784);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1747);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5343,7 +5296,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1791);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1754);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5373,7 +5326,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1784);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1747);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5385,11 +5338,12 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1791);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1754);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "quick", NULL, 0, &b);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5458,9 +5412,9 @@ PHP_METHOD(Tensor_Matrix, variance)
 			zephir_gettype(&_1$$4, mean);
 			ZEPHIR_INIT_VAR(&_2$$4);
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
-			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_2$$4);
+			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1810);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1773);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5478,9 +5432,9 @@ PHP_METHOD(Tensor_Matrix, variance)
 			zephir_cast_to_string(&_9$$5, &_8$$5);
 			ZEPHIR_INIT_VAR(&_10$$5);
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
-			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 3, &_10$$5);
+			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 2, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1816);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1779);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5567,9 +5521,9 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			zephir_cast_to_string(&_6$$4, &_5$$4);
 			ZEPHIR_INIT_VAR(&_7$$4);
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
-			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 3, &_7$$4);
+			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 2, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1841);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1804);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5655,13 +5609,14 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		}
 	if (precision == 0) {
+		object_init_ex(return_value, tensor_matrix_ce);
 		ZEPHIR_INIT_VAR(&_0$$3);
 		zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 		ZVAL_LONG(&_2$$3, 0);
 		tensor_round(&_0$$3, &_1$$3, &_2$$3);
 		zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 		zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-		ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0$$3, &_3$$3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0$$3, &_3$$3, &_4$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
@@ -5669,13 +5624,13 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_INIT_VAR(&_5$$4);
 		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_6$$4, precision);
-		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", NULL, 4, &_6$$4);
+		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", NULL, 3, &_6$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_8$$4);
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less than 0, ", &_7$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_8$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1869);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1832);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5692,7 +5647,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_12 = &_10;
 	}
-	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1892);
+	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1855);
 	if (Z_TYPE_P(_12) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
 		{
@@ -5715,7 +5670,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1889);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1852);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
@@ -5752,7 +5707,7 @@ PHP_METHOD(Tensor_Matrix, round)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1889);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1852);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5792,12 +5747,13 @@ PHP_METHOD(Tensor_Matrix, floor)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_floor(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5833,12 +5789,13 @@ PHP_METHOD(Tensor_Matrix, ceil)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_ceil(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5896,12 +5853,13 @@ PHP_METHOD(Tensor_Matrix, clip)
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_1$$3);
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1928);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1891);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_2);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_4, min);
@@ -5909,7 +5867,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 	tensor_clip(&_2, &_3, &_4, &_5);
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_2, &_6, &_7);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_2, &_6, &_7);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5953,13 +5911,14 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &min_param);
 	min = zephir_get_doubleval(min_param);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, min);
 	tensor_clip_lower(&_0, &_1, &_2);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_3, &_4);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_3, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6003,13 +5962,14 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &max_param);
 	max = zephir_get_doubleval(max_param);
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, max);
 	tensor_clip_upper(&_0, &_1, &_2);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_3, &_4);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_3, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6045,12 +6005,13 @@ PHP_METHOD(Tensor_Matrix, sign)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_sign(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6086,12 +6047,13 @@ PHP_METHOD(Tensor_Matrix, negate)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	tensor_negate(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6168,9 +6130,9 @@ PHP_METHOD(Tensor_Matrix, augmentAbove)
 		zephir_cast_to_string(&_8$$3, &_7$$3);
 		ZEPHIR_INIT_VAR(&_9$$3);
 		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_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1994);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1957);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6182,13 +6144,14 @@ PHP_METHOD(Tensor_Matrix, augmentAbove)
 	zephir_array_fast_append(&_11, &_12);
 	ZEPHIR_CALL_METHOD(&buffer, &_10, "concat", NULL, 0, &_11);
 	zephir_check_call_status();
+	object_init_ex(return_value, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_13, b, "m", NULL, 0);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_14, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_INIT_VAR(&_15);
 	zephir_add_function(&_15, &_13, &_14);
 	zephir_read_property_cached(&_14, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &buffer, &_15, &_14);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &buffer, &_15, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6265,9 +6228,9 @@ PHP_METHOD(Tensor_Matrix, augmentBelow)
 		zephir_cast_to_string(&_8$$3, &_7$$3);
 		ZEPHIR_INIT_VAR(&_9$$3);
 		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_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2014);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1977);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6279,13 +6242,14 @@ PHP_METHOD(Tensor_Matrix, augmentBelow)
 	zephir_array_fast_append(&_11, &_12);
 	ZEPHIR_CALL_METHOD(&buffer, &_10, "concat", NULL, 0, &_11);
 	zephir_check_call_status();
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_14, b, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&_15);
 	zephir_add_function(&_15, &_13, &_14);
 	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &buffer, &_15, &_13);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &buffer, &_15, &_13);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6369,9 +6333,9 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 		zephir_cast_to_string(&_8$$3, &_7$$3);
 		ZEPHIR_INIT_VAR(&_9$$3);
 		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_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2034);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1997);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6414,7 +6378,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2048);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2011);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -6501,9 +6465,9 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 		zephir_cast_to_string(&_8$$3, &_7$$3);
 		ZEPHIR_INIT_VAR(&_9$$3);
 		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_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2066);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2029);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6546,7 +6510,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2080);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2043);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -6567,12 +6531,13 @@ PHP_METHOD(Tensor_Matrix, repeat)
 	zend_bool _9$$3;
 	zval bigRows;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *m_param = NULL, *n_param = NULL, rowA, _18, _0$$3, _1$$3, _2$$3, *_3$$3, _4$$3, *_5$$3, _8$$3, _6$$4, _7$$4, _10$$5, _11$$5, flat$$6, _12$$6, _13$$6, _14$$6, _15$$6, _16$$6, _17$$6;
+	zval *m_param = NULL, *n_param = NULL, rowA, _18, _19, _0$$3, _1$$3, _2$$3, *_3$$3, _4$$3, *_5$$3, _8$$3, _6$$4, _7$$4, _10$$5, _11$$5, flat$$6, _12$$6, _13$$6, _14$$6, _15$$6, _16$$6, _17$$6;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
@@ -6624,7 +6589,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2104);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2067);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -6633,7 +6598,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2102);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2065);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -6656,16 +6621,16 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2102);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2065);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2107);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2070);
 		ZVAL_LONG(&_13$$6, 1);
-		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 26, &bigRows, &_13$$6);
+		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 27, &bigRows, &_13$$6);
 		zephir_check_call_status();
 		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "concat", NULL, 0, &_14$$6);
 		zephir_check_call_status();
@@ -6674,17 +6639,19 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "repeat", NULL, 0, &_13$$6);
 		zephir_check_call_status();
 		ZEPHIR_CPY_WRT(&flat$$6, &_12$$6);
+		object_init_ex(return_value, tensor_matrix_ce);
 		zephir_read_property_cached(&_13$$6, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 		zephir_read_property_cached(&_15$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 		ZVAL_LONG(&_16$$6, (zephir_get_numberval(&_13$$6) * ((m + 1))));
 		ZVAL_LONG(&_17$$6, (zephir_get_numberval(&_15$$6) * ((n + 1))));
-		ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &flat$$6, &_16$$6, &_17$$6);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &flat$$6, &_16$$6, &_17$$6);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
 	ZEPHIR_INIT_VAR(&_18);
 	array_init(&_18);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &_18);
+	ZVAL_BOOL(&_19, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6747,9 +6714,9 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2130);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2093);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6757,9 +6724,10 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_multiply(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6822,9 +6790,9 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2149);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2112);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6832,9 +6800,10 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_divide(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6897,9 +6866,9 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2168);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2131);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6907,9 +6876,10 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_add(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6972,9 +6942,9 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2187);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2150);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6982,9 +6952,10 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_subtract(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7048,9 +7019,9 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2207);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2170);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7058,9 +7029,10 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_pow(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7124,9 +7096,9 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2227);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2190);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7134,9 +7106,10 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_mod(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7200,9 +7173,9 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2247);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2210);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7210,9 +7183,10 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_equal(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7275,9 +7249,9 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2266);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2229);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7285,9 +7259,10 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_not_equal(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7351,9 +7326,9 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2286);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2249);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7361,9 +7336,10 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7427,9 +7403,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2306);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2269);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7437,9 +7413,10 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater_equal(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7502,9 +7479,9 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2325);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2288);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7512,9 +7489,10 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7577,9 +7555,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2344);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2307);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7587,9 +7565,10 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, b, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less_equal(&result, &_6, &_7);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7662,9 +7641,9 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2364);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2327);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7697,7 +7676,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_multiply(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2374);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2337);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -7773,9 +7752,9 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2392);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2355);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7808,7 +7787,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_divide(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2402);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2365);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -7884,9 +7863,9 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2420);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2383);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7919,7 +7898,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_add(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2430);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2393);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -7995,9 +7974,9 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2448);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2411);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8030,7 +8009,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_subtract(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2458);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2421);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8106,9 +8085,9 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2476);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2439);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8141,7 +8120,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_pow(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2486);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2449);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8217,9 +8196,9 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2504);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2467);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8252,7 +8231,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_mod(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2514);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2477);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8329,9 +8308,9 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2533);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2496);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8364,7 +8343,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2543);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2506);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8440,9 +8419,9 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2561);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2524);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8475,7 +8454,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_not_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2571);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2534);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8551,9 +8530,9 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2589);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2552);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8586,7 +8565,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2599);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2562);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8662,9 +8641,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2617);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2580);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8697,7 +8676,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2627);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2590);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8773,9 +8752,9 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2645);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2608);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8808,7 +8787,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2655);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2618);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8885,9 +8864,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2674);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2637);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8920,7 +8899,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2684);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2647);
 		}
 	}
 	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
@@ -8991,9 +8970,9 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2702);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2665);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9003,9 +8982,10 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_multiply_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9073,9 +9053,9 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2725);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2688);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9085,9 +9065,10 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_divide_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9155,9 +9136,9 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2748);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2711);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9167,9 +9148,10 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_add_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9237,9 +9219,9 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2771);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2734);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9249,9 +9231,10 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_subtract_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9319,9 +9302,9 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2794);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2757);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9331,9 +9314,10 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_pow_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9401,9 +9385,9 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2817);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2780);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9413,9 +9397,10 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_mod_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9483,9 +9468,9 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2840);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2803);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9495,9 +9480,10 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_equal_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9565,9 +9551,9 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2863);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2826);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9577,9 +9563,10 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_not_equal_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9647,9 +9634,9 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2886);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2849);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9659,9 +9646,10 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_greater_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9729,9 +9717,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2909);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2872);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9741,9 +9729,10 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_greater_equal_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9811,9 +9800,9 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2932);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2895);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9823,9 +9812,10 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_less_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9893,9 +9883,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2955);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2918);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9905,9 +9895,10 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	tensor_less_equal_col(&result, &_8, &bHat, &_9);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9955,9 +9946,10 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_multiply_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10005,9 +9997,10 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_divide_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10055,9 +10048,10 @@ PHP_METHOD(Tensor_Matrix, addScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_add_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10105,9 +10099,10 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_subtract_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10155,9 +10150,10 @@ PHP_METHOD(Tensor_Matrix, powScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_pow_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10205,9 +10201,10 @@ PHP_METHOD(Tensor_Matrix, modScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_mod_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10255,9 +10252,10 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_equal_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10305,9 +10303,10 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_not_equal_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10355,9 +10354,10 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_greater_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10406,9 +10406,10 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_greater_equal_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10456,9 +10457,10 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_less_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10507,9 +10509,10 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_1, b);
 	tensor_less_equal_scalar(&result, &_0, &_1);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffer", NULL, 0, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10546,7 +10549,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3139);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3102);
 	return;
 }
 
@@ -10597,7 +10600,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3163);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3126);
 	return;
 }
 
@@ -10655,9 +10658,9 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		zephir_gettype(&_1$$3, index);
 		ZEPHIR_INIT_VAR(&_2$$3);
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_2$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3177);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3140);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10672,12 +10675,13 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		zephir_cast_to_string(&_6$$4, index);
 		ZEPHIR_INIT_VAR(&_7$$4);
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_7$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3182);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3145);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, tensor_vector_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_INIT_VAR(&_11);
@@ -10685,7 +10689,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_9, &_8, "slice", NULL, 0, &_11, &_10);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_vector_ce, "fromTensorBuffer", NULL, 0, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10709,7 +10713,7 @@ PHP_METHOD(Tensor_Matrix, getIterator)
 	object_init_ex(return_value, spl_ce_ArrayIterator);
 	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asVectors", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 20, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index 87c0902..7b340bd 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -3,9 +3,6 @@ extern zend_class_entry *tensor_matrix_ce;
 
 ZEPHIR_INIT_CLASS(Tensor_Matrix);
 
-PHP_METHOD(Tensor_Matrix, build);
-PHP_METHOD(Tensor_Matrix, quick);
-PHP_METHOD(Tensor_Matrix, fromTensorBuffer);
 PHP_METHOD(Tensor_Matrix, fromTensorBuffers);
 PHP_METHOD(Tensor_Matrix, fromArray);
 PHP_METHOD(Tensor_Matrix, identity);
@@ -164,20 +161,6 @@ PHP_METHOD(Tensor_Matrix, offsetUnset);
 PHP_METHOD(Tensor_Matrix, offsetGet);
 PHP_METHOD(Tensor_Matrix, getIterator);
 
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_build, 0, 0, Tensor\\Matrix, 0)
-ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, a, IS_ARRAY, 0, "[]")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_quick, 0, 0, Tensor\\Matrix, 0)
-ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, a, IS_ARRAY, 0, "[]")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromtensorbuffer, 0, 3, Tensor\\Matrix, 0)
-	ZEND_ARG_OBJ_INFO(0, a, Tensor\\TensorBuffer, 0)
-	ZEND_ARG_TYPE_INFO(0, m, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
-ZEND_END_ARG_INFO()
-
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromtensorbuffers, 0, 1, Tensor\\Matrix, 0)
 	ZEND_ARG_ARRAY_INFO(0, buffers, 0)
 ZEND_END_ARG_INFO()
@@ -766,9 +749,6 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_getiterator, 0, 0,
 ZEND_END_ARG_INFO()
 
 ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
-	PHP_ME(Tensor_Matrix, build, arginfo_tensor_matrix_build, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	PHP_ME(Tensor_Matrix, quick, arginfo_tensor_matrix_quick, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	PHP_ME(Tensor_Matrix, fromTensorBuffer, arginfo_tensor_matrix_fromtensorbuffer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, fromTensorBuffers, arginfo_tensor_matrix_fromtensorbuffers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, fromArray, arginfo_tensor_matrix_fromarray, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, identity, arginfo_tensor_matrix_identity, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index ea06283..e6edef0 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -101,19 +101,21 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	ZEPHIR_CPY_WRT(&_3, &result);
 	zephir_get_arrval(&_4, &_3);
 	ZEPHIR_CPY_WRT(&ref, &_4);
+	ZEPHIR_INIT_VAR(&b);
+	object_init_ex(&b, tensor_matrix_ce);
 	zephir_array_fetch_long(&_5, &ref, 0, PH_NOISY | PH_READONLY, "tensor/reductions/ref.zep", 51);
 	ZEPHIR_CALL_METHOD(&_6, a, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_7, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_CE_STATIC(&b, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_5, &_6, &_7);
+	ZEPHIR_CALL_METHOD(NULL, &b, "__construct", NULL, 15, &_5, &_6, &_7);
 	zephir_check_call_status();
 	zephir_memory_observe(&_8);
 	zephir_array_fetch_long(&_8, &ref, 1, PH_NOISY, "tensor/reductions/ref.zep", 52);
 	swaps = zephir_get_intval(&_8);
 	object_init_ex(return_value, tensor_reductions_ref_ce);
 	ZVAL_LONG(&_9, swaps);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -156,11 +158,11 @@ PHP_METHOD(Tensor_Reductions_Ref, __construct)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, swaps);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "The number of swaps must", " be greater than or equal to 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_0$$3, "tensor/reductions/ref.zep", 67);
 		ZEPHIR_MM_RESTORE();
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index 3753af8..d32375a 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -80,13 +80,15 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 		return;
 	}
 	object_init_ex(return_value, tensor_reductions_rref_ce);
+	ZEPHIR_INIT_VAR(&_3);
+	object_init_ex(&_3, tensor_matrix_ce);
 	ZEPHIR_CALL_METHOD(&_4, a, "m", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_5, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_CE_STATIC(&_3, tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_4, &_5);
+	ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 15, &result, &_4, &_5);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 33, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/settings.zep.c b/ext/tensor/settings.zep.c
index 6f5f309..d1b41db 100644
--- a/ext/tensor/settings.zep.c
+++ b/ext/tensor/settings.zep.c
@@ -65,11 +65,11 @@ PHP_METHOD(Tensor_Settings, setNumThreads)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, threads);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "The number of threads", " must be greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_0$$3, "tensor/settings.zep", 26);
 		ZEPHIR_MM_RESTORE();
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 22ed0a6..7896e5f 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -313,7 +313,7 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 		object_init_ex(&_4$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_SS(&_5$$3, "Offset and length", " must be within the bounds of the buffer.");
-		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 118);
 		ZEPHIR_MM_RESTORE();
@@ -606,7 +606,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 		object_init_ex(&_6$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SS(&_7$$3, "Offset, length, and", " stride must be within the bounds of the buffer.");
-		ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_6$$3, "tensor/tensorbuffer.zep", 225);
 		ZEPHIR_MM_RESTORE();
@@ -751,11 +751,11 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, chunkLength);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Chunk length must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 267);
 		ZEPHIR_MM_RESTORE();
@@ -852,11 +852,11 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, times);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Times must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 295);
 		ZEPHIR_MM_RESTORE();
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 1527c26..6065c29 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -13,8 +13,8 @@
 
 #include "kernel/main.h"
 #include "kernel/fcall.h"
-#include "kernel/memory.h"
 #include "kernel/operators.h"
+#include "kernel/memory.h"
 #include "kernel/object.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
@@ -60,103 +60,6 @@ ZEPHIR_INIT_CLASS(Tensor_Vector)
 	return SUCCESS;
 }
 
-/**
- * Factory method to build a new vector from an array.
- *
- * @param float[] a
- * @return self
- */
-PHP_METHOD(Tensor_Vector, build)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a_param = NULL, _0;
-	zval a;
-
-	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&_0);
-	ZEND_PARSE_PARAMETERS_START(0, 1)
-		Z_PARAM_OPTIONAL
-		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	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_vector_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 float[] a
- * @return self
- */
-PHP_METHOD(Tensor_Vector, quick)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a_param = NULL, _0;
-	zval a;
-
-	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&_0);
-	ZEND_PARSE_PARAMETERS_START(0, 1)
-		Z_PARAM_OPTIONAL
-		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	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_vector_ce);
-	ZVAL_BOOL(&_0, 0);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 1, &a, &_0);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
-/**
- * Build a vector from a TensorBuffer object.
- *
- * @param \Tensor\TensorBuffer a
- * @return self
- */
-PHP_METHOD(Tensor_Vector, fromTensorBuffer)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a, a_sub, _0;
-
-	ZVAL_UNDEF(&a_sub);
-	ZVAL_UNDEF(&_0);
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 0, &a);
-	object_init_ex(return_value, tensor_vector_ce);
-	ZVAL_BOOL(&_0, 0);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 1, a, &_0);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
 /**
  * Build a vector of zeros with n elements.
  *
@@ -255,7 +158,7 @@ PHP_METHOD(Tensor_Vector, fill)
 	_1 = !(Z_TYPE_P(&_0) == IS_LONG);
 	if (_1) {
 		ZVAL_DOUBLE(&_2, value);
-		ZEPHIR_CALL_FUNCTION(&_3, "is_float", NULL, 2, &_2);
+		ZEPHIR_CALL_FUNCTION(&_3, "is_float", NULL, 1, &_2);
 		zephir_check_call_status();
 		_1 = !zephir_is_true(&_3);
 	}
@@ -267,9 +170,9 @@ PHP_METHOD(Tensor_Vector, fill)
 		zephir_gettype(&_5$$3, &_6$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SSVS(&_7$$3, "Value must be an", " integer or floating point number, ", &_5$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/vector.zep", 103);
+		zephir_throw_exception_debug(&_4$$3, "tensor/vector.zep", 70);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -277,22 +180,23 @@ PHP_METHOD(Tensor_Vector, fill)
 		ZEPHIR_INIT_VAR(&_8$$4);
 		object_init_ex(&_8$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_9$$4, n);
-		ZEPHIR_CALL_FUNCTION(&_10$$4, "strval", NULL, 4, &_9$$4);
+		ZEPHIR_CALL_FUNCTION(&_10$$4, "strval", NULL, 3, &_9$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_11$$4);
 		ZEPHIR_CONCAT_SSVS(&_11$$4, "N must be", " greater than 0, ", &_10$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_8$$4, "__construct", NULL, 3, &_11$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_8$$4, "__construct", NULL, 2, &_11$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_8$$4, "tensor/vector.zep", 108);
+		zephir_throw_exception_debug(&_8$$4, "tensor/vector.zep", 75);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZVAL_LONG(&_2, 0);
 	ZVAL_LONG(&_12, n);
 	ZVAL_DOUBLE(&_13, value);
-	ZEPHIR_CALL_FUNCTION(&_14, "array_fill", NULL, 5, &_2, &_12, &_13);
+	ZEPHIR_CALL_FUNCTION(&_14, "array_fill", NULL, 4, &_2, &_12, &_13);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_14);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -330,13 +234,13 @@ PHP_METHOD(Tensor_Vector, rand)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, n);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 125);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 92);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -353,9 +257,10 @@ PHP_METHOD(Tensor_Vector, rand)
 		zephir_check_call_status();
 		ZEPHIR_INIT_NVAR(&_7$$4);
 		ZVAL_DOUBLE(&_7$$4, zephir_safe_div_zval_long(&_5$$4, max));
-		zephir_array_append(&a, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 133);
+		zephir_array_append(&a, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 100);
 	}
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &a);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -400,13 +305,13 @@ PHP_METHOD(Tensor_Vector, gaussian)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, n);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 151);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 118);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -432,11 +337,11 @@ PHP_METHOD(Tensor_Vector, gaussian)
 		ZVAL_DOUBLE(&_11$$4, phi);
 		ZEPHIR_INIT_NVAR(&_12$$4);
 		ZVAL_DOUBLE(&_12$$4, (r * sin(phi)));
-		zephir_array_append(&a, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 165);
+		zephir_array_append(&a, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 132);
 		ZVAL_DOUBLE(&_13$$4, phi);
 		ZEPHIR_INIT_NVAR(&_12$$4);
 		ZVAL_DOUBLE(&_12$$4, (r * cos(phi)));
-		zephir_array_append(&a, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 166);
+		zephir_array_append(&a, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 133);
 	}
 	if (zephir_fast_count_int(&a) > n) {
 		ZEPHIR_MAKE_REF(&a);
@@ -444,7 +349,8 @@ PHP_METHOD(Tensor_Vector, gaussian)
 		ZEPHIR_UNREF(&a);
 		zephir_check_call_status();
 	}
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &a);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -499,13 +405,13 @@ PHP_METHOD(Tensor_Vector, poisson)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, n);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", &_3, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 188);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 155);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -513,13 +419,13 @@ PHP_METHOD(Tensor_Vector, poisson)
 		ZEPHIR_INIT_VAR(&_5$$4);
 		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_DOUBLE(&_6$$4, lambda);
-		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 4, &_6$$4);
+		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", &_3, 3, &_6$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_8$$4);
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Lambda must be", " greater than or equal to 0, ", &_7$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 3, &_8$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/vector.zep", 193);
+		zephir_throw_exception_debug(&_5$$4, "tensor/vector.zep", 160);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -556,9 +462,10 @@ PHP_METHOD(Tensor_Vector, poisson)
 		}
 		ZEPHIR_INIT_NVAR(&_16$$6);
 		ZVAL_DOUBLE(&_16$$6, (k - 1.0));
-		zephir_array_append(&a, &_16$$6, PH_SEPARATE, "tensor/vector.zep", 218);
+		zephir_array_append(&a, &_16$$6, PH_SEPARATE, "tensor/vector.zep", 185);
 	}
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &a);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -598,13 +505,13 @@ PHP_METHOD(Tensor_Vector, uniform)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, n);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 235);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 202);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -623,9 +530,10 @@ PHP_METHOD(Tensor_Vector, uniform)
 		zephir_check_call_status();
 		ZEPHIR_INIT_NVAR(&_9$$4);
 		ZVAL_DOUBLE(&_9$$4, zephir_safe_div_zval_long(&_7$$4, max));
-		zephir_array_append(&a, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 243);
+		zephir_array_append(&a, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 210);
 	}
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &a);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -665,12 +573,13 @@ PHP_METHOD(Tensor_Vector, range)
 	} else {
 		interval = zephir_get_doubleval(interval_param);
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZVAL_DOUBLE(&_0, start);
 	ZVAL_DOUBLE(&_1, end);
 	ZVAL_DOUBLE(&_2, interval);
 	ZEPHIR_CALL_FUNCTION(&_3, "range", NULL, 11, &_0, &_1, &_2);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -714,20 +623,20 @@ PHP_METHOD(Tensor_Vector, linspace)
 	min = zephir_get_doubleval(min_param);
 	max = zephir_get_doubleval(max_param);
 	if (UNEXPECTED(min > max)) {
-		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_invalidargumentexception_ce, "Minimum must be less than maximum.", "tensor/vector.zep", 274);
+		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(tensor_exceptions_invalidargumentexception_ce, "Minimum must be less than maximum.", "tensor/vector.zep", 241);
 		return;
 	}
 	if (UNEXPECTED(n < 2)) {
 		ZEPHIR_INIT_VAR(&_0$$4);
 		object_init_ex(&_0$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$4, n);
-		ZEPHIR_CALL_FUNCTION(&_2$$4, "strval", NULL, 4, &_1$$4);
+		ZEPHIR_CALL_FUNCTION(&_2$$4, "strval", NULL, 3, &_1$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$4);
 		ZEPHIR_CONCAT_SSVS(&_3$$4, "Number of elements", " must be greater than 1, ", &_2$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_3$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_3$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$4, "tensor/vector.zep", 279);
+		zephir_throw_exception_debug(&_0$$4, "tensor/vector.zep", 246);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -751,27 +660,30 @@ PHP_METHOD(Tensor_Vector, linspace)
 		zephir_check_call_status();
 		ZEPHIR_INIT_NVAR(&_9$$5);
 		ZVAL_DOUBLE(&_9$$5, (zephir_get_numberval(&_7$$5) + interval));
-		zephir_array_append(&a, &_9$$5, PH_SEPARATE, "tensor/vector.zep", 289);
+		zephir_array_append(&a, &_9$$5, PH_SEPARATE, "tensor/vector.zep", 256);
 	}
 	ZEPHIR_INIT_NVAR(&_6);
 	ZVAL_DOUBLE(&_6, max);
-	zephir_array_append(&a, &_6, PH_SEPARATE, "tensor/vector.zep", 292);
-	ZEPHIR_RETURN_CALL_SELF("quick", NULL, 0, &a);
+	zephir_array_append(&a, &_6, PH_SEPARATE, "tensor/vector.zep", 259);
+	object_init_ex(return_value, tensor_vector_ce);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
 	zephir_check_call_status();
 	RETURN_MM();
 }
 
 /**
+ * Construct a new vector from a PHP array of elements or an existing
+ * TensorBuffer.
+ *
  * @param float[] a
- * @param bool validate
+ * @throws \Tensor\Exceptions\InvalidArgumentException
  */
 PHP_METHOD(Tensor_Vector, __construct)
 {
 	zval _1$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zend_bool validate;
-	zval *a = NULL, a_sub, *validate_param = NULL, buffer, _2, _3, _0$$4;
+	zval *a = NULL, a_sub, buffer, _2, _3, _0$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&a_sub);
@@ -789,19 +701,13 @@ PHP_METHOD(Tensor_Vector, __construct)
 		_zephir_prop_1 = zend_string_init("n", 1, 1);
 	}
 
-	ZEND_PARSE_PARAMETERS_START(1, 2)
+	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_ZVAL(a)
-		Z_PARAM_OPTIONAL
-		Z_PARAM_BOOL(validate)
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 1, &a, &validate_param);
+	zephir_fetch_params(1, 1, 0, &a);
 	ZEPHIR_SEPARATE_PARAM(a);
-	if (!validate_param) {
-		validate = 1;
-	} else {
-		}
 	if (Z_TYPE_P(a) == IS_ARRAY) {
 		ZEPHIR_INIT_VAR(&buffer);
 		tensor_buffer_from_array(&buffer, a);
@@ -814,9 +720,9 @@ PHP_METHOD(Tensor_Vector, __construct)
 		object_init_ex(&_0$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_1$$4);
 		ZEPHIR_CONCAT_SS(&_1$$4, "Vector requires", " an array or TensorBuffer object.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 3, &_1$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_1$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$4, "tensor/vector.zep", 311);
+		zephir_throw_exception_debug(&_0$$4, "tensor/vector.zep", 281);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -977,10 +883,11 @@ PHP_METHOD(Tensor_Vector, asRowMatrix)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_2, 1);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_0, &_2, &_1);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_1);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1011,10 +918,11 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_2, 1);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_1, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1071,9 +979,9 @@ PHP_METHOD(Tensor_Vector, reshape)
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_2$$3);
 		ZEPHIR_CONCAT_SS(&_2$$3, "The number of rows", " and/or columns cannot be less than 0.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_2$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 420);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 390);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1083,21 +991,22 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_INIT_VAR(&_4$$4);
 		object_init_ex(&_4$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_5$$4, nHat);
-		ZEPHIR_CALL_FUNCTION(&_6$$4, "strval", NULL, 4, &_5$$4);
+		ZEPHIR_CALL_FUNCTION(&_6$$4, "strval", NULL, 3, &_5$$4);
 		zephir_check_call_status();
 		zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 		ZEPHIR_INIT_VAR(&_7$$4);
 		ZEPHIR_CONCAT_VSSVS(&_7$$4, &_6$$4, " elements", " are needed but vector only has ", &_5$$4, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 3, &_7$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 427);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 397);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_9, m);
 	ZVAL_LONG(&_10, n);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &_8, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_8, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1122,8 +1031,9 @@ PHP_METHOD(Tensor_Vector, transpose)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, tensor_columnvector_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1158,12 +1068,13 @@ PHP_METHOD(Tensor_Vector, map)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &callback);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, callback, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 16, callback, &_1);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_STATIC("quick", NULL, 0, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1211,7 +1122,7 @@ PHP_METHOD(Tensor_Vector, reduce)
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_2, initial);
-	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 16, &_1, callback, &_2);
+	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 17, &_1, callback, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1271,9 +1182,9 @@ PHP_METHOD(Tensor_Vector, dot)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " elements but vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 482);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 452);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1341,9 +1252,9 @@ PHP_METHOD(Tensor_Vector, convolve)
 		object_init_ex(&_2$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SS(&_3$$3, "Vector B cannot be", " larger than Vector A.");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 500);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 470);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1351,22 +1262,23 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_INIT_VAR(&_4$$4);
 		object_init_ex(&_4$$4, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_5$$4, stride);
-		ZEPHIR_CALL_FUNCTION(&_6$$4, "strval", NULL, 4, &_5$$4);
+		ZEPHIR_CALL_FUNCTION(&_6$$4, "strval", NULL, 3, &_5$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_7$$4);
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Stride cannot be", " less than 1, ", &_6$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 3, &_7$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 505);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 475);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_11, stride);
 	tensor_convolve_1d(&_8, &_9, &_10, &_11);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1468,10 +1380,11 @@ PHP_METHOD(Tensor_Vector, outer)
 	ZEPHIR_CALL_METHOD(&_3, b, "n", NULL, 0);
 	zephir_check_call_status();
 	tensor_outer(&result, &_0, &_1, &_2, &_3);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_5, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffer", NULL, 0, &result, &_4, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_4, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1562,13 +1475,13 @@ PHP_METHOD(Tensor_Vector, pNorm)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_DOUBLE(&_1$$3, p);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "P must be greater", " than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 577);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 547);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1580,7 +1493,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 	ZEPHIR_CALL_METHOD(&_7, &_5, "sum", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_6, zephir_safe_div_double_double(1.0, p));
-	ZEPHIR_RETURN_CALL_FUNCTION("pow", NULL, 17, &_7, &_6);
+	ZEPHIR_RETURN_CALL_FUNCTION("pow", NULL, 18, &_7, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1668,9 +1581,9 @@ PHP_METHOD(Tensor_Vector, multiply)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " vector by the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 620);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 590);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1734,9 +1647,9 @@ PHP_METHOD(Tensor_Vector, divide)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " vector by the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 650);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 620);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1801,9 +1714,9 @@ PHP_METHOD(Tensor_Vector, add)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " vector by the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 681);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 651);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1868,9 +1781,9 @@ PHP_METHOD(Tensor_Vector, subtract)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " vector from the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 712);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 682);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1935,9 +1848,9 @@ PHP_METHOD(Tensor_Vector, pow)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " vector to the power of the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 743);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 713);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2002,9 +1915,9 @@ PHP_METHOD(Tensor_Vector, mod)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " vector with the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 774);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 744);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2069,9 +1982,9 @@ PHP_METHOD(Tensor_Vector, equal)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 805);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 775);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2136,9 +2049,9 @@ PHP_METHOD(Tensor_Vector, notEqual)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 836);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 806);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2203,9 +2116,9 @@ PHP_METHOD(Tensor_Vector, greater)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 867);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 837);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2270,9 +2183,9 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 898);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 868);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2337,9 +2250,9 @@ PHP_METHOD(Tensor_Vector, less)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 929);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 899);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2404,9 +2317,9 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 	object_init_ex(&_2, tensor_exceptions_invalidargumentexception_ce);
 	ZEPHIR_INIT_VAR(&_3);
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
-	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 3, &_3);
+	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 960);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 930);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2461,10 +2374,11 @@ PHP_METHOD(Tensor_Vector, abs)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_abs(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2508,10 +2422,11 @@ PHP_METHOD(Tensor_Vector, sqrt)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_sqrt(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2537,10 +2452,11 @@ PHP_METHOD(Tensor_Vector, exp)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_exp(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2566,10 +2482,11 @@ PHP_METHOD(Tensor_Vector, expm1)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_expm1(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2618,29 +2535,31 @@ PHP_METHOD(Tensor_Vector, log)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_DOUBLE(&_1$$3, base);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Log base must be greater", " than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1034);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1004);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	if (base == 2.7182818284590452354) {
+		object_init_ex(return_value, zend_get_called_scope(execute_data));
 		ZEPHIR_INIT_VAR(&_4$$4);
 		zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 		tensor_log(&_4$$4, &_5$$4);
-		ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_4$$4);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_4$$4);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_6);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_8, base);
 	tensor_log_base(&_6, &_7, &_8);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_6);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2666,10 +2585,11 @@ PHP_METHOD(Tensor_Vector, log1p)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_log1p(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2695,10 +2615,11 @@ PHP_METHOD(Tensor_Vector, sin)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_sin(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2724,10 +2645,11 @@ PHP_METHOD(Tensor_Vector, asin)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_asin(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2753,10 +2675,11 @@ PHP_METHOD(Tensor_Vector, cos)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_cos(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2782,10 +2705,11 @@ PHP_METHOD(Tensor_Vector, acos)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_acos(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2811,10 +2735,11 @@ PHP_METHOD(Tensor_Vector, tan)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_tan(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2840,10 +2765,11 @@ PHP_METHOD(Tensor_Vector, atan)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_atan(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2869,10 +2795,11 @@ PHP_METHOD(Tensor_Vector, rad2deg)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_rad2deg(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2898,10 +2825,11 @@ PHP_METHOD(Tensor_Vector, deg2rad)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_deg2rad(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3072,25 +3000,25 @@ PHP_METHOD(Tensor_Vector, median)
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_1, 2);
-	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 18, &_0, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 19, &_0, &_1);
 	zephir_check_call_status();
 	mid = zephir_get_intval(&_2);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&a, &_1, "toArray", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_MAKE_REF(&a);
-	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 19, &a);
+	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 20, &a);
 	ZEPHIR_UNREF(&a);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
 		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1200);
+		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1170);
 	} else {
 		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1202);
+		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1172);
 		zephir_memory_observe(&_5$$4);
-		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1202);
+		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1172);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
 		ZEPHIR_INIT_NVAR(&median);
@@ -3151,13 +3079,13 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_INIT_VAR(&_1$$3);
 		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_DOUBLE(&_2$$3, q);
-		ZEPHIR_CALL_FUNCTION(&_3$$3, "strval", NULL, 4, &_2$$3);
+		ZEPHIR_CALL_FUNCTION(&_3$$3, "strval", NULL, 3, &_2$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1219);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1189);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3165,7 +3093,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 	ZEPHIR_CALL_METHOD(&a, &_5, "toArray", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_MAKE_REF(&a);
-	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 19, &a);
+	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 20, &a);
 	ZEPHIR_UNREF(&a);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
@@ -3175,15 +3103,15 @@ PHP_METHOD(Tensor_Vector, quantile)
 	if (ZEPHIR_LE_LONG(&_7, xHat)) {
 		zephir_memory_observe(&_8$$4);
 		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1231);
+		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1201);
 		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
 	}
 	remainder =  ((x -  (double) xHat));
 	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1236);
+	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1206);
 	t =  (zephir_get_doubleval(&_10));
 	zephir_memory_observe(&_11);
-	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1238);
+	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1208);
 	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
 }
 
@@ -3231,7 +3159,7 @@ PHP_METHOD(Tensor_Vector, variance)
 		ZEPHIR_SEPARATE_PARAM(mean);
 	}
 	if (!(Z_TYPE_P(mean) == IS_NULL)) {
-		ZEPHIR_CALL_FUNCTION(&_0$$3, "is_float", NULL, 2, mean);
+		ZEPHIR_CALL_FUNCTION(&_0$$3, "is_float", NULL, 1, mean);
 		zephir_check_call_status();
 		if (UNEXPECTED(!zephir_is_true(&_0$$3))) {
 			ZEPHIR_INIT_VAR(&_1$$4);
@@ -3240,9 +3168,9 @@ PHP_METHOD(Tensor_Vector, variance)
 			zephir_gettype(&_2$$4, mean);
 			ZEPHIR_INIT_VAR(&_3$$4);
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
-			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 3, &_3$$4);
+			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 2, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1253);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1223);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3302,21 +3230,22 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_INIT_VAR(&_0$$3);
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZVAL_LONG(&_1$$3, precision);
-		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 4, &_1$$3);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
 		ZEPHIR_INIT_VAR(&_3$$3);
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1277);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1247);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_4);
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_6, precision);
 	tensor_round(&_4, &_5, &_6);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_4);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3342,10 +3271,11 @@ PHP_METHOD(Tensor_Vector, floor)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_floor(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3371,10 +3301,11 @@ PHP_METHOD(Tensor_Vector, ceil)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_ceil(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3422,18 +3353,19 @@ PHP_METHOD(Tensor_Vector, clip)
 		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
 		ZEPHIR_INIT_VAR(&_1$$3);
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 3, &_1$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1316);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1286);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_2);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_4, min);
 	ZVAL_DOUBLE(&_5, max);
 	tensor_clip(&_2, &_3, &_4, &_5);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3467,11 +3399,12 @@ PHP_METHOD(Tensor_Vector, clipLower)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &min_param);
 	min = zephir_get_doubleval(min_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, min);
 	tensor_clip_lower(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3505,11 +3438,12 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &max_param);
 	max = zephir_get_doubleval(max_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, max);
 	tensor_clip_upper(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3535,10 +3469,11 @@ PHP_METHOD(Tensor_Vector, sign)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_sign(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3564,10 +3499,11 @@ PHP_METHOD(Tensor_Vector, negate)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_negate(&_0, &_1);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3636,9 +3572,9 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1376);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1346);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3653,7 +3589,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1387);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1357);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3662,7 +3598,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1384);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1354);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3685,7 +3621,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1384);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1354);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3758,9 +3694,9 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1402);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1372);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3775,7 +3711,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1413);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1383);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3784,7 +3720,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1410);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1380);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3807,7 +3743,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1410);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1380);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3880,9 +3816,9 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1428);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1398);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3897,7 +3833,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1439);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1409);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3906,7 +3842,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1436);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1406);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3929,7 +3865,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1436);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1406);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4002,9 +3938,9 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1454);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1424);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4019,7 +3955,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1465);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1435);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4028,7 +3964,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1462);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1432);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4051,7 +3987,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1462);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1432);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4124,9 +4060,9 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1480);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1450);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4141,7 +4077,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1491);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1461);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4150,7 +4086,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1488);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1458);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4173,7 +4109,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1488);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1458);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4246,9 +4182,9 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1506);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1476);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4263,7 +4199,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1517);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1487);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4272,7 +4208,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1514);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1484);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4295,7 +4231,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1514);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1484);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4368,9 +4304,9 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1532);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1502);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4385,7 +4321,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1543);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1513);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4394,7 +4330,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1540);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1510);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4417,7 +4353,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1540);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1510);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4490,9 +4426,9 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1558);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1528);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4507,7 +4443,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1569);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1539);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4516,7 +4452,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1566);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1536);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4539,7 +4475,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1566);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1536);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4612,9 +4548,9 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1584);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1554);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4629,7 +4565,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1595);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1565);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4638,7 +4574,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1592);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1562);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4661,7 +4597,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1592);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1562);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4734,9 +4670,9 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1610);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1580);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4751,7 +4687,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1621);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1591);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4760,7 +4696,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1618);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1588);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4783,7 +4719,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1618);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1588);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4856,9 +4792,9 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1636);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1606);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4873,7 +4809,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1647);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1617);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4882,7 +4818,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1644);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1614);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4905,7 +4841,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1644);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1614);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4978,9 +4914,9 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1662);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1632);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4995,7 +4931,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1673);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1643);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5004,7 +4940,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1670);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1640);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5027,7 +4963,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1670);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1640);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5092,17 +5028,18 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1688);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1658);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_multiply(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5163,17 +5100,18 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1706);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1676);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_divide(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5234,17 +5172,18 @@ PHP_METHOD(Tensor_Vector, addVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1724);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1694);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_add(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5305,17 +5244,18 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1742);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1712);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_subtract(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5376,17 +5316,18 @@ PHP_METHOD(Tensor_Vector, powVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1760);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1730);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_pow(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5447,17 +5388,18 @@ PHP_METHOD(Tensor_Vector, modVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1778);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1748);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_mod(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5519,17 +5461,18 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1797);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1767);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_equal(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5590,17 +5533,18 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1815);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1785);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_not_equal(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5661,17 +5605,18 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1833);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1803);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5732,17 +5677,18 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1851);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1821);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater_equal(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5803,17 +5749,18 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1869);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1839);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5874,17 +5821,18 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		zephir_cast_to_string(&_6$$3, &_5$$3);
 		ZEPHIR_INIT_VAR(&_7$$3);
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 3, &_7$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1887);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1857);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_8);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less_equal(&_8, &_9, &_10);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5918,11 +5866,12 @@ PHP_METHOD(Tensor_Vector, multiplyScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_multiply_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5956,11 +5905,12 @@ PHP_METHOD(Tensor_Vector, divideScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_divide_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5994,11 +5944,12 @@ PHP_METHOD(Tensor_Vector, addScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_add_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6032,11 +5983,12 @@ PHP_METHOD(Tensor_Vector, subtractScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_subtract_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6070,11 +6022,12 @@ PHP_METHOD(Tensor_Vector, powScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_pow_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6108,11 +6061,12 @@ PHP_METHOD(Tensor_Vector, modScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_mod_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6146,11 +6100,12 @@ PHP_METHOD(Tensor_Vector, equalScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6184,11 +6139,12 @@ PHP_METHOD(Tensor_Vector, notEqualScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_not_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6222,11 +6178,12 @@ PHP_METHOD(Tensor_Vector, greaterScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_greater_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6261,11 +6218,12 @@ PHP_METHOD(Tensor_Vector, greaterEqualScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_greater_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6299,11 +6257,12 @@ PHP_METHOD(Tensor_Vector, lessScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_less_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6338,11 +6297,12 @@ PHP_METHOD(Tensor_Vector, lessEqualScalar)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b_param);
 	b = zephir_get_doubleval(b_param);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_less_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_RETURN_CALL_STATIC("fromTensorBuffer", NULL, 0, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6374,7 +6334,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2044);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2014);
 	return;
 }
 
@@ -6425,7 +6385,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2068);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2038);
 	return;
 }
 
@@ -6481,9 +6441,9 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		zephir_cast_to_string(&_4$$3, index);
 		ZEPHIR_INIT_VAR(&_5$$3);
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
-		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 3, &_5$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2082);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2052);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6518,7 +6478,7 @@ PHP_METHOD(Tensor_Vector, getIterator)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 20, &_1);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_1);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/vector.zep.h b/ext/tensor/vector.zep.h
index e51c653..42dc598 100644
--- a/ext/tensor/vector.zep.h
+++ b/ext/tensor/vector.zep.h
@@ -3,9 +3,6 @@ extern zend_class_entry *tensor_vector_ce;
 
 ZEPHIR_INIT_CLASS(Tensor_Vector);
 
-PHP_METHOD(Tensor_Vector, build);
-PHP_METHOD(Tensor_Vector, quick);
-PHP_METHOD(Tensor_Vector, fromTensorBuffer);
 PHP_METHOD(Tensor_Vector, zeros);
 PHP_METHOD(Tensor_Vector, ones);
 PHP_METHOD(Tensor_Vector, fill);
@@ -125,18 +122,6 @@ PHP_METHOD(Tensor_Vector, offsetUnset);
 PHP_METHOD(Tensor_Vector, offsetGet);
 PHP_METHOD(Tensor_Vector, getIterator);
 
-ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_vector_build, 0, 0, 0)
-ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, a, IS_ARRAY, 0, "[]")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_vector_quick, 0, 0, 0)
-ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, a, IS_ARRAY, 0, "[]")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_vector_fromtensorbuffer, 0, 0, 1)
-	ZEND_ARG_OBJ_INFO(0, a, Tensor\\TensorBuffer, 0)
-ZEND_END_ARG_INFO()
-
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_zeros, 0, 1, Tensor\\Vector, 0)
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
@@ -181,7 +166,6 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_vector___construct, 0, 0, 1)
 	ZEND_ARG_INFO(0, a)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_vector_shape, 0, 0, IS_ARRAY, 0)
@@ -584,9 +568,6 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_getiterator, 0, 0,
 ZEND_END_ARG_INFO()
 
 ZEPHIR_INIT_FUNCS(tensor_vector_method_entry) {
-	PHP_ME(Tensor_Vector, build, arginfo_tensor_vector_build, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	PHP_ME(Tensor_Vector, quick, arginfo_tensor_vector_quick, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	PHP_ME(Tensor_Vector, fromTensorBuffer, arginfo_tensor_vector_fromtensorbuffer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, zeros, arginfo_tensor_vector_zeros, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, ones, arginfo_tensor_vector_ones, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, fill, arginfo_tensor_vector_fill, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
diff --git a/tensor/columnvector.zep b/tensor/columnvector.zep
index d563a36..68f8c67 100644
--- a/tensor/columnvector.zep
+++ b/tensor/columnvector.zep
@@ -14,39 +14,6 @@ use Tensor\Exceptions\DimensionalityMismatch;
  */
 class ColumnVector extends Vector
 {
-    /**
-     * Factory method to build a new vector from an array.
-     *
-     * @param (int|float)[] a
-     * @return self
-     */
-    public static function build(const array a = [])
-    {
-        return new self(a, true);
-    }
- 
-    /**
-     * Build a vector foregoing any validation for quicker instantiation.
-     *
-     * @param (int|float)[] a
-     * @return self
-     */
-    public static function quick(const array a = [])
-    {
-        return new self(a, false);
-    }
-
-    /**
-     * Build a column vector from a TensorBuffer object.
-     *
-     * @param \Tensor\TensorBuffer a
-     * @return self
-     */
-    public static function fromTensorBuffer(<TensorBuffer> a)
-    {
-        return new self(a, false);
-    }
-
     /**
      * Return the number of rows in the vector.
      *
@@ -74,7 +41,7 @@ class ColumnVector extends Vector
      */
     public function transpose()
     {
-        return Vector::fromTensorBuffer(this->a);
+        return new Vector(this->a);
     }
 
     /**
@@ -108,7 +75,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_multiply_col(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -131,7 +98,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_divide_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -154,7 +121,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_add_col(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -177,7 +144,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_subtract_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -200,7 +167,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_pow_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
  
     /**
@@ -223,7 +190,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_mod_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -246,7 +213,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_equal_col(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -269,7 +236,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_not_equal_col(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -292,7 +259,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_greater_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -315,7 +282,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_greater_equal_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -338,7 +305,7 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_less_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -361,6 +328,6 @@ class ColumnVector extends Vector
         let bHat = b->asTensorBuffer();
         let result = tensor_less_equal_col_reverse(bHat, this->a, b->n());
 
-        return Matrix::fromTensorBuffer(result, b->m(), b->n());
+        return new Matrix(result, b->m(), b->n());
     }
 }
\ No newline at end of file
diff --git a/tensor/decompositions/cholesky.zep b/tensor/decompositions/cholesky.zep
index f4c2b93..28f1048 100644
--- a/tensor/decompositions/cholesky.zep
+++ b/tensor/decompositions/cholesky.zep
@@ -43,7 +43,7 @@ class Cholesky
             throw new RuntimeException("Failed to decompose matrix.");
         }
 
-        return new self(Matrix::fromTensorBuffer(l, a->n(), a->n()));
+        return new self(new Matrix(l, a->n(), a->n()));
     }
 
     /**
diff --git a/tensor/decompositions/eigen.zep b/tensor/decompositions/eigen.zep
index 4377235..eb1794d 100644
--- a/tensor/decompositions/eigen.zep
+++ b/tensor/decompositions/eigen.zep
@@ -65,7 +65,7 @@ class Eigen
         let eig = (array) result;
 
         var eigenvalues = (array) eig[0];
-        var eigenvectors = Matrix::fromTensorBuffer(eig[1], a->n(), a->n())->transpose();
+        var eigenvectors = new Matrix(eig[1], a->n(), a->n())->transpose();
 
         return new self(eigenvalues, eigenvectors);
     }
diff --git a/tensor/decompositions/lu.zep b/tensor/decompositions/lu.zep
index 91e888e..f253c38 100644
--- a/tensor/decompositions/lu.zep
+++ b/tensor/decompositions/lu.zep
@@ -62,9 +62,9 @@ class Lu
 
         let lup = (array) result;
 
-        var l = Matrix::fromTensorBuffer(lup[0], a->n(), a->n());
-        var u = Matrix::fromTensorBuffer(lup[1], a->n(), a->n());
-        var p = Matrix::fromTensorBuffer(lup[2], a->n(), a->n());
+        var l = new Matrix(lup[0], a->n(), a->n());
+        var u = new Matrix(lup[1], a->n(), a->n());
+        var p = new Matrix(lup[2], a->n(), a->n());
 
         return new self(l, u, p);
     }
diff --git a/tensor/decompositions/svd.zep b/tensor/decompositions/svd.zep
index 21fdffb..97bf5a7 100644
--- a/tensor/decompositions/svd.zep
+++ b/tensor/decompositions/svd.zep
@@ -52,9 +52,9 @@ class Svd
 
         let usvT = (array) result;
 
-        var u = Matrix::fromTensorBuffer(usvT[0], a->m(), a->m());
+        var u = new Matrix(usvT[0], a->m(), a->m());
         var singularValues = (array) usvT[1];
-        var vT = Matrix::fromTensorBuffer(usvT[2], a->n(), a->n());
+        var vT = new Matrix(usvT[2], a->n(), a->n());
 
         return new self(u, singularValues, vT);
     }
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 8041ca7..582b66b 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -43,43 +43,6 @@ class Matrix implements Tensor
      */
     protected n;
 
-    /**
-     * Build a new matrix from a PHP array of arrays, validating the input.
-     *
-     * @param array[] a
-     * @throws \Tensor\Exceptions\InvalidArgumentException
-     * @return self
-     */
-    public static function build(const array a = []) -> <Matrix>
-    {
-        return self::fromArray(a, true);
-    }
-
-    /**
-     * Build a new matrix from a PHP array of arrays, foregoing any row
-     * validation for quicker instantiation.
-     *
-     * @param array[] a
-     * @return self
-     */
-    public static function quick(const array a = []) -> <Matrix>
-    {
-        return self::fromArray(a, false);
-    }
-
-    /**
-     * Build a matrix from a TensorBuffer object.
-     *
-     * @param \Tensor\TensorBuffer a
-     * @param int m
-     * @param int n
-     * @return self
-     */
-    public static function fromTensorBuffer(<TensorBuffer> a, const int m, const int n) -> <Matrix>
-    {
-        return new self(a, m, n);
-    }
-
     /**
      * Build a matrix by concatenating an array of TensorBuffers (each buffer
      * representing one row) into a single contiguous buffer.
@@ -196,7 +159,7 @@ class Matrix implements Tensor
             let a[] = rowA;
         }
  
-        return self::quick(a);
+        return self::fromArray(a, false);
     }
  
     /**
@@ -253,7 +216,7 @@ class Matrix implements Tensor
             let a[] = rowA;
         }
  
-        return self::quick(a);
+        return self::fromArray(a, false);
     }
  
     /**
@@ -277,7 +240,7 @@ class Matrix implements Tensor
                 . " greater than 0, " . strval(n) . " given.");
         }
  
-        return self::quick(array_fill(0, m, array_fill(0, n, value)));
+        return self::fromArray(array_fill(0, m, array_fill(0, n, value)), false);
     }
  
      /**
@@ -315,7 +278,7 @@ class Matrix implements Tensor
             let a[] = rowA;
         }
  
-        return self::quick(a);
+        return self::fromArray(a, false);
     }
  
     /**
@@ -369,7 +332,7 @@ class Matrix implements Tensor
             let a[] = rowA;
         }
  
-        return self::quick(a);
+        return self::fromArray(a, false);
     }
 
     /**
@@ -430,7 +393,7 @@ class Matrix implements Tensor
             let a[] = rowA;
         }
 
-        return self::quick(a);
+        return self::fromArray(a, false);
     }
 
     /**
@@ -468,7 +431,7 @@ class Matrix implements Tensor
             let a[] = rowA;
         }
     
-        return self::quick(a);
+        return self::fromArray(a, false);
     }
 
     /**
@@ -560,7 +523,7 @@ class Matrix implements Tensor
                 . " bounds.");
         }
 
-        return Vector::fromTensorBuffer(this->a->slice(index * this->n, this->n));
+        return new Vector(this->a->slice(index * this->n, this->n));
     }
 
     /**
@@ -577,7 +540,7 @@ class Matrix implements Tensor
                 . " bounds.");
         }
 
-        return ColumnVector::fromTensorBuffer(this->a->sliceStrided(index, this->m, this->n));
+        return new ColumnVector(this->a->sliceStrided(index, this->m, this->n));
     }
 
     /**
@@ -593,7 +556,7 @@ class Matrix implements Tensor
                 . " square, " . this->shapeString() . " given.");
         }
 
-        return Vector::fromTensorBuffer(this->a->sliceStrided(0, this->m, this->n + 1));
+        return new Vector(this->a->sliceStrided(0, this->m, this->n + 1));
     }
 
     /**
@@ -603,7 +566,7 @@ class Matrix implements Tensor
      */
     public function asVector() -> <Vector>
     {
-        return Vector::fromTensorBuffer(this->a);
+        return new Vector(this->a);
     }
 
     /**
@@ -668,7 +631,7 @@ class Matrix implements Tensor
         }
 
         for rowBuffer in this->a->split(this->n) {
-            let b[] = Vector::fromTensorBuffer(rowBuffer);
+            let b[] = new Vector(rowBuffer);
         }
 
         return b;
@@ -712,7 +675,7 @@ class Matrix implements Tensor
         }
 
         for columnBuffer in this->asColumnBuffers() {
-            let b[] = ColumnVector::fromTensorBuffer(columnBuffer);
+            let b[] = new ColumnVector(columnBuffer);
         }
 
         return b;
@@ -735,7 +698,7 @@ class Matrix implements Tensor
      */
     public function flatten() -> <Vector>
     {
-        return Vector::fromTensorBuffer(this->a);
+        return new Vector(this->a);
     }
 
     /**
@@ -748,7 +711,7 @@ class Matrix implements Tensor
      */
     public function map(const var callback) -> <Matrix>
     {
-        return self::fromTensorBuffer(this->a->map(callback), this->m, this->n);
+        return new self(this->a->map(callback), this->m, this->n);
     }
 
     /**
@@ -777,14 +740,14 @@ class Matrix implements Tensor
         var cols = this->asColumnBuffers();
 
         if unlikely count(cols) < 1 {
-            return self::quick();
+            return self::fromArray([], false);
         }
 
         let col = cols[0];
 
         let col = col->concat(array_slice(cols, 1));
 
-        return self::fromTensorBuffer(col, this->n, this->m);
+        return new self(col, this->n, this->m);
     }
 
     /**
@@ -812,7 +775,7 @@ class Matrix implements Tensor
                 . " of a singular matrix.");
         }
 
-        return self::fromTensorBuffer(result, this->n, this->n);
+        return new self(result, this->n, this->n);
     }
 
     /**
@@ -829,7 +792,7 @@ class Matrix implements Tensor
                 . " of the matrix.");
         }
 
-        return self::fromTensorBuffer(result, this->n, this->m);
+        return new self(result, this->n, this->m);
     }
 
     /**
@@ -915,7 +878,7 @@ class Matrix implements Tensor
          
         var result = tensor_matmul(this->a, b->a, this->m, this->n, b->n());
 
-        return self::fromTensorBuffer(result, this->m, b->n());
+        return new self(result, this->m, b->n());
     }
 
     /**
@@ -961,7 +924,7 @@ class Matrix implements Tensor
         int outM = (int) intdiv(this->m + stride - 1, stride);
         int outN = (int) intdiv(this->n + stride - 1, stride);
 
-        return self::fromTensorBuffer(result, outM, outN);
+        return new self(result, outM, outN);
     }
 
     /**
@@ -1491,7 +1454,7 @@ class Matrix implements Tensor
      */
     public function abs() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_abs(this->a), this->m, this->n);
+        return new self(tensor_abs(this->a), this->m, this->n);
     }
 
     /**
@@ -1511,7 +1474,7 @@ class Matrix implements Tensor
      */
     public function sqrt() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_sqrt(this->a), this->m, this->n);
+        return new self(tensor_sqrt(this->a), this->m, this->n);
     }
 
     /**
@@ -1521,7 +1484,7 @@ class Matrix implements Tensor
      */
     public function exp() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_exp(this->a), this->m, this->n);
+        return new self(tensor_exp(this->a), this->m, this->n);
     }
 
     /**
@@ -1531,7 +1494,7 @@ class Matrix implements Tensor
     */
     public function expm1() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_expm1(this->a), this->m, this->n);
+        return new self(tensor_expm1(this->a), this->m, this->n);
     }
 
     /**
@@ -1543,10 +1506,10 @@ class Matrix implements Tensor
     public function log(const float base = self::M_E) -> <Matrix>
     {
         if base === self::M_E {
-            return self::fromTensorBuffer(tensor_log(this->a), this->m, this->n);
+            return new self(tensor_log(this->a), this->m, this->n);
         }
 
-        return self::fromTensorBuffer(
+        return new self(
             tensor_log_base(this->a, (double) base), this->m, this->n
         );
     }
@@ -1558,7 +1521,7 @@ class Matrix implements Tensor
     */
     public function log1p() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_log1p(this->a), this->m, this->n);
+        return new self(tensor_log1p(this->a), this->m, this->n);
     }
  
     /**
@@ -1568,7 +1531,7 @@ class Matrix implements Tensor
      */
     public function sin() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_sin(this->a), this->m, this->n);
+        return new self(tensor_sin(this->a), this->m, this->n);
     }
 
     /**
@@ -1578,7 +1541,7 @@ class Matrix implements Tensor
      */
     public function asin() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_asin(this->a), this->m, this->n);
+        return new self(tensor_asin(this->a), this->m, this->n);
     }
  
     /**
@@ -1588,7 +1551,7 @@ class Matrix implements Tensor
      */
     public function cos() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_cos(this->a), this->m, this->n);
+        return new self(tensor_cos(this->a), this->m, this->n);
     }
 
     /**
@@ -1598,7 +1561,7 @@ class Matrix implements Tensor
      */
     public function acos() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_acos(this->a), this->m, this->n);
+        return new self(tensor_acos(this->a), this->m, this->n);
     }
  
     /**
@@ -1608,7 +1571,7 @@ class Matrix implements Tensor
      */
     public function tan() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_tan(this->a), this->m, this->n);
+        return new self(tensor_tan(this->a), this->m, this->n);
     }
 
     /**
@@ -1618,7 +1581,7 @@ class Matrix implements Tensor
      */
     public function atan() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_atan(this->a), this->m, this->n);
+        return new self(tensor_atan(this->a), this->m, this->n);
     }
  
     /**
@@ -1628,7 +1591,7 @@ class Matrix implements Tensor
      */
     public function rad2deg() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_rad2deg(this->a), this->m, this->n);
+        return new self(tensor_rad2deg(this->a), this->m, this->n);
     }
  
     /**
@@ -1638,7 +1601,7 @@ class Matrix implements Tensor
      */
     public function deg2rad() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_deg2rad(this->a), this->m, this->n);
+        return new self(tensor_deg2rad(this->a), this->m, this->n);
     }
 
     /**
@@ -1656,7 +1619,7 @@ class Matrix implements Tensor
             let b[] = rowBuffer->sum();
         }
 
-        return ColumnVector::quick(b);
+        return new ColumnVector(b);
     }
 
     /**
@@ -1674,7 +1637,7 @@ class Matrix implements Tensor
             let b[] = rowBuffer->product();
         }
 
-        return ColumnVector::quick(b);
+        return new ColumnVector(b);
     }
 
     /**
@@ -1692,7 +1655,7 @@ class Matrix implements Tensor
             let b[] = rowBuffer->min();
         }
 
-        return ColumnVector::quick(b);
+        return new ColumnVector(b);
     }
 
     /**
@@ -1710,7 +1673,7 @@ class Matrix implements Tensor
             let b[] = rowBuffer->max();
         }
 
-        return ColumnVector::quick(b);
+        return new ColumnVector(b);
     }
 
     /**
@@ -1749,7 +1712,7 @@ class Matrix implements Tensor
             let b[] = median;
         }
 
-        return ColumnVector::quick(b);
+        return new ColumnVector(b);
     }
 
     /**
@@ -1791,7 +1754,7 @@ class Matrix implements Tensor
             let b[] = t + remainder * (rowBuffer->get(xHat) - t);
         }
 
-        return ColumnVector::quick(b);
+        return new ColumnVector(b);
     }
 
     /**
@@ -1859,7 +1822,7 @@ class Matrix implements Tensor
     public function round(const int precision = 0) -> <Matrix>
     {
         if precision === 0 {
-            return self::fromTensorBuffer(
+            return new self(
                 tensor_round(this->a, 0), this->m, this->n
             );
         }
@@ -1899,7 +1862,7 @@ class Matrix implements Tensor
      */
     public function floor() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_floor(this->a), this->m, this->n);
+        return new self(tensor_floor(this->a), this->m, this->n);
     }
 
     /**
@@ -1909,7 +1872,7 @@ class Matrix implements Tensor
      */
     public function ceil() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_ceil(this->a), this->m, this->n);
+        return new self(tensor_ceil(this->a), this->m, this->n);
     }
 
     /**
@@ -1928,7 +1891,7 @@ class Matrix implements Tensor
                 . " greater than maximum.");
         }
 
-        return self::fromTensorBuffer(
+        return new self(
             tensor_clip(this->a, (double) min, (double) max), this->m, this->n
         );
     }
@@ -1941,7 +1904,7 @@ class Matrix implements Tensor
      */
     public function clipLower(const float min) -> <Matrix>
     {
-        return self::fromTensorBuffer(
+        return new self(
             tensor_clip_lower(this->a, (double) min), this->m, this->n
         );
     }
@@ -1954,7 +1917,7 @@ class Matrix implements Tensor
      */
     public function clipUpper(const float max) -> <Matrix>
     {
-        return self::fromTensorBuffer(
+        return new self(
             tensor_clip_upper(this->a, (double) max), this->m, this->n
         );
     }
@@ -1966,7 +1929,7 @@ class Matrix implements Tensor
      */
     public function sign() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_sign(this->a), this->m, this->n);
+        return new self(tensor_sign(this->a), this->m, this->n);
     }
 
     /**
@@ -1976,7 +1939,7 @@ class Matrix implements Tensor
      */
     public function negate() -> <Matrix>
     {
-        return self::fromTensorBuffer(tensor_negate(this->a), this->m, this->n);
+        return new self(tensor_negate(this->a), this->m, this->n);
     }
 
     /**
@@ -1996,7 +1959,7 @@ class Matrix implements Tensor
 
         var buffer = b->a->concat([this->a]);
 
-        return self::fromTensorBuffer(buffer, b->m() + this->m, this->n);
+        return new self(buffer, b->m() + this->m, this->n);
     }
 
     /**
@@ -2016,7 +1979,7 @@ class Matrix implements Tensor
 
         var buffer = this->a->concat([b->a]);
 
-        return self::fromTensorBuffer(buffer, this->m + b->m(), this->n);
+        return new self(buffer, this->m + b->m(), this->n);
     }
 
     /**
@@ -2110,10 +2073,10 @@ class Matrix implements Tensor
 
             let flat = flat->repeat(m + 1);
 
-            return self::fromTensorBuffer(flat, this->m * (m + 1), this->n * (n + 1));
+            return new self(flat, this->m * (m + 1), this->n * (n + 1));
         }
 
-        return self::quick([]);
+        return self::fromArray([], false);
     }
 
     /**
@@ -2132,7 +2095,7 @@ class Matrix implements Tensor
 
         var result = tensor_multiply(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2151,7 +2114,7 @@ class Matrix implements Tensor
 
         var result = tensor_divide(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2170,7 +2133,7 @@ class Matrix implements Tensor
 
         var result = tensor_add(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2189,7 +2152,7 @@ class Matrix implements Tensor
 
         var result = tensor_subtract(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2209,7 +2172,7 @@ class Matrix implements Tensor
 
         var result = tensor_pow(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2229,7 +2192,7 @@ class Matrix implements Tensor
 
         var result = tensor_mod(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2249,7 +2212,7 @@ class Matrix implements Tensor
 
         var result = tensor_equal(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2268,7 +2231,7 @@ class Matrix implements Tensor
 
         var result = tensor_not_equal(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2288,7 +2251,7 @@ class Matrix implements Tensor
 
         var result = tensor_greater(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2308,7 +2271,7 @@ class Matrix implements Tensor
 
         var result = tensor_greater_equal(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2327,7 +2290,7 @@ class Matrix implements Tensor
 
         var result = tensor_less(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2346,7 +2309,7 @@ class Matrix implements Tensor
 
         var result = tensor_less_equal(this->a, b->a);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2707,7 +2670,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_multiply_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2730,7 +2693,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_divide_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2753,7 +2716,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_add_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2776,7 +2739,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_subtract_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2799,7 +2762,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_pow_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2822,7 +2785,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_mod_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2845,7 +2808,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_equal_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2868,7 +2831,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_not_equal_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2891,7 +2854,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_greater_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2914,7 +2877,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_greater_equal_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2937,7 +2900,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_less_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2960,7 +2923,7 @@ class Matrix implements Tensor
         let bHat = b->asTensorBuffer();
         let result = tensor_less_equal_col(this->a, bHat, this->n);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2973,7 +2936,7 @@ class Matrix implements Tensor
     {
         var result = tensor_multiply_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2986,7 +2949,7 @@ class Matrix implements Tensor
     {
         var result = tensor_divide_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2999,7 +2962,7 @@ class Matrix implements Tensor
     {
         var result = tensor_add_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3012,7 +2975,7 @@ class Matrix implements Tensor
     {
         var result = tensor_subtract_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3025,7 +2988,7 @@ class Matrix implements Tensor
     {
         var result = tensor_pow_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3038,7 +3001,7 @@ class Matrix implements Tensor
     {
         var result = tensor_mod_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3051,7 +3014,7 @@ class Matrix implements Tensor
     {
         var result = tensor_equal_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3064,7 +3027,7 @@ class Matrix implements Tensor
     {
         var result = tensor_not_equal_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3077,7 +3040,7 @@ class Matrix implements Tensor
     {
         var result = tensor_greater_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3091,7 +3054,7 @@ class Matrix implements Tensor
     {
         var result = tensor_greater_equal_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3104,7 +3067,7 @@ class Matrix implements Tensor
     {
         var result = tensor_less_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3118,7 +3081,7 @@ class Matrix implements Tensor
     {
         var result = tensor_less_equal_scalar(this->a, b);
 
-        return self::fromTensorBuffer(result, this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -3182,7 +3145,7 @@ class Matrix implements Tensor
                 . " bounds, " . (string) index . " given.");
         }
 
-        return Vector::fromTensorBuffer(this->a->slice(index * this->n, this->n));
+        return new Vector(this->a->slice(index * this->n, this->n));
     }
 
     /**
diff --git a/tensor/reductions/ref.zep b/tensor/reductions/ref.zep
index 9ea6c68..b30cbed 100644
--- a/tensor/reductions/ref.zep
+++ b/tensor/reductions/ref.zep
@@ -48,7 +48,7 @@ class Ref
 
         let ref = (array) result;
 
-        var b = Matrix::fromTensorBuffer(ref[0], a->m(), a->n());
+        var b = new Matrix(ref[0], a->m(), a->n());
         var swaps = (int) ref[1];
 
         return new self(b, swaps);
diff --git a/tensor/reductions/rref.zep b/tensor/reductions/rref.zep
index 91636b1..a908747 100644
--- a/tensor/reductions/rref.zep
+++ b/tensor/reductions/rref.zep
@@ -36,7 +36,7 @@ class Rref
             throw new RuntimeException("Failed to reduce matrix.");
         }
 
-        return new self(Matrix::fromTensorBuffer(result, a->m(), a->n()));
+        return new self(new Matrix(result, a->m(), a->n()));
     }
 
     /**
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 2084317..889d9cd 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -28,40 +28,7 @@ class Vector implements Tensor
      *
      * @var int
      */
-    protected n;
-
-    /**
-     * Factory method to build a new vector from an array.
-     *
-     * @param float[] a
-     * @return self
-     */
-    public static function build(const array a = [])
-    {
-        return new self(a, true);
-    }
-
-    /**
-     * Build a vector foregoing any validation for quicker instantiation.
-     *
-     * @param float[] a
-     * @return self
-     */
-    public static function quick(const array a = [])
-    {
-        return new self(a, false);
-    }
-
-    /**
-     * Build a vector from a TensorBuffer object.
-     *
-     * @param \Tensor\TensorBuffer a
-     * @return self
-     */
-    public static function fromTensorBuffer(<TensorBuffer> a)
-    {
-        return new self(a, false);
-    }
+        protected n;
 
     /**
      * Build a vector of zeros with n elements.
@@ -108,7 +75,7 @@ class Vector implements Tensor
                 . " greater than 0, " . strval(n) . " given.");
         }
 
-        return static::quick(array_fill(0, n, value));
+        return new static(array_fill(0, n, value));
     }
 
     /**
@@ -133,7 +100,7 @@ class Vector implements Tensor
             let a[] = rand() / max;
         }
 
-        return static::quick(a);
+        return new static(a);
     }
 
     /**
@@ -170,7 +137,7 @@ class Vector implements Tensor
             array_pop(a);
         }
 
-        return static::quick(a);
+        return new static(a);
     }
 
     /**
@@ -218,7 +185,7 @@ class Vector implements Tensor
             let a[] = k - 1.0;
         }
 
-        return static::quick(a);
+        return new static(a);
     }
 
     /**
@@ -243,7 +210,7 @@ class Vector implements Tensor
             let a[] = rand(-max, max) / max;
         }
 
-        return static::quick(a);
+        return new static(a);
     }
 
     /**
@@ -256,7 +223,7 @@ class Vector implements Tensor
      */
     public static function range(const float start, const float end, const float interval = 1.0) -> <Vector>
     {
-        return static::quick(range(start, end, interval));
+        return new static(range(start, end, interval));
     }
 
     /**
@@ -291,14 +258,17 @@ class Vector implements Tensor
 
         let a[] = max;
 
-        return self::quick(a);
+        return new self(a);
     }
 
     /**
+     * Construct a new vector from a PHP array of elements or an existing
+     * TensorBuffer.
+     *
      * @param float[] a
-     * @param bool validate
+     * @throws \Tensor\Exceptions\InvalidArgumentException
      */
-    public function __construct(var a, const bool validate = true)
+    public function __construct(var a)
     {
         var buffer;
 
@@ -392,7 +362,7 @@ class Vector implements Tensor
      */
     public function asRowMatrix() -> <Matrix>
     {
-        return Matrix::fromTensorBuffer(this->a, 1, this->n);
+        return new Matrix(this->a, 1, this->n);
     }
 
     /**
@@ -402,7 +372,7 @@ class Vector implements Tensor
      */
     public function asColumnMatrix() -> <Matrix>
     {
-        return Matrix::fromTensorBuffer(this->a, this->n, 1);
+        return new Matrix(this->a, this->n, 1);
     }
 
     /**
@@ -427,7 +397,7 @@ class Vector implements Tensor
                 . " are needed but vector only has " . this->n . ".");
         }
 
-        return Matrix::fromTensorBuffer(this->a, m, n);
+        return new Matrix(this->a, m, n);
     }
 
     /**
@@ -437,7 +407,7 @@ class Vector implements Tensor
      */
     public function transpose()
     {
-        return ColumnVector::fromTensorBuffer(this->a);
+        return new ColumnVector(this->a);
     }
 
     /**
@@ -450,7 +420,7 @@ class Vector implements Tensor
      */
     public function map(const var callback) -> <Vector>
     {
-        return static::quick(array_map(callback, this->a->toArray()));
+        return new static(array_map(callback, this->a->toArray()));
     }
 
     /**
@@ -505,7 +475,7 @@ class Vector implements Tensor
                 . " less than 1, " . strval(stride). " given.");
         }
 
-        return static::fromTensorBuffer(tensor_convolve_1d(this->a, b->a, stride));
+        return new static(tensor_convolve_1d(this->a, b->a, stride));
     }
 
     /**
@@ -540,7 +510,7 @@ class Vector implements Tensor
     {
         var result = tensor_outer(this->a, b->asTensorBuffer(), this->n, b->n());
 
-        return Matrix::fromTensorBuffer(result, this->n, b->n());
+        return new Matrix(result, this->n, b->n());
     }
 
     /**
@@ -978,7 +948,7 @@ class Vector implements Tensor
      */
     public function abs() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_abs(this->a));
+        return new static(tensor_abs(this->a));
     }
 
     /**
@@ -998,7 +968,7 @@ class Vector implements Tensor
      */
     public function sqrt() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_sqrt(this->a));
+        return new static(tensor_sqrt(this->a));
     }
 
     /**
@@ -1008,7 +978,7 @@ class Vector implements Tensor
      */
     public function exp() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_exp(this->a));
+        return new static(tensor_exp(this->a));
     }
 
     /**
@@ -1018,7 +988,7 @@ class Vector implements Tensor
     */
     public function expm1() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_expm1(this->a));
+        return new static(tensor_expm1(this->a));
     }
 
     /**
@@ -1035,10 +1005,10 @@ class Vector implements Tensor
         }
 
         if base === self::M_E {
-            return static::fromTensorBuffer(tensor_log(this->a));
+            return new static(tensor_log(this->a));
         }
 
-        return static::fromTensorBuffer(tensor_log_base(this->a, (double) base));
+        return new static(tensor_log_base(this->a, (double) base));
     }
 
     /**
@@ -1048,7 +1018,7 @@ class Vector implements Tensor
     */
     public function log1p() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_log1p(this->a));
+        return new static(tensor_log1p(this->a));
     }
 
     /**
@@ -1058,7 +1028,7 @@ class Vector implements Tensor
      */
     public function sin() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_sin(this->a));
+        return new static(tensor_sin(this->a));
     }
 
     /**
@@ -1068,7 +1038,7 @@ class Vector implements Tensor
      */
     public function asin() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_asin(this->a));
+        return new static(tensor_asin(this->a));
     }
 
     /**
@@ -1078,7 +1048,7 @@ class Vector implements Tensor
      */
     public function cos() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_cos(this->a));
+        return new static(tensor_cos(this->a));
     }
 
     /**
@@ -1088,7 +1058,7 @@ class Vector implements Tensor
      */
     public function acos() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_acos(this->a));
+        return new static(tensor_acos(this->a));
     }
 
     /**
@@ -1098,7 +1068,7 @@ class Vector implements Tensor
      */
     public function tan() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_tan(this->a));
+        return new static(tensor_tan(this->a));
     }
 
     /**
@@ -1108,7 +1078,7 @@ class Vector implements Tensor
      */
     public function atan() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_atan(this->a));
+        return new static(tensor_atan(this->a));
     }
 
     /**
@@ -1118,7 +1088,7 @@ class Vector implements Tensor
      */
     public function rad2deg() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_rad2deg(this->a));
+        return new static(tensor_rad2deg(this->a));
     }
 
     /**
@@ -1128,7 +1098,7 @@ class Vector implements Tensor
      */
     public function deg2rad() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_deg2rad(this->a));
+        return new static(tensor_deg2rad(this->a));
     }
 
     /**
@@ -1277,7 +1247,7 @@ class Vector implements Tensor
                 . " be less than 0, " . strval(precision)  . " given.");
         }
 
-        return static::fromTensorBuffer(tensor_round(this->a, (int) precision));
+        return new static(tensor_round(this->a, (int) precision));
     }
 
     /**
@@ -1287,7 +1257,7 @@ class Vector implements Tensor
      */
     public function floor() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_floor(this->a));
+        return new static(tensor_floor(this->a));
     }
 
     /**
@@ -1297,7 +1267,7 @@ class Vector implements Tensor
      */
     public function ceil() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_ceil(this->a));
+        return new static(tensor_ceil(this->a));
     }
 
     /**
@@ -1316,7 +1286,7 @@ class Vector implements Tensor
                 . " greater than maximum.");
         }
 
-        return static::fromTensorBuffer(tensor_clip(this->a, (double) min, (double) max));
+        return new static(tensor_clip(this->a, (double) min, (double) max));
     }
 
     /**
@@ -1327,7 +1297,7 @@ class Vector implements Tensor
      */
     public function clipLower(const float min) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_clip_lower(this->a, (double) min));
+        return new static(tensor_clip_lower(this->a, (double) min));
     }
 
     /**
@@ -1338,7 +1308,7 @@ class Vector implements Tensor
      */
     public function clipUpper(const float max) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_clip_upper(this->a, (double) max));
+        return new static(tensor_clip_upper(this->a, (double) max));
     }
 
     /**
@@ -1348,7 +1318,7 @@ class Vector implements Tensor
      */
     public function sign() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_sign(this->a));
+        return new static(tensor_sign(this->a));
     }
 
     /**
@@ -1358,7 +1328,7 @@ class Vector implements Tensor
      */
     public function negate() -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_negate(this->a));
+        return new static(tensor_negate(this->a));
     }
 
     /**
@@ -1688,7 +1658,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_multiply(this->a, b->a));
+        return new static(tensor_multiply(this->a, b->a));
     }
 
     /**
@@ -1706,7 +1676,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_divide(this->a, b->a));
+        return new static(tensor_divide(this->a, b->a));
     }
 
     /**
@@ -1724,7 +1694,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_add(this->a, b->a));
+        return new static(tensor_add(this->a, b->a));
     }
 
     /**
@@ -1742,7 +1712,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_subtract(this->a, b->a));
+        return new static(tensor_subtract(this->a, b->a));
     }
 
     /**
@@ -1760,7 +1730,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_pow(this->a, b->a));
+        return new static(tensor_pow(this->a, b->a));
     }
 
     /**
@@ -1778,7 +1748,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_mod(this->a, b->a));
+        return new static(tensor_mod(this->a, b->a));
     }
 
     /**
@@ -1797,7 +1767,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_equal(this->a, b->a));
+        return new static(tensor_equal(this->a, b->a));
     }
 
     /**
@@ -1815,7 +1785,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_not_equal(this->a, b->a));
+        return new static(tensor_not_equal(this->a, b->a));
     }
 
     /**
@@ -1833,7 +1803,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_greater(this->a, b->a));
+        return new static(tensor_greater(this->a, b->a));
     }
 
     /**
@@ -1851,7 +1821,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_greater_equal(this->a, b->a));
+        return new static(tensor_greater_equal(this->a, b->a));
     }
 
     /**
@@ -1869,7 +1839,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_less(this->a, b->a));
+        return new static(tensor_less(this->a, b->a));
     }
 
     /**
@@ -1887,7 +1857,7 @@ class Vector implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return static::fromTensorBuffer(tensor_less_equal(this->a, b->a));
+        return new static(tensor_less_equal(this->a, b->a));
     }
 
     /**
@@ -1898,7 +1868,7 @@ class Vector implements Tensor
      */
      public function multiplyScalar(const float b) -> <Vector>
      {
-        return static::fromTensorBuffer(tensor_multiply_scalar(this->a, b));
+        return new static(tensor_multiply_scalar(this->a, b));
     }
 
     /**
@@ -1909,7 +1879,7 @@ class Vector implements Tensor
      */
     public function divideScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_divide_scalar(this->a, b));
+        return new static(tensor_divide_scalar(this->a, b));
     }
 
     /**
@@ -1920,7 +1890,7 @@ class Vector implements Tensor
      */
     public function addScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_add_scalar(this->a, b));
+        return new static(tensor_add_scalar(this->a, b));
     }
 
     /**
@@ -1931,7 +1901,7 @@ class Vector implements Tensor
      */
     public function subtractScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_subtract_scalar(this->a, b));
+        return new static(tensor_subtract_scalar(this->a, b));
     }
 
     /**
@@ -1942,7 +1912,7 @@ class Vector implements Tensor
      */
      public function powScalar(const float b) -> <Vector>
      {
-        return static::fromTensorBuffer(tensor_pow_scalar(this->a, b));
+        return new static(tensor_pow_scalar(this->a, b));
      }
 
     /**
@@ -1953,7 +1923,7 @@ class Vector implements Tensor
      */
     public function modScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_mod_scalar(this->a, b));
+        return new static(tensor_mod_scalar(this->a, b));
     }
 
     /**
@@ -1964,7 +1934,7 @@ class Vector implements Tensor
      */
     public function equalScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_equal_scalar(this->a, b));
+        return new static(tensor_equal_scalar(this->a, b));
     }
 
     /**
@@ -1975,7 +1945,7 @@ class Vector implements Tensor
      */
     public function notEqualScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_not_equal_scalar(this->a, b));
+        return new static(tensor_not_equal_scalar(this->a, b));
     }
 
     /**
@@ -1986,7 +1956,7 @@ class Vector implements Tensor
      */
     public function greaterScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_greater_scalar(this->a, b));
+        return new static(tensor_greater_scalar(this->a, b));
     }
 
     /**
@@ -1998,7 +1968,7 @@ class Vector implements Tensor
      */
     public function greaterEqualScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_greater_equal_scalar(this->a, b));
+        return new static(tensor_greater_equal_scalar(this->a, b));
     }
 
     /**
@@ -2009,7 +1979,7 @@ class Vector implements Tensor
      */
     public function lessScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_less_scalar(this->a, b));
+        return new static(tensor_less_scalar(this->a, b));
     }
 
     /**
@@ -2021,7 +1991,7 @@ class Vector implements Tensor
      */
     public function lessEqualScalar(const float b) -> <Vector>
     {
-        return static::fromTensorBuffer(tensor_less_equal_scalar(this->a, b));
+        return new static(tensor_less_equal_scalar(this->a, b));
     }
 
     /**
diff --git a/tests/ColumnVectorTest.php b/tests/ColumnVectorTest.php
index cd6d0e7..dde88c9 100644
--- a/tests/ColumnVectorTest.php
+++ b/tests/ColumnVectorTest.php
@@ -33,7 +33,7 @@ class ColumnVectorTest extends TestCase
      */
     public function build() : void
     {
-        $vector = ColumnVector::build([-15, 25, 35]);
+        $vector = new ColumnVector([-15, 25, 35]);
 
         $this->assertInstanceOf(ColumnVector::class, $vector);
         $this->assertInstanceOf(Tensor::class, $vector);
@@ -51,7 +51,7 @@ public function build() : void
      */
     public function shape() : void
     {
-        $vector = ColumnVector::quick([-15, 25, 35]);
+        $vector = new ColumnVector([-15, 25, 35]);
 
         $this->assertEquals([3], $vector->shape());
     }
@@ -61,7 +61,7 @@ public function shape() : void
      */
     public function shapeString() : void
     {
-        $vector = ColumnVector::quick([-15, 25, 35]);
+        $vector = new ColumnVector([-15, 25, 35]);
 
         $this->assertEquals('3', $vector->shapeString());
     }
@@ -71,7 +71,7 @@ public function shapeString() : void
      */
     public function size() : void
     {
-        $vector = ColumnVector::quick([-15, 25, 35]);
+        $vector = new ColumnVector([-15, 25, 35]);
 
         $this->assertEquals(3, $vector->size());
     }
@@ -81,7 +81,7 @@ public function size() : void
      */
     public function m() : void
     {
-        $vector = ColumnVector::quick([-15, 25, 35]);
+        $vector = new ColumnVector([-15, 25, 35]);
 
         $this->assertEquals(3, $vector->m());
     }
@@ -91,7 +91,7 @@ public function m() : void
      */
     public function n() : void
     {
-        $vector = ColumnVector::quick([-15, 25, 35]);
+        $vector = new ColumnVector([-15, 25, 35]);
 
         $this->assertEquals(1, $vector->n());
     }
@@ -101,9 +101,9 @@ public function n() : void
      */
     public function multiply() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -111,7 +111,7 @@ public function multiply() : void
 
         $c = $a->multiply($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [-93.45, 15, -0.44999999999999996],
             [0.25, 50.24999999999999, 25],
             [38.5, 175, -175],
@@ -125,9 +125,9 @@ public function multiply() : void
      */
     public function divide() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -135,7 +135,7 @@ public function divide() : void
 
         $c = $a->divide($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [-2.407704654895666, 15, -500.],
             [2500.0, 12.437810945273633, 25],
             [31.818181818181817, 7, -7],
@@ -149,9 +149,9 @@ public function divide() : void
      */
     public function add() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -159,7 +159,7 @@ public function add() : void
 
         $c = $a->add($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [-8.77, -16, -14.97],
             [25.01, 27.009999999999998, 26],
             [36.1, 40, 30],
@@ -173,9 +173,9 @@ public function add() : void
      */
     public function subtract() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -183,7 +183,7 @@ public function subtract() : void
 
         $c = $a->subtract($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [-21.23, -14, -15.03],
             [24.99, 22.990000000000002, 24],
             [33.9, 30, 40],
@@ -197,9 +197,9 @@ public function subtract() : void
      */
     public function equal() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -207,7 +207,7 @@ public function equal() : void
 
         $c = $a->equal($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0, 0, 0],
             [0, 0, 0],
             [0, 0, 0],
@@ -221,9 +221,9 @@ public function equal() : void
      */
     public function notEqual() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -231,7 +231,7 @@ public function notEqual() : void
 
         $c = $a->notEqual($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1, 1, 1],
             [1, 1, 1],
             [1, 1, 1],
@@ -245,9 +245,9 @@ public function notEqual() : void
      */
     public function greater() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -255,7 +255,7 @@ public function greater() : void
 
         $c = $a->greater($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0, 0, 0],
             [1, 1, 1],
             [1, 1, 1],
@@ -269,9 +269,9 @@ public function greater() : void
      */
     public function greaterEqual() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -279,7 +279,7 @@ public function greaterEqual() : void
 
         $c = $a->greaterEqual($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0, 0, 0],
             [1, 1, 1],
             [1, 1, 1],
@@ -293,9 +293,9 @@ public function greaterEqual() : void
      */
     public function less() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -303,7 +303,7 @@ public function less() : void
 
         $c = $a->less($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1, 1, 1],
             [0, 0, 0],
             [0, 0, 0],
@@ -317,9 +317,9 @@ public function less() : void
      */
     public function lessEqual() : void
     {
-        $a = ColumnVector::quick([-15, 25, 35]);
+        $a = new ColumnVector([-15, 25, 35]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [6.23, -1, 0.03],
             [0.01, 2.01, 1],
             [1.1, 5, -5],
@@ -327,7 +327,7 @@ public function lessEqual() : void
 
         $c = $a->lessEqual($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1, 1, 1],
             [0, 0, 0],
             [0, 0, 0],
@@ -341,12 +341,12 @@ public function lessEqual() : void
      */
     public function transposeReturnsVector() : void
     {
-        $a = ColumnVector::quick([1.0, 2.0, 3.0]);
+        $a = new ColumnVector([1.0, 2.0, 3.0]);
 
         $b = $a->transpose();
 
         $this->assertInstanceOf(Vector::class, $b);
-        $this->assertEquals(Vector::quick([1.0, 2.0, 3.0]), $b);
+        $this->assertEquals(new Vector([1.0, 2.0, 3.0]), $b);
     }
 
     /**
@@ -354,7 +354,7 @@ public function transposeReturnsVector() : void
      */
     public function sizes() : void
     {
-        $a = ColumnVector::quick([1.0, 2.0, 3.0]);
+        $a = new ColumnVector([1.0, 2.0, 3.0]);
 
         $this->assertEquals(3, $a->m());
         $this->assertEquals(1, $a->n());
@@ -366,15 +366,15 @@ public function sizes() : void
      */
     public function matmul() : void
     {
-        $a = ColumnVector::quick([1.0, 2.0, 3.0]);
+        $a = new ColumnVector([1.0, 2.0, 3.0]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [1.0, 2.0, 3.0],
         ]);
 
         $c = $a->matmul($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [2.0, 4.0, 6.0],
             [3.0, 6.0, 9.0],
@@ -390,7 +390,7 @@ public function matmulDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        ColumnVector::quick([1.0, 2.0, 3.0])->matmul(Matrix::quick([
+        (new ColumnVector([1.0, 2.0, 3.0]))->matmul(Matrix::fromArray([
             [1.0, 2.0, 3.0, 4.0],
             [5.0, 6.0, 7.0, 8.0],
             [9.0, 10.0, 11.0, 12.0],
@@ -402,9 +402,9 @@ public function matmulDimensionMismatchThrows() : void
      */
     public function powMatrix() : void
     {
-        $a = ColumnVector::quick([2.0, 3.0, 4.0]);
+        $a = new ColumnVector([2.0, 3.0, 4.0]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [1.0, 1.0, 1.0],
             [2.0, 0.0, 1.0],
@@ -412,7 +412,7 @@ public function powMatrix() : void
 
         $c = $a->powMatrix($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [2.0, 4.0, 8.0],
             [3.0, 3.0, 3.0],
             [16.0, 1.0, 4.0],
@@ -428,7 +428,7 @@ public function powMatrixDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        ColumnVector::quick([1.0, 2.0, 3.0])->powMatrix(Matrix::quick([
+        (new ColumnVector([1.0, 2.0, 3.0]))->powMatrix(Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]));
@@ -439,9 +439,9 @@ public function powMatrixDimensionMismatchThrows() : void
      */
     public function modMatrix() : void
     {
-        $a = ColumnVector::quick([10.0, 12.0, 15.0]);
+        $a = new ColumnVector([10.0, 12.0, 15.0]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [3.0, 4.0, 5.0],
             [2.0, 3.0, 4.0],
             [5.0, 6.0, 7.0],
@@ -449,7 +449,7 @@ public function modMatrix() : void
 
         $c = $a->modMatrix($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1.0, 2.0, 0.0],
             [0.0, 0.0, 0.0],
             [0.0, 3.0, 1.0],
@@ -465,7 +465,7 @@ public function modMatrixDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        ColumnVector::quick([1.0, 2.0, 3.0])->modMatrix(Matrix::quick([
+        (new ColumnVector([1.0, 2.0, 3.0]))->modMatrix(Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]));
@@ -478,7 +478,7 @@ public function multiplyMatrixDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        ColumnVector::quick([1.0, 2.0, 3.0])->multiplyMatrix(Matrix::quick([
+        (new ColumnVector([1.0, 2.0, 3.0]))->multiplyMatrix(Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]));
@@ -491,7 +491,7 @@ public function divideMatrixDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        ColumnVector::quick([1.0, 2.0, 3.0])->divideMatrix(Matrix::quick([
+        (new ColumnVector([1.0, 2.0, 3.0]))->divideMatrix(Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]));
diff --git a/tests/Decompositions/CholeskyTest.php b/tests/Decompositions/CholeskyTest.php
index 6dc819d..f6dc9a8 100644
--- a/tests/Decompositions/CholeskyTest.php
+++ b/tests/Decompositions/CholeskyTest.php
@@ -25,14 +25,14 @@ class CholeskyTest extends TestCase
      */
     public function decompose2x2() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [9.0, 3.0],
             [3.0, 5.0],
         ]);
 
         $ch = Cholesky::decompose($a);
 
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [3.0, 0.0],
             [1.0, 2.0],
         ]);
@@ -50,7 +50,7 @@ public function decompose2x2() : void
      */
     public function decompose3x3() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [2.0, -1.0,  0.0],
             [-1.0, 2.0, -1.0],
             [0.0, -1.0, 2.0],
@@ -58,7 +58,7 @@ public function decompose3x3() : void
 
         $ch = Cholesky::decompose($a);
 
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [1.4142135623730951, 0, 0],
             [-0.7071067811865475, 1.224744871391589, 0],
             [0, -0.8164965809277261, 1.1547005383792515],
@@ -74,11 +74,11 @@ public function decompose3x3() : void
      */
     public function decompose1x1() : void
     {
-        $a = Matrix::quick([[9.0]]);
+        $a = Matrix::fromArray([[9.0]]);
 
         $ch = Cholesky::decompose($a);
 
-        $l = Matrix::quick([[3.0]]);
+        $l = Matrix::fromArray([[3.0]]);
 
         $expected = new Cholesky($l);
 
@@ -90,7 +90,7 @@ public function decompose1x1() : void
      */
     public function decomposeDiagonal() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [4.0, 0.0, 0.0],
             [0.0, 9.0, 0.0],
             [0.0, 0.0, 16.0],
@@ -98,7 +98,7 @@ public function decomposeDiagonal() : void
 
         $ch = Cholesky::decompose($a);
 
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [2.0, 0.0, 0.0],
             [0.0, 3.0, 0.0],
             [0.0, 0.0, 4.0],
@@ -116,7 +116,7 @@ public function decomposeNonSquareThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Cholesky::decompose(Matrix::quick([
+        Cholesky::decompose(Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ]));
@@ -129,7 +129,7 @@ public function decomposeIndefiniteThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        Cholesky::decompose(Matrix::quick([
+        Cholesky::decompose(Matrix::fromArray([
             [1.0, 2.0],
             [2.0, 1.0],
         ]));
@@ -142,7 +142,7 @@ public function decomposeZeroPivotThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        Cholesky::decompose(Matrix::quick([
+        Cholesky::decompose(Matrix::fromArray([
             [0.0, 1.0],
             [1.0, 1.0],
         ]));
@@ -155,7 +155,7 @@ public function decomposeSingularThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        Cholesky::decompose(Matrix::quick([
+        Cholesky::decompose(Matrix::fromArray([
             [1.0, 2.0],
             [2.0, 4.0],
         ]));
@@ -166,7 +166,7 @@ public function decomposeSingularThrows() : void
      */
     public function lTIsTranspose() : void
     {
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [3.0, 0.0],
             [1.0, 2.0],
         ]);
@@ -181,7 +181,7 @@ public function lTIsTranspose() : void
      */
     public function accessorsReturnMatrices() : void
     {
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [1.0, 0.0],
             [0.5, 1.0],
         ]);
@@ -190,7 +190,7 @@ public function accessorsReturnMatrices() : void
 
         $this->assertEquals($l, $ch->l());
 
-        $expectedT = Matrix::quick([
+        $expectedT = Matrix::fromArray([
             [1.0, 0.5],
             [0.0, 1.0],
         ]);
diff --git a/tests/Decompositions/EigenTest.php b/tests/Decompositions/EigenTest.php
index efe9104..6bd355c 100644
--- a/tests/Decompositions/EigenTest.php
+++ b/tests/Decompositions/EigenTest.php
@@ -24,7 +24,7 @@ class EigenTest extends TestCase
      */
     public function decomposeGeneral3x3() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -52,7 +52,7 @@ public function decomposeGeneral3x3() : void
      */
     public function decomposeSymmetric3x3() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [3.0, -1.0, 0.0],
             [-1.0, 2.0, -1.0],
             [0.0, -1.0, 3.0],
@@ -72,7 +72,7 @@ public function decomposeSymmetric3x3() : void
      */
     public function decomposeSymmetric2x2() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [9.0, 3.0],
             [3.0, 5.0],
         ]);
@@ -89,7 +89,7 @@ public function decomposeSymmetric2x2() : void
      */
     public function decomposeGeneralAndSymmetricAgree() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [3.0, -1.0, 0.0],
             [-1.0, 2.0, -1.0],
             [0.0, -1.0, 3.0],
@@ -112,7 +112,7 @@ public function decomposeGeneralAndSymmetricAgree() : void
      */
     public function decompose1x1() : void
     {
-        $a = Matrix::quick([[9.0]]);
+        $a = Matrix::fromArray([[9.0]]);
 
         $eig = Eigen::decompose($a);
 
@@ -120,7 +120,7 @@ public function decompose1x1() : void
 
         $this->assertEquals([9.0], $eig->eigenvalues());
 
-        $this->assertEqualsWithDelta(Matrix::quick([[1.0]]), $eig->eigenvectors(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::fromArray([[1.0]]), $eig->eigenvectors(), self::MAX_DELTA);
     }
 
     /**
@@ -128,7 +128,7 @@ public function decompose1x1() : void
      */
     public function decomposeDiagonal() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [2.0, 0.0, 0.0],
             [0.0, 3.0, 0.0],
             [0.0, 0.0, 5.0],
@@ -148,7 +148,7 @@ public function decomposeNonSquareThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Eigen::decompose(Matrix::quick([
+        Eigen::decompose(Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ]));
@@ -161,7 +161,7 @@ public function constructAndAccess() : void
     {
         $eigenvalues = [1.0, 2.0, 3.0];
 
-        $eigenvectors = Matrix::quick([
+        $eigenvectors = Matrix::fromArray([
             [1.0, 0.0, 0.0],
             [0.0, 1.0, 0.0],
             [0.0, 0.0, 1.0],
@@ -180,7 +180,7 @@ public function constructAndAccess() : void
      */
     public function decomposeComplexPair() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [0.0, -1.0],
             [1.0, 0.0],
         ]);
@@ -226,7 +226,7 @@ public function decomposeComplexPair() : void
      */
     public function decomposeComplexPairWithReal() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [0.0, -1.0, 0.0],
             [1.0, 0.0, 0.0],
             [0.0, 0.0, 2.0],
diff --git a/tests/Decompositions/LUTest.php b/tests/Decompositions/LUTest.php
index 3f79c46..672fb05 100644
--- a/tests/Decompositions/LUTest.php
+++ b/tests/Decompositions/LUTest.php
@@ -25,7 +25,7 @@ class LUTest extends TestCase
      */
     public function decompose3x3() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -33,19 +33,19 @@ public function decompose3x3() : void
 
         $lu = LU::decompose($a);
 
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [1.0, 0, 0],
             [0.18181818181818182, 1.0, 0],
             [0.9090909090909091, 0.6709677419354838, 1.0],
         ]);
 
-        $u = Matrix::quick([
+        $u = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [0.0, 14.09090909090909, -4.181818181818182],
             [0.0, 0.0, -17.10322580645161],
         ]);
 
-        $p = Matrix::quick([
+        $p = Matrix::fromArray([
             [1.0, 0, 0],
             [0.0, 1.0, 0],
             [0.0, 0.0, 1.0],
@@ -67,7 +67,7 @@ public function decompose3x3() : void
      */
     public function decomposeRequiresPivoting() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [0.0,  1.0,  0.0,  0.0],
             [-1.0, 0.0,  0.0,  0.0],
             [0.0,  0.0,  0.0,  2.0],
@@ -88,13 +88,13 @@ public function decomposeRequiresPivoting() : void
      */
     public function decompose1x1() : void
     {
-        $a = Matrix::quick([[9.0]]);
+        $a = Matrix::fromArray([[9.0]]);
 
         $lu = LU::decompose($a);
 
-        $l = Matrix::quick([[1.0]]);
-        $u = Matrix::quick([[9.0]]);
-        $p = Matrix::quick([[1.0]]);
+        $l = Matrix::fromArray([[1.0]]);
+        $u = Matrix::fromArray([[9.0]]);
+        $p = Matrix::fromArray([[1.0]]);
 
         $expected = new LU($l, $u, $p);
 
@@ -106,24 +106,24 @@ public function decompose1x1() : void
      */
     public function decomposeDiagonal() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [2.0, 0.0],
             [0.0, 3.0],
         ]);
 
         $lu = LU::decompose($a);
 
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [1.0, 0.0],
             [0.0, 1.0],
         ]);
 
-        $u = Matrix::quick([
+        $u = Matrix::fromArray([
             [2.0, 0.0],
             [0.0, 3.0],
         ]);
 
-        $p = Matrix::quick([
+        $p = Matrix::fromArray([
             [1.0, 0.0],
             [0.0, 1.0],
         ]);
@@ -140,7 +140,7 @@ public function decomposeNonSquareThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        LU::decompose(Matrix::quick([
+        LU::decompose(Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ]));
@@ -153,7 +153,7 @@ public function decomposeSingularThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        LU::decompose(Matrix::quick([
+        LU::decompose(Matrix::fromArray([
             [1.0, 2.0],
             [2.0, 4.0],
         ]));
@@ -164,17 +164,17 @@ public function decomposeSingularThrows() : void
      */
     public function accessorsReturnMatrices() : void
     {
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [1.0, 0.0],
             [0.5, 1.0],
         ]);
 
-        $u = Matrix::quick([
+        $u = Matrix::fromArray([
             [2.0, 3.0],
             [0.0, 4.0],
         ]);
 
-        $p = Matrix::quick([
+        $p = Matrix::fromArray([
             [0.0, 1.0],
             [1.0, 0.0],
         ]);
diff --git a/tests/Decompositions/SVDTest.php b/tests/Decompositions/SVDTest.php
index 57d36ff..5ff73d0 100644
--- a/tests/Decompositions/SVDTest.php
+++ b/tests/Decompositions/SVDTest.php
@@ -23,7 +23,7 @@ class SVDTest extends TestCase
      */
     public function decomposeSquare3x3() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -50,7 +50,7 @@ public function decomposeSquare3x3() : void
      */
     public function decomposeSquare2x2() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]);
@@ -70,7 +70,7 @@ public function decomposeSquare2x2() : void
      */
     public function decomposeTall() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
             [5.0, 6.0],
@@ -95,7 +95,7 @@ public function decomposeTall() : void
      */
     public function decomposeWide() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ]);
@@ -118,7 +118,7 @@ public function decomposeWide() : void
      */
     public function decompose1x1() : void
     {
-        $a = Matrix::quick([[9.0]]);
+        $a = Matrix::fromArray([[9.0]]);
 
         $svd = SVD::decompose($a);
 
@@ -132,7 +132,7 @@ public function decompose1x1() : void
      */
     public function decomposeRankDeficient() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 1.0],
             [2.0, 2.0],
         ]);
@@ -155,7 +155,7 @@ public function decomposeRankDeficient() : void
      */
     public function decomposePreservesTinySingularValues() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 0.0, 0.0],
             [0.0, 1e-9, 0.0],
             [0.0, 0.0, 0.0],
@@ -177,14 +177,14 @@ public function decomposePreservesTinySingularValues() : void
      */
     public function constructAndAccess() : void
     {
-        $u = Matrix::quick([
+        $u = Matrix::fromArray([
             [1.0, 0.0],
             [0.0, 1.0],
         ]);
 
         $singularValues = [5.0, 3.0];
 
-        $vT = Matrix::quick([
+        $vT = Matrix::fromArray([
             [1.0, 0.0],
             [0.0, 1.0],
         ]);
@@ -201,7 +201,7 @@ public function constructAndAccess() : void
         // The singular value matrix is an m by n matrix with the singular values on the diagonal.
         $this->assertSame([2, 2], $svd->s()->shape());
 
-        $expectedS = Matrix::quick([
+        $expectedS = Matrix::fromArray([
             [5.0, 0.0],
             [0.0, 3.0],
         ]);
@@ -225,6 +225,6 @@ private function reconstruct(SVD $svd, int $m, int $n) : Matrix
             $s[$i][$i] = $value;
         }
 
-        return $svd->u()->matmul(Matrix::quick($s))->matmul($svd->vT());
+        return $svd->u()->matmul(Matrix::fromArray($s))->matmul($svd->vT());
     }
 }
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index 71dfcda..822c693 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -42,7 +42,7 @@ class MatrixTest extends TestCase
      */
     public function build() : void
     {
-        $matrix = Matrix::build([
+        $matrix = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -64,7 +64,7 @@ public function build() : void
      */
     public function buildCastsIntegersToFloatsAndPreservesShape() : void
     {
-        $matrix = Matrix::build([
+        $matrix = Matrix::fromArray([
             [1, 2, 3],
             [4, 5, 6],
         ]);
@@ -97,7 +97,7 @@ public function identity() : void
     {
         $matrix = Matrix::identity(4);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1, 0, 0, 0],
             [0, 1, 0, 0],
             [0, 0, 1, 0],
@@ -114,7 +114,7 @@ public function zeros() : void
     {
         $matrix = Matrix::zeros(2, 4);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0, 0, 0, 0],
             [0, 0, 0, 0],
         ]);
@@ -129,7 +129,7 @@ public function ones() : void
     {
         $matrix = Matrix::ones(4, 2);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1, 1],
             [1, 1],
             [1, 1],
@@ -146,7 +146,7 @@ public function diagonal() : void
     {
         $matrix = Matrix::diagonal([0, 1, 4, 5]);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0, 0, 0, 0],
             [0, 1, 0, 0],
             [0, 0, 4, 0],
@@ -163,7 +163,7 @@ public function fill() : void
     {
         $matrix = Matrix::fill(5, 4, 4);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [5, 5, 5, 5],
             [5, 5, 5, 5],
             [5, 5, 5, 5],
@@ -240,7 +240,7 @@ public function uniform() : void
      */
     public function shape() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -254,7 +254,7 @@ public function shape() : void
      */
     public function shapeString() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22, -17, 12, 16],
             [4, 11, -2, 18],
         ]);
@@ -280,7 +280,7 @@ public function isSquare(Matrix $matrix, $expected) : void
     public function isSquareProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22, -17, 12],
                 [4, 11, -2],
                 [20, -6, -9],
@@ -289,7 +289,7 @@ public function isSquareProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22, -17, 12, 16],
                 [4, 11, -2, 18],
             ]),
@@ -302,7 +302,7 @@ public function isSquareProvider() : Generator
      */
     public function size() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -316,7 +316,7 @@ public function size() : void
      */
     public function m() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -330,7 +330,7 @@ public function m() : void
      */
     public function n() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -344,7 +344,7 @@ public function n() : void
      */
     public function rowAsVector() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -352,7 +352,7 @@ public function rowAsVector() : void
 
         $b = $a->rowAsVector(1);
 
-        $expected = Vector::quick([4, 11, -2]);
+        $expected = new Vector([4, 11, -2]);
 
         $this->assertEquals($expected, $b);
     }
@@ -362,7 +362,7 @@ public function rowAsVector() : void
      */
     public function columnAsVector() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -370,7 +370,7 @@ public function columnAsVector() : void
 
         $b = $a->columnAsVector(1);
 
-        $expected = ColumnVector::quick([-17, 11, -6]);
+        $expected = new ColumnVector([-17, 11, -6]);
 
         $this->assertEquals($expected, $b);
     }
@@ -380,7 +380,7 @@ public function columnAsVector() : void
      */
     public function diagonalAsVector() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -388,7 +388,7 @@ public function diagonalAsVector() : void
 
         $b = $a->diagonalAsVector();
 
-        $expected = Vector::quick([22, 11, -9]);
+        $expected = new Vector([22, 11, -9]);
 
         $this->assertEquals($expected, $b);
     }
@@ -398,7 +398,7 @@ public function diagonalAsVector() : void
      */
     public function asArray() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -418,7 +418,7 @@ public function asArray() : void
      */
     public function asVectors() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -427,9 +427,9 @@ public function asVectors() : void
         $vectors = $matrix->asVectors();
 
         $expected = [
-            Vector::quick([22, -17, 12]),
-            Vector::quick([4, 11, -2]),
-            Vector::quick([20, -6, -9]),
+            new Vector([22, -17, 12]),
+            new Vector([4, 11, -2]),
+            new Vector([20, -6, -9]),
         ];
 
         $this->assertEquals($expected, $vectors);
@@ -440,7 +440,7 @@ public function asVectors() : void
      */
     public function asColumnVectors() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -449,9 +449,9 @@ public function asColumnVectors() : void
         $vectors = $matrix->asColumnVectors();
 
         $expected = [
-            ColumnVector::quick([22, 4, 20]),
-            ColumnVector::quick([-17, 11, -6]),
-            ColumnVector::quick([12, -2, -9]),
+            new ColumnVector([22, 4, 20]),
+            new ColumnVector([-17, 11, -6]),
+            new ColumnVector([12, -2, -9]),
         ];
 
         $this->assertEquals($expected, $vectors);
@@ -462,7 +462,7 @@ public function asColumnVectors() : void
      */
     public function flatten() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -470,7 +470,7 @@ public function flatten() : void
 
         $b = $a->flatten();
 
-        $expected = Vector::quick([22, -17, 12, 4, 11, -2, 20, -6, -9]);
+        $expected = new Vector([22, -17, 12, 4, 11, -2, 20, -6, -9]);
 
         $this->assertEquals($expected, $b);
     }
@@ -480,7 +480,7 @@ public function flatten() : void
      */
     public function transpose() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -488,7 +488,7 @@ public function transpose() : void
 
         $b = $a->transpose();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [22, 4, 20],
             [-17, 11, -6],
             [12, -2, -9],
@@ -502,7 +502,7 @@ public function transpose() : void
      */
     public function inverse() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -510,7 +510,7 @@ public function inverse() : void
 
         $b = $a->inverse();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0.02093549603923048, 0.042436816295737464, 0.018483591097698978],
             [0.0007544322897019996, 0.08261033572236892, -0.017351942663145988],
             [0.04602036967182196, 0.03923047906450396, -0.05846850245190495],
@@ -526,7 +526,7 @@ public function inverseNonSquareThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
             [5.0, 6.0],
@@ -541,7 +541,7 @@ public function inverseSingularThrows() : void
         // Exactly singular (column 3 = column 0 - column 1 + column 2); the
         // inverse must be rejected rather than return a magnitude ~1e15 matrix
         // that does not satisfy A * A^-1 = I.
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [2.0, 1.0, 0.0, 1.0],
             [1.0, 2.0, 1.0, 0.0],
             [0.0, 1.0, 2.0, 1.0],
@@ -559,14 +559,14 @@ public function inverseSingularThrows() : void
      */
     public function pseudoinverse() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
         ]);
 
         $b = $a->pseudoinverse();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0.03147992432205172, 0.05583000490505223],
             [-0.009144418751313844, 0.07003713825239999],
             [0.01266554551187723, -0.0031357298016957483],
@@ -580,7 +580,7 @@ public function pseudoinverse() : void
      */
     public function det() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [4, 6, -12],
             [1, 3, 5],
             [-10, -1, 14],
@@ -596,7 +596,7 @@ public function detSingularIsZero() : void
     {
         // Exactly singular (column 3 = column 0 - column 1 + column 2); the
         // determinant must be ~0 rather than a spurious ~1e-15 value.
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [2.0, 1.0, 0.0, 1.0],
             [1.0, 2.0, 1.0, 0.0],
             [0.0, 1.0, 2.0, 1.0],
@@ -611,7 +611,7 @@ public function detSingularIsZero() : void
      */
     public function trace() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [4, 6, -12],
             [1, 3, 5],
             [-10, -1, 14],
@@ -638,7 +638,7 @@ public function symmetric(Matrix $matrix, $expected) : void
     public function symmetricProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22, -17, 12],
                 [4, 11, -2],
                 [20, -6, -9],
@@ -647,7 +647,7 @@ public function symmetricProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 5, 2],
                 [5, 1, 3],
                 [2, 3, 1],
@@ -661,7 +661,7 @@ public function symmetricProvider() : Generator
      */
     public function rank() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -669,7 +669,7 @@ public function rank() : void
 
         $this->assertEquals(3, $a->rank());
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ]);
@@ -679,7 +679,7 @@ public function rank() : void
         // Exactly singular (column 3 = column 0 - column 1 + column 2); the
         // rank must be 3, not 4, even though floating point leaves a ~1e-16
         // residual on the diagonal.
-        $c = Matrix::quick([
+        $c = Matrix::fromArray([
             [2.0, 1.0, 0.0, 1.0],
             [1.0, 2.0, 1.0, 0.0],
             [0.0, 1.0, 2.0, 1.0],
@@ -694,7 +694,7 @@ public function rank() : void
      */
     public function fullRank() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -702,7 +702,7 @@ public function fullRank() : void
 
         $this->assertTrue($a->fullRank());
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ]);
@@ -710,7 +710,7 @@ public function fullRank() : void
         $this->assertTrue($b->fullRank());
 
         // Exactly singular 4x4 (see rank() above); fullRank() must be false.
-        $c = Matrix::quick([
+        $c = Matrix::fromArray([
             [2.0, 1.0, 0.0, 1.0],
             [1.0, 2.0, 1.0, 0.0],
             [0.0, 1.0, 2.0, 1.0],
@@ -725,7 +725,7 @@ public function fullRank() : void
      */
     public function reciprocal() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -733,7 +733,7 @@ public function reciprocal() : void
 
         $b = $a->reciprocal();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0.045454545454545456, -0.058823529411764705, 0.08333333333333333],
             [0.25, 0.09090909090909091, -0.5],
             [0.05, -0.16666666666666666, -0.1111111111111111],
@@ -747,7 +747,7 @@ public function reciprocal() : void
      */
     public function map() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -759,7 +759,7 @@ public function map() : void
 
         $b = $a->map($sign);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1, -1, 1],
             [1, 1, -1],
             [1, -1, -1],
@@ -773,7 +773,7 @@ public function map() : void
      */
     public function reduce() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]);
@@ -793,7 +793,7 @@ public function reduce() : void
         $this->assertEqualsWithDelta(-8.0, $a->reduce($subtract, 2.0), self::MAX_DELTA);
 
         // Must match Vector::reduce() for the same data and callback.
-        $v = Vector::quick([1.0, 2.0, 3.0, 4.0]);
+        $v = new Vector([1.0, 2.0, 3.0, 4.0]);
 
         $this->assertEqualsWithDelta($v->reduce($subtract), $a->reduce($subtract), self::MAX_DELTA);
     }
@@ -803,7 +803,7 @@ public function reduce() : void
      */
     public function ref() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -811,7 +811,7 @@ public function ref() : void
 
         $ref = $matrix->ref();
 
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22, -17, 12],
             [0, 14.09090909090909, -4.181818181818182],
             [0, 0, -17.10322580645161],
@@ -827,7 +827,7 @@ public function ref() : void
      */
     public function rref() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -835,7 +835,7 @@ public function rref() : void
 
         $rref = $matrix->rref();
 
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1, 0, 0],
             [0, 1, 0],
             [0, 0, 1],
@@ -851,7 +851,7 @@ public function rref() : void
      */
     public function lu() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -859,19 +859,19 @@ public function lu() : void
 
         $lu = $matrix->lu();
 
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [1.0, 0, 0],
             [0.18181818181818182, 1.0, 0],
             [0.9090909090909091, 0.6709677419354838, 1.0],
         ]);
 
-        $u = Matrix::quick([
+        $u = Matrix::fromArray([
             [22, -17, 12],
             [0, 14.09090909090909, -4.181818181818182],
             [0, 0, -17.10322580645161],
         ]);
 
-        $p = Matrix::quick([
+        $p = Matrix::fromArray([
             [1, 0, 0],
             [0, 1, 0],
             [0, 0, 1],
@@ -887,7 +887,7 @@ public function lu() : void
      */
     public function luMultiPivot() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [0.0,  1.0,  0.0,  0.0],
             [-1.0,  0.0,  0.0,  0.0],
             [0.0,  0.0,  0.0,  2.0],
@@ -907,7 +907,7 @@ public function luMultiPivot() : void
      */
     public function luNegativePivot() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [1.0,  2.0,  3.0,  4.0],
             [-9.0,  1.0,  0.0,  0.0],
             [0.5,  0.5,  1.0,  1.0],
@@ -929,7 +929,7 @@ public function luSingular() : void
     {
         $this->expectException(RuntimeException::class);
 
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [1.0, 2.0,  0.0,  0.0],
             [0.0, 1.0,  1.0,  0.0],
             [2.0, 4.0,  0.0,  1.0],
@@ -944,7 +944,7 @@ public function luSingular() : void
      */
     public function cholesky() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [2, -1, 0],
             [-1, 2, -1],
             [0, -1, 2],
@@ -952,7 +952,7 @@ public function cholesky() : void
 
         $cholesky = $matrix->cholesky();
 
-        $l = Matrix::quick([
+        $l = Matrix::fromArray([
             [1.4142135623730951, 0, 0],
             [-0.7071067811865475, 1.224744871391589, 0],
             [0, -0.8164965809277261, 1.1547005383792515],
@@ -984,7 +984,7 @@ public function eig(Matrix $matrix, Eigen $expected) : void
     public function eigProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
@@ -993,7 +993,7 @@ public function eigProvider() : Generator
                 [
                     -15.096331148319537, 25.108706520450326, 13.9876246278692,
                 ],
-                Matrix::quick([
+                Matrix::fromArray([
                     [0.25848694820886425, -0.11314537870318066, -0.9593657388523845],
                     [-0.8622719261400653, -0.17721179605718698, -0.47442924101375483],
                     [-0.6684472200177011, -0.6126879076802705, -0.42165369894378907],
@@ -1008,7 +1008,7 @@ public function eigProvider() : Generator
      */
     public function eigSymmetric() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -1018,7 +1018,7 @@ public function eigSymmetric() : void
 
         $values = [-366.30071669298195, 335.92000012383926, 1084.3807165691428];
 
-        $vectors = Matrix::quick([
+        $vectors = Matrix::fromArray([
             [0.5423765325213931, 0.8162941265260668, -0.19872492538460218],
             [-0.04667292577741032, 0.26544998308386847, 0.9629942598375911],
             [-0.8388380862654284, 0.5130304137961217, -0.1820726765627782],
@@ -1035,7 +1035,7 @@ public function eigSymmetric() : void
      */
     public function svd() : void
     {
-        $matrix = Matrix::quick([
+        $matrix = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -1043,7 +1043,7 @@ public function svd() : void
 
         $svd = $matrix->svd();
 
-        $u = Matrix::quick([
+        $u = Matrix::fromArray([
             [-0.8436018806559158, 0.4252547343454771, -0.3278631999333884],
             [0.08179499775610413, -0.5016868397437385, -0.8611735557772425],
             [-0.5307027843302525, -0.7533052009276842, 0.38844025146657923],
@@ -1053,7 +1053,7 @@ public function svd() : void
             34.66917512262571, 17.12630582468919, 8.929610580306822,
         ];
 
-        $vT = Matrix::quick([
+        $vT = Matrix::fromArray([
             [-0.8320393250771425, 0.531457514846513, -0.15894486917903863],
             [-0.4506078135544562, -0.48043370238236727, 0.7524201326246152],
             [-0.3235168618307952, -0.6976649392999047, -0.6392186422366096],
@@ -1069,13 +1069,13 @@ public function svd() : void
      */
     public function matmul() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
         ]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -1083,7 +1083,7 @@ public function matmul() : void
 
         $c = $a->matmul($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [207], [155], [113],
         ]);
 
@@ -1095,17 +1095,17 @@ public function matmul() : void
      */
     public function dotVector() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
         ]);
 
-        $b = Vector::quick([2, 10, -1]);
+        $b = new Vector([2, 10, -1]);
 
         $c = $a->dot($b);
 
-        $expected = ColumnVector::quick([-138, 120, -11]);
+        $expected = new ColumnVector([-138, 120, -11]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
     }
@@ -1115,7 +1115,7 @@ public function dotVector() : void
      */
     public function convolve() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [3, 27, 66, 29, 42, 5],
             [5, 9, 15, 42, 45, 16],
             [1, 5, 10, 22, 66, 5],
@@ -1124,7 +1124,7 @@ public function convolve() : void
             [0, 0, 0, 5, 2, 33],
         ]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [0, 0, 1],
             [0, 1, 0],
             [1, 0, 0],
@@ -1132,7 +1132,7 @@ public function convolve() : void
 
         $c = $a->convolve($b, 1);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [3, 32, 75, 44, 84, 50],
             [32, 76, 49, 94, 72, 82],
             [10, 20, 53, 71, 91, 15],
@@ -1152,7 +1152,7 @@ public function convolve() : void
      */
     public function convolveStrideTwo() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1, 2, 3, 4, 5, 6, 7, 8],
             [9, 10, 11, 12, 13, 14, 15, 16],
             [17, 18, 19, 20, 21, 22, 23, 24],
@@ -1160,13 +1160,13 @@ public function convolveStrideTwo() : void
             [33, 34, 35, 36, 37, 38, 39, 40],
         ]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [1],
         ]);
 
         $c = $a->convolve($b, 2);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1, 3, 5, 7],
             [17, 19, 21, 23],
             [33, 35, 37, 39],
@@ -1180,7 +1180,7 @@ public function convolveStrideTwo() : void
      */
     public function convolveStrideThree() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1, 2, 3, 4, 5, 6, 7, 8],
             [9, 10, 11, 12, 13, 14, 15, 16],
             [17, 18, 19, 20, 21, 22, 23, 24],
@@ -1188,13 +1188,13 @@ public function convolveStrideThree() : void
             [33, 34, 35, 36, 37, 38, 39, 40],
         ]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [1],
         ]);
 
         $c = $a->convolve($b, 3);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1, 4, 7],
             [25, 28, 31],
         ]);
@@ -1223,17 +1223,17 @@ public function multiply(Matrix $a, $b, $expected) : void
     public function multiplyProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [88, -102, -144],
                 [4, 33, -10],
                 [-200, 6, -126],
@@ -1241,13 +1241,13 @@ public function multiplyProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [44, -170, -12],
                 [8, 110, 2],
                 [40, -60, 9],
@@ -1255,13 +1255,13 @@ public function multiplyProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [55.0, -42.5, 30.],
                 [-4, -11, 2],
                 [96.0, -28.799999999999997, -43.199999999999996],
@@ -1269,13 +1269,13 @@ public function multiplyProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             2.5,
-            Matrix::quick([
+            Matrix::fromArray([
                 [55, -42.5, 30],
                 [10.0, 27.5, -5.],
                 [50, -15, -22.5],
@@ -1304,17 +1304,17 @@ public function divide(Matrix $a, $b, $expected) : void
     public function divideProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [5.5, -2.8333333333333335, -1],
                 [4, 3.6666666666666665, -0.4],
                 [-2, 6, -0.6428571428571429],
@@ -1322,13 +1322,13 @@ public function divideProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [11, -1.7, -12],
                 [2, 1.1, 2],
                 [10, -0.6, 9],
@@ -1336,13 +1336,13 @@ public function divideProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [8.8, -6.8, 4.8],
                 [-4, -11, 2],
                 [4.166666666666667, -1.25, -1.875],
@@ -1350,13 +1350,13 @@ public function divideProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             2.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [11.0, -8.5, 6.],
                 [2.0, 5.5, -1.],
                 [10.0, -3.0, -4.5],
@@ -1385,17 +1385,17 @@ public function add(Matrix $a, $b, $expected) : void
     public function addProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [26, -11, 0],
                 [5, 14, 3],
                 [10, -7, 5],
@@ -1403,13 +1403,13 @@ public function addProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [24, -7, 11],
                 [6, 21, -3],
                 [22, 4, -10],
@@ -1417,13 +1417,13 @@ public function addProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [24.5, -14.5, 14.5],
                 [3, 10, -3],
                 [24.8, -1.2000000000000002, -4.2],
@@ -1431,13 +1431,13 @@ public function addProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             1.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [23, -16, 13],
                 [5, 12, -1],
                 [21, -5, -8],
@@ -1466,17 +1466,17 @@ public function subtract(Matrix $a, $b, $expected) : void
     public function subtractProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [18, -23, 24],
                 [3, 8, -7],
                 [30, -5, -23],
@@ -1484,13 +1484,13 @@ public function subtractProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [20, -27, 13],
                 [2, 1, -1],
                 [18, -16, -8],
@@ -1498,13 +1498,13 @@ public function subtractProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [19.5, -19.5, 9.5],
                 [5, 12, -1],
                 [15.2, -10.8, -13.8],
@@ -1512,13 +1512,13 @@ public function subtractProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             10.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [12, -27, 2],
                 [-6, 1, -12],
                 [10, -16, -19],
@@ -1547,17 +1547,17 @@ public function pow(Matrix $a, $b, $expected) : void
     public function powProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [234256, 24137569, 1.1215665478461509E-13],
                 [4, 1331, -32],
                 [9.765625E-14, -0.16666666666666666, 22876792454961],
@@ -1565,13 +1565,13 @@ public function powProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [484, 2015993900449, 0.08333333333333333],
                 [16, 25937424601, -0.5],
                 [400, 60466176, -0.1111111111111111],
@@ -1579,13 +1579,13 @@ public function powProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             3.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [10648, -4913, 1728],
                 [64, 1331, -8],
                 [8000, -216, -729],
@@ -1614,17 +1614,17 @@ public function mod(Matrix $a, $b, $expected) : void
     public function modProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [2, -5, 0],
                 [0, 2, -2],
                 [0, 0, -9],
@@ -1632,13 +1632,13 @@ public function modProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [0, -7, 0],
                 [0, 1, 0],
                 [0, -6, 0],
@@ -1646,13 +1646,13 @@ public function modProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [0,  -1,  0],
                 [0, 0, 0],
                 [0,  -2,  -1]
@@ -1660,13 +1660,13 @@ public function modProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             10.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [2, -7, 2],
                 [4, 1, -2],
                 [0, -6, -9],
@@ -1695,17 +1695,17 @@ public function equal(Matrix $a, $b, $expected) : void
     public function equalProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [0, 0, 0],
                 [0, 0, 0],
                 [0, 0, 0],
@@ -1713,13 +1713,13 @@ public function equalProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [0, 0, 0],
                 [0, 0, 0],
                 [0, 0, 0],
@@ -1727,13 +1727,13 @@ public function equalProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [0, 0, 0],
                 [0, 0, 0],
                 [0, 0, 0],
@@ -1741,13 +1741,13 @@ public function equalProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             4.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [0, 0, 0],
                 [1, 0, 0],
                 [0, 0, 0],
@@ -1776,17 +1776,17 @@ public function notEqual(Matrix $a, $b, $expected) : void
     public function notEqualProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 1, 1],
                 [1, 1, 1],
                 [1, 1, 1],
@@ -1794,13 +1794,13 @@ public function notEqualProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [1, 1, 1],
                 [1, 1, 1],
                 [1, 1, 1],
@@ -1808,13 +1808,13 @@ public function notEqualProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [1, 1, 1],
                 [1, 1, 1],
                 [1, 1, 1],
@@ -1822,13 +1822,13 @@ public function notEqualProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             4.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 1, 1],
                 [0, 1, 1],
                 [1, 1, 1],
@@ -1857,17 +1857,17 @@ public function greater(Matrix $a, $b, $expected) : void
     public function greaterProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
                 [1, 0, 0],
@@ -1875,13 +1875,13 @@ public function greaterProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
                 [1, 0, 0],
@@ -1889,13 +1889,13 @@ public function greaterProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
                 [1, 0, 0],
@@ -1903,13 +1903,13 @@ public function greaterProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             4.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 0, 1],
                 [0, 1, 0],
                 [1, 0, 0],
@@ -1938,17 +1938,17 @@ public function greaterEqual(Matrix $a, $b, $expected) : void
     public function greaterEqualProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
                 [1, 0, 0],
@@ -1956,13 +1956,13 @@ public function greaterEqualProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
                 [1, 0, 0],
@@ -1970,13 +1970,13 @@ public function greaterEqualProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
                 [1, 0, 0],
@@ -1984,13 +1984,13 @@ public function greaterEqualProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             4.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
                 [1, 0, 0],
@@ -2019,17 +2019,17 @@ public function less(Matrix $a, $b, $expected) : void
     public function lessProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
                 [0, 1, 1],
@@ -2037,13 +2037,13 @@ public function lessProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
                 [0, 1, 1],
@@ -2051,13 +2051,13 @@ public function lessProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
                 [0, 1, 1],
@@ -2065,13 +2065,13 @@ public function lessProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             10.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [0, 1, 0],
                 [1, 0, 1],
                 [0, 1, 1],
@@ -2100,17 +2100,17 @@ public function lessEqual(Matrix $a, $b, $expected) : void
     public function lessEqualProvider() : Generator
     {
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [4, 6, -12],
                 [1, 3, 5],
                 [-10, -1, 14],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
                 [0, 1, 1],
@@ -2118,13 +2118,13 @@ public function lessEqualProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::quick([2, 10, -1]),
-            Matrix::quick([
+            new Vector([2, 10, -1]),
+            Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
                 [0, 1, 1],
@@ -2132,13 +2132,13 @@ public function lessEqualProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::quick([2.5, -1, 4.8]),
-            Matrix::quick([
+            new ColumnVector([2.5, -1, 4.8]),
+            Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
                 [0, 1, 1],
@@ -2146,13 +2146,13 @@ public function lessEqualProvider() : Generator
         ];
 
         yield [
-            Matrix::quick([
+            Matrix::fromArray([
                 [22.0, -17.0, 12.0],
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
             10.0,
-            Matrix::quick([
+            Matrix::fromArray([
                 [0, 1, 0],
                 [1, 0, 1],
                 [0, 1, 1],
@@ -2165,7 +2165,7 @@ public function lessEqualProvider() : Generator
      */
     public function abs() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2173,7 +2173,7 @@ public function abs() : void
 
         $b = $a->abs();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [22, 17, 12],
             [4, 11, 2],
             [20, 6, 9],
@@ -2187,7 +2187,7 @@ public function abs() : void
      */
     public function square() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2195,7 +2195,7 @@ public function square() : void
 
         $b = $a->square();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [484, 289, 144],
             [16, 121, 4],
             [400, 36, 81],
@@ -2209,7 +2209,7 @@ public function square() : void
      */
     public function sqrt() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2217,7 +2217,7 @@ public function sqrt() : void
 
         $b = $a->sqrt();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [3.605551275463989],
             [3.3166247903554],
             [3],
@@ -2231,7 +2231,7 @@ public function sqrt() : void
      */
     public function exp() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2239,7 +2239,7 @@ public function exp() : void
 
         $b = $a->exp();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [442413.3920089205],
             [59874.14171519778],
             [8103.08392757538],
@@ -2253,7 +2253,7 @@ public function exp() : void
      */
     public function expm1() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2261,7 +2261,7 @@ public function expm1() : void
 
         $b = $a->expm1();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [442412.3920089205],
             [59873.14171519782],
             [8102.083927575384],
@@ -2275,7 +2275,7 @@ public function expm1() : void
      */
     public function log() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2283,7 +2283,7 @@ public function log() : void
 
         $b = $a->log();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [2.5649493574615367],
             [2.3978952727983707],
             [2.1972245773362196],
@@ -2297,7 +2297,7 @@ public function log() : void
      */
     public function log1p() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2305,7 +2305,7 @@ public function log1p() : void
 
         $b = $a->log1p();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [2.6390573296152584],
             [2.4849066497880004],
             [2.302585092994046],
@@ -2319,7 +2319,7 @@ public function log1p() : void
      */
     public function sin() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2327,7 +2327,7 @@ public function sin() : void
 
         $b = $a->sin();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0.4201670368266409],
             [-0.9999902065507035],
             [0.4121184852417566],
@@ -2341,7 +2341,7 @@ public function sin() : void
      */
     public function asin() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [0.32],
             [-0.5],
             [0.01],
@@ -2349,7 +2349,7 @@ public function asin() : void
 
         $b = $a->asin();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0.3257294872946302],
             [-0.5235987755982989],
             [0.010000166674167114],
@@ -2363,7 +2363,7 @@ public function asin() : void
      */
     public function cos() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2371,7 +2371,7 @@ public function cos() : void
 
         $b = $a->cos();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0.9074467814501962],
             [0.004425697988050785],
             [-0.9111302618846769],
@@ -2385,7 +2385,7 @@ public function cos() : void
      */
     public function acos() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [0.32],
             [-0.5],
             [0.01],
@@ -2393,7 +2393,7 @@ public function acos() : void
 
         $b = $a->acos();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1.2450668395002664],
             [2.0943951023931957],
             [1.5607961601207294],
@@ -2407,7 +2407,7 @@ public function acos() : void
      */
     public function tan() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2415,7 +2415,7 @@ public function tan() : void
 
         $b = $a->tan();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0.4630211329364896],
             [-225.95084645419513],
             [-0.45231565944180985],
@@ -2429,7 +2429,7 @@ public function tan() : void
      */
     public function atan() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2437,7 +2437,7 @@ public function atan() : void
 
         $b = $a->atan();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1.4940244355251187],
             [1.4801364395941514],
             [1.460139105621001],
@@ -2451,7 +2451,7 @@ public function atan() : void
      */
     public function rad2deg() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2459,7 +2459,7 @@ public function rad2deg() : void
 
         $b = $a->rad2deg();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [744.8451336700701],
             [630.2535746439056],
             [515.6620156177408],
@@ -2473,7 +2473,7 @@ public function rad2deg() : void
      */
     public function deg2rad() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -2481,7 +2481,7 @@ public function deg2rad() : void
 
         $b = $a->deg2rad();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [0.22689280275926282],
             [0.19198621771937624],
             [0.15707963267948966],
@@ -2495,7 +2495,7 @@ public function deg2rad() : void
      */
     public function sum() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2503,7 +2503,7 @@ public function sum() : void
 
         $b = $a->sum();
 
-        $expected = ColumnVector::quick([17, 13, 5]);
+        $expected = new ColumnVector([17, 13, 5]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2513,7 +2513,7 @@ public function sum() : void
      */
     public function product() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2521,7 +2521,7 @@ public function product() : void
 
         $b = $a->product();
 
-        $expected = ColumnVector::quick([-4488.0, -88.0, 1080.0]);
+        $expected = new ColumnVector([-4488.0, -88.0, 1080.0]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2531,7 +2531,7 @@ public function product() : void
      */
     public function min() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2539,7 +2539,7 @@ public function min() : void
 
         $b = $a->min();
 
-        $expected = ColumnVector::quick([-17, -2, -9]);
+        $expected = new ColumnVector([-17, -2, -9]);
 
         $this->assertEquals($expected, $b);
     }
@@ -2549,7 +2549,7 @@ public function min() : void
      */
     public function max() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2557,7 +2557,7 @@ public function max() : void
 
         $b = $a->max();
 
-        $expected = ColumnVector::quick([22, 11, 20]);
+        $expected = new ColumnVector([22, 11, 20]);
 
         $this->assertEquals($expected, $b);
     }
@@ -2567,7 +2567,7 @@ public function max() : void
      */
     public function mean() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2575,7 +2575,7 @@ public function mean() : void
 
         $b = $a->mean();
 
-        $expected = ColumnVector::quick([5.666666666666667, 4.333333333333333, 1.6666666666666667]);
+        $expected = new ColumnVector([5.666666666666667, 4.333333333333333, 1.6666666666666667]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2585,7 +2585,7 @@ public function mean() : void
      */
     public function median() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2593,7 +2593,7 @@ public function median() : void
 
         $b = $a->median();
 
-        $expected = ColumnVector::quick([12, 4, -6]);
+        $expected = new ColumnVector([12, 4, -6]);
 
         $this->assertEquals($expected, $b);
     }
@@ -2603,7 +2603,7 @@ public function median() : void
      */
     public function quantile() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2611,23 +2611,23 @@ public function quantile() : void
 
         $b = $a->quantile(0.4);
 
-        $expected = ColumnVector::quick([6.200000000000001, 2.8000000000000003, -6.6]);
+        $expected = new ColumnVector([6.200000000000001, 2.8000000000000003, -6.6]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
 
         $max = $a->quantile(1.0);
 
-        $maxExpected = ColumnVector::quick([22.0, 11.0, 20.0]);
+        $maxExpected = new ColumnVector([22.0, 11.0, 20.0]);
 
         $this->assertEqualsWithDelta($maxExpected, $max, self::MAX_DELTA);
 
-        $single = Matrix::quick([
+        $single = Matrix::fromArray([
             [5.0],
             [3.0],
             [8.0],
         ]);
 
-        $singleExpected = ColumnVector::quick([5.0, 3.0, 8.0]);
+        $singleExpected = new ColumnVector([5.0, 3.0, 8.0]);
 
         $this->assertEqualsWithDelta(
             $singleExpected,
@@ -2641,7 +2641,7 @@ public function quantile() : void
      */
     public function variance() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2649,7 +2649,7 @@ public function variance() : void
 
         $b = $a->variance();
 
-        $expected = ColumnVector::quick([273.55555555555554, 28.222222222222225, 169.55555555555554]);
+        $expected = new ColumnVector([273.55555555555554, 28.222222222222225, 169.55555555555554]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2659,14 +2659,14 @@ public function variance() : void
      */
     public function varianceRowNonSquare() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [10.0, 20.0, 30.0],
         ]);
 
         $b = $a->variance();
 
-        $expected = ColumnVector::quick([0.6666666666666666, 66.66666666666667]);
+        $expected = new ColumnVector([0.6666666666666666, 66.66666666666667]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2676,7 +2676,7 @@ public function varianceRowNonSquare() : void
      */
     public function covariance() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2684,7 +2684,7 @@ public function covariance() : void
 
         $b = $a->covariance();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [273.55555555555554, -65.55555555555556, 135.2222222222222],
             [-65.55555555555556, 28.222222222222225, 3.4444444444444406],
             [135.2222222222222, 3.4444444444444406, 169.55555555555554],
@@ -2692,14 +2692,14 @@ public function covariance() : void
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
 
-        $c = Matrix::quick([
+        $c = Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ]);
 
         $d = $c->covariance();
 
-        $expectedC = Matrix::quick([
+        $expectedC = Matrix::fromArray([
             [2.0 / 3.0, 2.0 / 3.0],
             [2.0 / 3.0, 2.0 / 3.0],
         ]);
@@ -2712,7 +2712,7 @@ public function covariance() : void
      */
     public function round() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2720,7 +2720,7 @@ public function round() : void
 
         $b = $a->round(2);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -2734,7 +2734,7 @@ public function round() : void
      */
     public function floor() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2742,7 +2742,7 @@ public function floor() : void
 
         $b = $a->floor();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -2756,7 +2756,7 @@ public function floor() : void
      */
     public function ceil() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2764,7 +2764,7 @@ public function ceil() : void
 
         $b = $a->ceil();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -2778,13 +2778,13 @@ public function ceil() : void
      */
     public function l1Norm() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
         ]);
 
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2798,7 +2798,7 @@ public function l1Norm() : void
      */
     public function l2Norm() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2812,7 +2812,7 @@ public function l2Norm() : void
      */
     public function infinityNorm() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2826,7 +2826,7 @@ public function infinityNorm() : void
      */
     public function maxNorm() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2840,7 +2840,7 @@ public function maxNorm() : void
      */
     public function clip() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2848,7 +2848,7 @@ public function clip() : void
 
         $b = $a->clip(0.0, INF);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [22, 0.0, 12],
             [4, 11, 0.],
             [20, 0.0, 0.],
@@ -2862,7 +2862,7 @@ public function clip() : void
      */
     public function clipLower() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2870,7 +2870,7 @@ public function clipLower() : void
 
         $b = $a->clipLower(5.);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [22, 5.0, 12],
             [5.0, 11, 5.],
             [20, 5.0, 5.],
@@ -2884,7 +2884,7 @@ public function clipLower() : void
      */
     public function clipUpper() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2892,7 +2892,7 @@ public function clipUpper() : void
 
         $b = $a->clipUpper(16.0);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [16.0, -17.0, 12],
             [4, 11, -2.0],
             [16, -6.0, -9.0],
@@ -2906,7 +2906,7 @@ public function clipUpper() : void
      */
     public function sign() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2914,7 +2914,7 @@ public function sign() : void
 
         $b = $a->sign();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1, -1, 1],
             [1, 1, -1],
             [1, -1, -1],
@@ -2928,7 +2928,7 @@ public function sign() : void
      */
     public function negate() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -2936,7 +2936,7 @@ public function negate() : void
 
         $b = $a->negate();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [-22, 17, -12],
             [-4, -11, 2],
             [-20, 6, 9],
@@ -2950,13 +2950,13 @@ public function negate() : void
      */
     public function augmentAbove() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
         ]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [4, 6, -12],
             [1, 3, 5],
             [-10, -1, 14],
@@ -2964,7 +2964,7 @@ public function augmentAbove() : void
 
         $c = $a->augmentAbove($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [4, 6, -12],
             [1, 3, 5],
             [-10, -1, 14],
@@ -2981,13 +2981,13 @@ public function augmentAbove() : void
      */
     public function augmentBelow() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
         ]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [4, 6, -12],
             [1, 3, 5],
             [-10, -1, 14],
@@ -2995,7 +2995,7 @@ public function augmentBelow() : void
 
         $c = $a->augmentBelow($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [22, -17, 12],
             [4, 11, -2],
             [20, -6, -9],
@@ -3012,13 +3012,13 @@ public function augmentBelow() : void
      */
     public function augmentLeft() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
         ]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -3026,7 +3026,7 @@ public function augmentLeft() : void
 
         $c = $a->augmentLeft($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [13, 22, -17, 12],
             [11, 4, 11, -2],
             [9, 20, -6, -9],
@@ -3040,13 +3040,13 @@ public function augmentLeft() : void
      */
     public function augmentRight() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
         ]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -3054,7 +3054,7 @@ public function augmentRight() : void
 
         $c = $a->augmentRight($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [22, -17, 12, 13],
             [4, 11, -2, 11],
             [20, -6, -9, 9],
@@ -3068,7 +3068,7 @@ public function augmentRight() : void
      */
     public function repeat() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [13],
             [11],
             [9],
@@ -3076,7 +3076,7 @@ public function repeat() : void
 
         $b = $a->repeat(1, 3);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [13, 13, 13, 13],
             [11, 11, 11, 11],
             [9, 9, 9, 9],
@@ -3125,7 +3125,7 @@ public function detNonSquareThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ])->det();
@@ -3138,10 +3138,10 @@ public function matmulDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
-        ])->matmul(Matrix::quick([
+        ])->matmul(Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
             [5.0, 6.0],
@@ -3155,10 +3155,10 @@ public function dotDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
-        ])->dot(Vector::quick([1.0, 2.0]));
+        ])->dot(new Vector([1.0, 2.0]));
     }
 
     /**
@@ -3168,9 +3168,9 @@ public function augmentAboveDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0],
-        ])->augmentAbove(Matrix::quick([
+        ])->augmentAbove(Matrix::fromArray([
             [1.0, 2.0, 3.0],
         ]));
     }
@@ -3182,9 +3182,9 @@ public function augmentBelowDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0],
-        ])->augmentBelow(Matrix::quick([
+        ])->augmentBelow(Matrix::fromArray([
             [1.0, 2.0, 3.0],
         ]));
     }
@@ -3196,9 +3196,9 @@ public function augmentLeftDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0],
-        ])->augmentLeft(Matrix::quick([
+        ])->augmentLeft(Matrix::fromArray([
             [1.0],
             [2.0],
             [3.0],
@@ -3212,9 +3212,9 @@ public function augmentRightDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0],
-        ])->augmentRight(Matrix::quick([
+        ])->augmentRight(Matrix::fromArray([
             [1.0],
             [2.0],
             [3.0],
@@ -3228,7 +3228,7 @@ public function offsetSetThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]);
@@ -3243,7 +3243,7 @@ public function offsetUnsetThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]);
@@ -3258,7 +3258,7 @@ public function offsetGetOutOfBoundsThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]);
@@ -3273,7 +3273,7 @@ public function luNonSquareThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ])->lu();
@@ -3286,7 +3286,7 @@ public function choleskyNonSquareThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Matrix::quick([
+        Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ])->cholesky();
@@ -3297,7 +3297,7 @@ public function choleskyNonSquareThrows() : void
      */
     public function eigReturnsEigen() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]);
@@ -3326,7 +3326,7 @@ public function eigReturnsEigen() : void
      */
     public function eigSymmetricReturnsEigen() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [9.0, 3.0],
             [3.0, 5.0],
         ]);
@@ -3343,12 +3343,12 @@ public function eigSymmetricReturnsEigen() : void
      */
     public function pseudoinversePreservesTinySingularValues() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 0.0],
             [0.0, 1e-9],
         ]);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [1.0, 0.0],
             [0.0, 1.0 / 1e-9],
         ]);
diff --git a/tests/Reductions/REFTest.php b/tests/Reductions/REFTest.php
index e7122af..fe46cd6 100644
--- a/tests/Reductions/REFTest.php
+++ b/tests/Reductions/REFTest.php
@@ -24,7 +24,7 @@ class REFTest extends TestCase
      */
     public function reduce2x2() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]);
@@ -33,7 +33,7 @@ public function reduce2x2() : void
 
         // Partial pivoting selects the largest magnitude in each column, so the
         // rows are swapped to bring 3 (col 0) to the top and 4 (col 1) to the right.
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [3.0, 4.0],
             [0.0, 2.0 / 3.0],
         ]);
@@ -47,7 +47,7 @@ public function reduce2x2() : void
      */
     public function reduce3x3() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [4.0, 11.0, -2.0],
             [20.0, -6.0, -9.0],
@@ -55,7 +55,7 @@ public function reduce3x3() : void
 
         $ref = REF::reduce($a);
 
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [22.0, -17.0, 12.0],
             [0.0, 14.09090909090909, -4.181818181818182],
             [0.0, 0.0, -17.10322580645161],
@@ -69,7 +69,7 @@ public function reduce3x3() : void
      */
     public function reduce2x3Rectangular() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
         ]);
@@ -77,7 +77,7 @@ public function reduce2x3Rectangular() : void
         $ref = REF::reduce($a);
 
         // Partial pivoting brings 4 to the top of column 0.
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [4.0, 5.0, 6.0],
             [0.0, 0.75, 1.5],
         ]);
@@ -92,7 +92,7 @@ public function reduce2x3Rectangular() : void
     public function reduceRequiresPivoting() : void
     {
         // First column is [0, 5] - a row swap is required to pivot.
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [0.0, 1.0],
             [5.0, 2.0],
         ]);
@@ -103,7 +103,7 @@ public function reduceRequiresPivoting() : void
         // should be used as the pivot, and the first row below it zeroed.
         $this->assertGreaterThanOrEqual(1, $ref->swaps());
 
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [5.0, 2.0],
             [0.0, 1.0],
         ]);
@@ -116,11 +116,11 @@ public function reduceRequiresPivoting() : void
      */
     public function reduce1x1() : void
     {
-        $a = Matrix::quick([[7.0]]);
+        $a = Matrix::fromArray([[7.0]]);
 
         $ref = REF::reduce($a);
 
-        $expectedA = Matrix::quick([[7.0]]);
+        $expectedA = Matrix::fromArray([[7.0]]);
 
         $this->assertEquals(0, $ref->swaps());
         $this->assertEqualsWithDelta($expectedA, $ref->a(), self::MAX_DELTA);
@@ -131,7 +131,7 @@ public function reduce1x1() : void
      */
     public function reduceDiagonal() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [2.0, 0.0],
             [0.0, 3.0],
         ]);
@@ -139,7 +139,7 @@ public function reduceDiagonal() : void
         $ref = REF::reduce($a);
 
         // Diagonal is already in row echelon form.
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [2.0, 0.0],
             [0.0, 3.0],
         ]);
@@ -154,7 +154,7 @@ public function reduceDiagonal() : void
     public function reduceZeroRow() : void
     {
         // One zero row at the top, non-zero row at the bottom.
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [0.0, 0.0],
             [1.0, 2.0],
         ]);
@@ -177,14 +177,14 @@ public function reduceSingularKeepsPivotScale() : void
         // A rank-1 matrix is singular: Gaussian elimination must fail and the
         // row reduction fallback must produce the same (non-normalised) REF
         // convention as Gaussian elimination - the pivot keeps its value.
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [2.0, 4.0],
             [1.0, 2.0],
         ]);
 
         $ref = REF::reduce($a);
 
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [2.0, 4.0],
             [0.0, 0.0],
         ]);
@@ -199,7 +199,7 @@ public function constructorWithNegativeSwapsThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        new REF(Matrix::quick([[1.0]]), -1);
+        new REF(Matrix::fromArray([[1.0]]), -1);
     }
 
     /**
@@ -207,7 +207,7 @@ public function constructorWithNegativeSwapsThrows() : void
      */
     public function constructorWithZeroSwaps() : void
     {
-        $a = Matrix::quick([[1.0]]);
+        $a = Matrix::fromArray([[1.0]]);
 
         $ref = new REF($a, 0);
 
@@ -220,7 +220,7 @@ public function constructorWithZeroSwaps() : void
      */
     public function constructorWithPositiveSwaps() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 0.0],
             [0.0, 1.0],
         ]);
diff --git a/tests/Reductions/RREFTest.php b/tests/Reductions/RREFTest.php
index 0aec1da..1c98028 100644
--- a/tests/Reductions/RREFTest.php
+++ b/tests/Reductions/RREFTest.php
@@ -24,7 +24,7 @@ class RREFTest extends TestCase
     public function reduceDiagonalIsIdentity() : void
     {
         // A non-singular diagonal matrix reduces to the identity.
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 0.0, 0.0],
             [0.0, 2.0, 0.0],
             [0.0, 0.0, 3.0],
@@ -32,7 +32,7 @@ public function reduceDiagonalIsIdentity() : void
 
         $rref = RREF::reduce($a);
 
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [1.0, 0.0, 0.0],
             [0.0, 1.0, 0.0],
             [0.0, 0.0, 1.0],
@@ -46,14 +46,14 @@ public function reduceDiagonalIsIdentity() : void
      */
     public function reduce2x2() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]);
 
         $rref = RREF::reduce($a);
 
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [1.0, 0.0],
             [0.0, 1.0],
         ]);
@@ -66,14 +66,14 @@ public function reduce2x2() : void
      */
     public function reduceDiagonal2x2() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [2.0, 0.0],
             [0.0, 3.0],
         ]);
 
         $rref = RREF::reduce($a);
 
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [1.0, 0.0],
             [0.0, 1.0],
         ]);
@@ -86,11 +86,11 @@ public function reduceDiagonal2x2() : void
      */
     public function reduce1x1() : void
     {
-        $a = Matrix::quick([[7.0]]);
+        $a = Matrix::fromArray([[7.0]]);
 
         $rref = RREF::reduce($a);
 
-        $this->assertEqualsWithDelta(Matrix::quick([[1.0]]), $rref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::fromArray([[1.0]]), $rref->a(), self::MAX_DELTA);
     }
 
     /**
@@ -99,14 +99,14 @@ public function reduce1x1() : void
     public function reduceSingular2x2() : void
     {
         // A rank-1 matrix has a zero row and one free variable.
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0],
             [2.0, 4.0],
         ]);
 
         $rref = RREF::reduce($a);
 
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [1.0, 2.0],
             [0.0, 0.0],
         ]);
@@ -124,14 +124,14 @@ public function reduceSingular2x2() : void
     public function reduceZeroRow() : void
     {
         // A leading zero row is swapped down; the result has a zero row.
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [0.0, 0.0],
             [1.0, 2.0],
         ]);
 
         $rref = RREF::reduce($a);
 
-        $expectedA = Matrix::quick([
+        $expectedA = Matrix::fromArray([
             [1.0, 2.0],
             [0.0, 0.0],
         ]);
@@ -144,7 +144,7 @@ public function reduceZeroRow() : void
      */
     public function rankMatchesNumberNonZeroRows() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [2.0, 4.0, 6.0],
             [4.0, 8.0, 12.0],
@@ -185,7 +185,7 @@ public function reduceExactlySingular4x4Has3NonZeroRows() : void
         // RREF must contain exactly three non-zero rows, the fourth being zero.
         // Before the float-tolerance fix, floating-point residual of ~1e-16
         // on the diagonal would cause RREF to report a fourth non-zero row.
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [2.0, 1.0, 0.0, 1.0],
             [1.0, 2.0, 1.0, 0.0],
             [0.0, 1.0, 2.0, 1.0],
@@ -222,7 +222,7 @@ public function reduceExactlySingular4x4Has3NonZeroRows() : void
      */
     public function accessorsReturnMatrices() : void
     {
-        $a = Matrix::quick([
+        $a = Matrix::fromArray([
             [1.0, 0.0, 0.0],
             [0.0, 1.0, 0.0],
             [0.0, 0.0, 1.0],
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index 52c5ea9..80ea2f9 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -36,7 +36,7 @@ class VectorTest extends TestCase
      */
     public function build() : void
     {
-        $vector = Vector::build([1, 2, 3, 4, 5]);
+        $vector = new Vector([1, 2, 3, 4, 5]);
 
         $this->assertInstanceOf(Vector::class, $vector);
         $this->assertInstanceOf(Tensor::class, $vector);
@@ -54,7 +54,7 @@ public function build() : void
      */
     public function buildCastsIntegersToFloats() : void
     {
-        $vector = Vector::build([1, 2, 3, 4, 5]);
+        $vector = new Vector([1, 2, 3, 4, 5]);
 
         $this->assertSame(5, $vector->size());
 
@@ -76,7 +76,7 @@ public function zeros() : void
     {
         $zeros = Vector::zeros(4);
 
-        $expected = Vector::quick([0, 0, 0, 0]);
+        $expected = new Vector([0, 0, 0, 0]);
 
         $this->assertEquals($expected, $zeros);
     }
@@ -88,7 +88,7 @@ public function ones() : void
     {
         $ones = Vector::ones(4);
 
-        $expected = Vector::quick([1, 1, 1, 1]);
+        $expected = new Vector([1, 1, 1, 1]);
 
         $this->assertEquals($expected, $ones);
     }
@@ -100,7 +100,7 @@ public function fill() : void
     {
         $vector = Vector::fill(16, 4);
 
-        $expected = Vector::quick([16, 16, 16, 16]);
+        $expected = new Vector([16, 16, 16, 16]);
 
         $this->assertEquals($expected, $vector);
     }
@@ -280,7 +280,7 @@ public function range() : void
     {
         $vector = Vector::range(5.0, 12.0, 2.0);
 
-        $expected = Vector::quick([5.0, 7.0, 9.0, 11.0]);
+        $expected = new Vector([5.0, 7.0, 9.0, 11.0]);
 
         $this->assertEquals($expected, $vector);
     }
@@ -292,7 +292,7 @@ public function linspace() : void
     {
         $vector = Vector::linspace(-5.0, 5.0, 10);
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             -5.0, -3.888888888888889, -2.7777777777777777, -1.6666666666666665, -0.5555555555555554,
             0.5555555555555558, 1.666666666666667, 2.777777777777778, 3.8888888888888893, 5.0,
         ]);
@@ -317,11 +317,11 @@ public function shape(Vector $vector, array $expected) : void
      */
     public function shapeProvider() : Generator
     {
-        yield [Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]), [8]];
+        yield [new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]), [8]];
 
-        yield [Vector::quick([0.25]), [1]];
+        yield [new Vector([0.25]), [1]];
 
-        yield [Vector::quick([]), [0]];
+        yield [new Vector([]), [0]];
     }
 
     /**
@@ -329,7 +329,7 @@ public function shapeProvider() : Generator
      */
     public function shapeString() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals('8', $vector->shapeString());
     }
@@ -339,7 +339,7 @@ public function shapeString() : void
      */
     public function size() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(8, $vector->size());
     }
@@ -349,7 +349,7 @@ public function size() : void
      */
     public function m() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(1, $vector->m());
     }
@@ -359,7 +359,7 @@ public function m() : void
      */
     public function n() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(8, $vector->n());
     }
@@ -369,7 +369,7 @@ public function n() : void
      */
     public function asArray() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $expected = [-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0];
 
@@ -381,11 +381,11 @@ public function asArray() : void
      */
     public function asRowMatrix() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $matrix = $vector->asRowMatrix();
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0],
         ]);
 
@@ -397,11 +397,11 @@ public function asRowMatrix() : void
      */
     public function asColumnMatrix() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $matrix = $vector->asColumnMatrix();
 
-        $expected = Matrix::quick([[-15.0], [25.0], [35.0], [-36.0], [-72.0], [89.0], [106.0], [45.0]]);
+        $expected = Matrix::fromArray([[-15.0], [25.0], [35.0], [-36.0], [-72.0], [89.0], [106.0], [45.0]]);
 
         $this->assertEquals($expected, $matrix);
     }
@@ -411,11 +411,11 @@ public function asColumnMatrix() : void
      */
     public function reshape() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $matrix = $vector->reshape(4, 2);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [-15.0, 25.0],
             [35.0, -36.0],
             [-72.0, 89.0],
@@ -430,11 +430,11 @@ public function reshape() : void
      */
     public function transpose() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $vector = $vector->transpose();
 
-        $expected = ColumnVector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $expected = new ColumnVector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals($expected, $vector);
     }
@@ -444,7 +444,7 @@ public function transpose() : void
      */
     public function map() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $sign = function ($value) {
             return $value >= 0.0 ? 1 : 0;
@@ -452,7 +452,7 @@ public function map() : void
 
         $vector = $vector->map($sign);
 
-        $expected = Vector::quick([0, 1, 1, 0, 0, 1, 1, 1]);
+        $expected = new Vector([0, 1, 1, 0, 0, 1, 1, 1]);
 
         $this->assertEquals($expected, $vector);
     }
@@ -462,7 +462,7 @@ public function map() : void
      */
     public function reduce() : void
     {
-        $vector = Vector::quick([1.0, 2.0, 3.0]);
+        $vector = new Vector([1.0, 2.0, 3.0]);
 
         $sum = function ($carry, $value) {
             return $carry + $value;
@@ -479,7 +479,7 @@ public function reduce() : void
         $this->assertEqualsWithDelta(-4.0, $vector->reduce($subtract, 2.0), self::MAX_DELTA);
 
         // Must match Matrix::reduce() for the same data and callback.
-        $matrix = Matrix::quick([[1.0, 2.0, 3.0]]);
+        $matrix = Matrix::fromArray([[1.0, 2.0, 3.0]]);
 
         $this->assertEqualsWithDelta($vector->reduce($subtract), $matrix->reduce($subtract), self::MAX_DELTA);
     }
@@ -489,11 +489,11 @@ public function reduce() : void
      */
     public function reciprocal() : void
     {
-        $vector = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $vector = $vector->reciprocal();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             -0.06666666666666667, 0.04, 0.02857142857142857, -0.027777777777777776,
             -0.013888888888888888, 0.011235955056179775, 0.009433962264150943, 0.022222222222222223,
         ]);
@@ -506,9 +506,9 @@ public function reciprocal() : void
      */
     public function dot() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = Vector::quick([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
+        $b = new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
 
         $c = $a->dot($b);
 
@@ -517,9 +517,9 @@ public function dot() : void
 
     public function matmul() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [1.1, 0.01, 6.23],
             [5.0, 2.01, -1.0],
             [-5.0, 1.0, 0.03],
@@ -530,7 +530,7 @@ public function matmul() : void
 
         $c = $a->matmul($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [622.3751, 4.634999999999993, 40.807],
         ]);
 
@@ -542,9 +542,9 @@ public function matmul() : void
      */
     public function inner() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = Vector::quick([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
+        $b = new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
 
         $c = $a->inner($b);
 
@@ -556,13 +556,13 @@ public function inner() : void
      */
     public function outer() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = Vector::quick([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
+        $b = new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
 
         $c = $a->outer($b);
 
-        $expected = Matrix::quick([
+        $expected = Matrix::fromArray([
             [-3.75, -1.5, -30.0, 7.5, 15.0, 45.0, -49.5, -30.],
             [6.25, 2.5, 50.0, -12.5, -25.0, -75.0, 82.5, 50.],
             [8.75, 3.5, 70.0, -17.5, -35.0, -105.0, 115.5, 70.],
@@ -581,13 +581,13 @@ public function outer() : void
      */
     public function convolve() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $b = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $c = $a->convolve($b, 1);
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             -60.0, 2.5, 259.0, -144.0, 40.5, 370.1, 462.20000000000005,
             10.000000000000114, 1764.3000000000002, 1625.1, 2234.7, 1378.4, 535.5,
         ]);
@@ -604,13 +604,13 @@ public function convolve() : void
      */
     public function convolveFullReadsNoOutOfBounds() : void
     {
-        $a = Vector::quick([5.0, 2.0, 7.0, 1.0, 9.0, 3.0]);
+        $a = new Vector([5.0, 2.0, 7.0, 1.0, 9.0, 3.0]);
 
-        $b = Vector::quick([1.0, 2.0, 3.0]);
+        $b = new Vector([1.0, 2.0, 3.0]);
 
         $c = $a->convolve($b, 1);
 
-        $expected = Vector::quick([5.0, 12.0, 26.0, 21.0, 32.0, 24.0, 33.0, 9.0]);
+        $expected = new Vector([5.0, 12.0, 26.0, 21.0, 32.0, 24.0, 33.0, 9.0]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
     }
@@ -620,13 +620,13 @@ public function convolveFullReadsNoOutOfBounds() : void
      */
     public function convolveStrideTwo() : void
     {
-        $a = Vector::quick([5.0, 2.0, 7.0, 1.0, 9.0, 3.0]);
+        $a = new Vector([5.0, 2.0, 7.0, 1.0, 9.0, 3.0]);
 
-        $b = Vector::quick([1.0, 2.0, 3.0]);
+        $b = new Vector([1.0, 2.0, 3.0]);
 
         $c = $a->convolve($b, 2);
 
-        $expected = Vector::quick([5.0, 26.0, 32.0, 33.0]);
+        $expected = new Vector([5.0, 26.0, 32.0, 33.0]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
     }
@@ -652,13 +652,13 @@ public function multiply(Vector $a, $b, $expected) : void
     public function multiplyProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, -0.001],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [24.92, -6.5, 0.087, -0.2, -1.3, 23.8],
                 [0.04, 13.064999999999998, 2.9, 0.4, 0.13, -11.9],
                 [4.4, 32.5, -14.5, 600.0, -0.013000000000000001, -0.0119],
@@ -666,15 +666,15 @@ public function multiplyProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([-3.75, 2.5, 70.0, 18.0, 72.0, -267.0, 349.79999999999995, 90.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([-3.75, 2.5, 70.0, 18.0, 72.0, -267.0, 349.79999999999995, 90.0]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             2.0,
-            Vector::quick([-30.0, 50.0, 70.0, -72.0, -144.0, 178.0, 212.0, 90.0]),
+            new Vector([-30.0, 50.0, 70.0, -72.0, -144.0, 178.0, 212.0, 90.0]),
         ];
     }
 
@@ -699,13 +699,13 @@ public function divide(Vector $a, $b, $expected) : void
     public function divideProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, -0.001],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [0.6420545746388443, -6.5, 96.66666666666667, -2000.0, -5.2, 5.95],
                 [400.0, 3.2338308457711444, 2.9, 1000.0, 52.0, -11.9],
                 [3.6363636363636362, 1.3, -0.58, 0.6666666666666666, -520.0, -11900.],
@@ -713,15 +713,15 @@ public function divideProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([-60.0, 250.0, 17.5, 72.0, 72.0, -29.666666666666668, 32.121212121212125, 22.5]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([-60.0, 250.0, 17.5, 72.0, 72.0, -29.666666666666668, 32.121212121212125, 22.5]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             2.0,
-            Vector::quick([-7.5, 12.5, 17.5, -18.0, -36.0, 44.5, 53, 22.5]),
+            new Vector([-7.5, 12.5, 17.5, -18.0, -36.0, 44.5, 53, 22.5]),
         ];
     }
 
@@ -746,13 +746,13 @@ public function add(Vector $a, $b, $expected) : void
     public function addProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, -0.001],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [10.23, 5.5, 2.9299999999999997, 19.99, 2.1, 13.9],
                 [4.01, 8.51, 3.9, 20.02, 2.65, 10.9],
                 [5.1, 11.5, -2.1, 50.0, 2.595, 11.899000000000001],
@@ -760,15 +760,15 @@ public function addProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([-14.75, 25.1, 37.0, -36.5, -73.0, 86.0, 109.3, 47.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([-14.75, 25.1, 37.0, -36.5, -73.0, 86.0, 109.3, 47.0]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             10.0,
-            Vector::quick([-5.0, 35.0, 45.0, -26.0, -62.0, 99.0, 116.0, 55.0]),
+            new Vector([-5.0, 35.0, 45.0, -26.0, -62.0, 99.0, 116.0, 55.0]),
         ];
     }
 
@@ -793,13 +793,13 @@ public function subtract(Vector $a, $b, $expected) : void
     public function subtractProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, -0.001],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [-2.2300000000000004, 7.5, 2.87, 20.01, 3.1, 9.9],
                 [3.99, 4.49, 1.9, 19.98, 2.5500000000000003, 12.9],
                 [2.9, 1.5, 7.9, -10.0, 2.605, 11.901],
@@ -807,15 +807,15 @@ public function subtractProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([-15.25, 24.9, 33.0, -35.5, -71.0, 92.0, 102.7, 43.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([-15.25, 24.9, 33.0, -35.5, -71.0, 92.0, 102.7, 43.0]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             10.0,
-            Vector::quick([-25.0, 15.0, 25.0, -46.0, -82.0, 79.0, 96.0, 35.0]),
+            new Vector([-25.0, 15.0, 25.0, -46.0, -82.0, 79.0, 96.0, 35.0]),
         ];
     }
 
@@ -840,13 +840,13 @@ public function power(Vector $a, $b, $expected) : void
     public function powProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, -0.001],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [5634.219287100394, 0.15384615384615385, 1.0324569211337775, 0.9704869503929601, 0.6201736729460423, 141.61],
                 [1.013959479790029, 43.048284263459465, 2.9, 1.0617459178549786, 1.0489352187366092, 0.08403361344537814],
                 [4.59479341998814, 11602.90625, 0.004875397277841432, 1.073741824E+39, 0.9952338371484033, 0.9975265256911376],
@@ -854,15 +854,15 @@ public function powProvider() : Generator
         ];
 
         yield [
-            Vector::quick([3.0, 6.0, 9.0]),
-            Vector::quick([3.0, 2.0, 1.0]),
-            Vector::quick([27.0, 36.0, 9.0]),
+            new Vector([3.0, 6.0, 9.0]),
+            new Vector([3.0, 2.0, 1.0]),
+            new Vector([27.0, 36.0, 9.0]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             4.0,
-            Vector::quick([
+            new Vector([
                 50625, 390625, 1500625, 1679616, 26873856, 62742241, 126247696, 4100625
             ]),
         ];
@@ -889,13 +889,13 @@ public function equal(Vector $a, $b, $expected) : void
     public function equalProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, 11.9],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 0, 0, 0, 0, 0],
                 [0, 0, 0, 1, 0, 0],
                 [0, 0, 0, 0, 0, 1],
@@ -903,15 +903,15 @@ public function equalProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([0, 0, 0, 1, 0, 0, 0, 0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([0, 0, 0, 1, 0, 0, 0, 0]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::quick([0, 1, 0, 0, 0, 0, 0, 0]),
+            new Vector([0, 1, 0, 0, 0, 0, 0, 0]),
         ];
     }
 
@@ -936,13 +936,13 @@ public function notEqual(Vector $a, $b, $expected) : void
     public function notEqualProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, 11.9],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [0, 1, 1, 1, 1, 1],
                 [1, 1, 1, 0, 1, 1],
                 [1, 1, 1, 1, 1, 0],
@@ -950,15 +950,15 @@ public function notEqualProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([1, 1, 1, 0, 1, 1, 1, 1]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([1, 1, 1, 0, 1, 1, 1, 1]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::quick([1, 0, 1, 1, 1, 1, 1, 1]),
+            new Vector([1, 0, 1, 1, 1, 1, 1, 1]),
         ];
     }
 
@@ -969,9 +969,9 @@ public function notEqualMatrixDimensionMismatch() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        $a = Vector::quick([1.0, 2.0, 3.0]);
+        $a = new Vector([1.0, 2.0, 3.0]);
 
-        $b = Matrix::quick([
+        $b = Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]);
@@ -1000,13 +1000,13 @@ public function greater(Vector $a, $b, $expected) : void
     public function greaterProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, 11.9],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [0, 1, 1, 1, 1, 1],
                 [1, 1, 1, 0, 1, 1],
                 [1, 1, 1, 0, 1, 0],
@@ -1014,15 +1014,15 @@ public function greaterProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([0, 1, 1, 0, 0, 1, 1, 1]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([0, 1, 1, 0, 0, 1, 1, 1]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             1.0,
-            Vector::quick([0, 1, 1, 0, 0, 1, 1, 1]),
+            new Vector([0, 1, 1, 0, 0, 1, 1, 1]),
         ];
     }
 
@@ -1047,13 +1047,13 @@ public function greaterEqual(Vector $a, $b, $expected) : void
     public function greaterEqualProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, 11.9],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 1, 1, 1, 1, 1],
                 [1, 1, 1, 1, 1, 1],
                 [1, 1, 1, 0, 1, 1],
@@ -1061,15 +1061,15 @@ public function greaterEqualProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([0, 1, 1, 1, 0, 1, 1, 1]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([0, 1, 1, 1, 0, 1, 1, 1]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::quick([0, 1, 1, 0, 0, 1, 1, 1]),
+            new Vector([0, 1, 1, 0, 0, 1, 1, 1]),
         ];
     }
 
@@ -1094,13 +1094,13 @@ public function less(Vector $a, $b, $expected) : void
     public function lessProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, 11.9],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [0, 0, 0, 0, 0, 0],
                 [0, 0, 0, 0, 0, 0],
                 [0, 0, 0, 1, 0, 0],
@@ -1108,15 +1108,15 @@ public function lessProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([1, 0, 0, 0, 1, 0, 0, 0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([1, 0, 0, 0, 1, 0, 0, 0]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::quick([1, 0, 0, 1, 1, 0, 0, 0]),
+            new Vector([1, 0, 0, 1, 1, 0, 0, 0]),
         ];
     }
 
@@ -1141,13 +1141,13 @@ public function lessEqual(Vector $a, $b, $expected) : void
     public function lessEqualProvider() : Generator
     {
         yield [
-            Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
-            Matrix::quick([
+            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
                 [1.1, 5.0, -5.0, 30, -0.005, 11.9],
             ]),
-            Matrix::quick([
+            Matrix::fromArray([
                 [1, 0, 0, 0, 0, 0],
                 [0, 0, 0, 1, 0, 0],
                 [0, 0, 0, 1, 0, 1],
@@ -1156,15 +1156,15 @@ public function lessEqualProvider() : Generator
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([1, 0, 0, 1, 1, 0, 0, 0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([1, 0, 0, 1, 1, 0, 0, 0]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::quick([1, 1, 0, 1, 1, 0, 0, 0]),
+            new Vector([1, 1, 0, 1, 1, 0, 0, 0]),
         ];
     }
 
@@ -1189,15 +1189,15 @@ public function mod(Vector $a, $b, $expected) : void
     public function modProvider() : Generator
     {
         yield [
-            Vector::quick([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::quick([0, 0, 2, 0, -1, -3, 3, 2]),
+            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([0, 0, 2, 0, -1, -3, 3, 2]),
         ];
 
         yield [
-            Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             4,
-            Vector::quick([-3, 1, 3, 0, 0, 1, 2, 1]),
+            new Vector([-3, 1, 3, 0, 0, 1, 2, 1]),
         ];
     }
 
@@ -1206,11 +1206,11 @@ public function modProvider() : Generator
      */
     public function abs() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->abs();
 
-        $expected = Vector::quick([15, 25, 35, 36, 72, 89, 106, 45]);
+        $expected = new Vector([15, 25, 35, 36, 72, 89, 106, 45]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1220,11 +1220,11 @@ public function abs() : void
      */
     public function square() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->square();
 
-        $expected = Vector::quick([225, 625, 1225, 1296, 5184, 7921, 11236, 2025]);
+        $expected = new Vector([225, 625, 1225, 1296, 5184, 7921, 11236, 2025]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -1234,11 +1234,11 @@ public function square() : void
      */
     public function pow() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->pow(3);
 
-        $expected = Vector::quick([-3375, 15625, 42875, -46656, -373248, 704969, 1191016, 91125]);
+        $expected = new Vector([-3375, 15625, 42875, -46656, -373248, 704969, 1191016, 91125]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -1248,11 +1248,11 @@ public function pow() : void
      */
     public function sqrt() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->sqrt();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             2.0, 2.5495097567963922, 1.70293863659264, 4.47213595499958,
             1.61245154965971, 3.449637662132068,
         ]);
@@ -1265,11 +1265,11 @@ public function sqrt() : void
      */
     public function exp() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->exp();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             54.598150033144236, 665.1416330443618, 18.17414536944306,
             485165195.4097903, 13.463738035001692, 147266.6252405527,
         ]);
@@ -1282,11 +1282,11 @@ public function exp() : void
      */
     public function log() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->log();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             1.3862943611198906, 1.8718021769015913, 1.0647107369924282,
             2.995732273553991, 0.9555114450274363, 2.4765384001174837,
         ]);
@@ -1299,11 +1299,11 @@ public function log() : void
      */
     public function sin() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->sin();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             -0.7568024953079282, 0.21511998808781552, 0.23924932921398243,
             0.9129452507276277, 0.5155013718214642, -0.6181371122370333,
         ]);
@@ -1316,11 +1316,11 @@ public function sin() : void
      */
     public function asin() : void
     {
-        $a = Vector::quick([0.1, 0.3, -0.5]);
+        $a = new Vector([0.1, 0.3, -0.5]);
 
         $b = $a->asin();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             0.1001674211615598, 0.3046926540153975, -0.5235987755982989,
         ]);
 
@@ -1332,11 +1332,11 @@ public function asin() : void
      */
     public function cos() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->cos();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             -0.6536436208636119, 0.9765876257280235, -0.9709581651495905,
             0.40808206181339196, -0.8568887533689473, 0.7860702961410393,
         ]);
@@ -1349,11 +1349,11 @@ public function cos() : void
      */
     public function acos() : void
     {
-        $a = Vector::quick([0.1, 0.3, -0.5]);
+        $a = new Vector([0.1, 0.3, -0.5]);
 
         $b = $a->acos();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             1.4706289056333368, 1.2661036727794992, 2.0943951023931957,
         ]);
 
@@ -1365,11 +1365,11 @@ public function acos() : void
      */
     public function tan() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->tan();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             1.1578212823495777, 0.22027720034589682, -0.24640539397196634,
             2.237160944224742, -0.6015966130897586, -0.7863636563696398,
         ]);
@@ -1382,11 +1382,11 @@ public function tan() : void
      */
     public function atan() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->atan();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             1.3258176636680326, 1.4181469983996315, 1.2387368592520112,
             1.5208379310729538, 1.2036224929766774, 1.486959684726482,
         ]);
@@ -1399,11 +1399,11 @@ public function atan() : void
      */
     public function rad2deg() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->rad2deg();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             229.1831180523293, 372.42256683503507, 166.15776058793872,
             1145.9155902616465, 148.96902673401405, 681.8197762056797,
         ]);
@@ -1416,11 +1416,11 @@ public function rad2deg() : void
      */
     public function deg2rad() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->deg2rad();
 
-        $expected = Vector::quick([
+        $expected = new Vector([
             0.06981317007977318, 0.11344640137963141, 0.05061454830783556,
             0.3490658503988659, 0.04537856055185257, 0.2076941809873252,
         ]);
@@ -1433,7 +1433,7 @@ public function deg2rad() : void
      */
     public function sum() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(177.0, $a->sum(), self::MAX_DELTA);
     }
@@ -1443,7 +1443,7 @@ public function sum() : void
      */
     public function product() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(-14442510600000.0, $a->product(), self::MAX_DELTA);
     }
@@ -1453,7 +1453,7 @@ public function product() : void
      */
     public function min() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(-72, $a->min());
     }
@@ -1463,7 +1463,7 @@ public function min() : void
      */
     public function max() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(106, $a->max());
     }
@@ -1473,7 +1473,7 @@ public function max() : void
      */
     public function mean() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(22.125, $a->mean(), self::MAX_DELTA);
     }
@@ -1483,7 +1483,7 @@ public function mean() : void
      */
     public function median() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(30.0, $a->median());
     }
@@ -1493,13 +1493,13 @@ public function median() : void
      */
     public function quantile() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(30.0, $a->quantile(0.5), self::MAX_DELTA);
         $this->assertEqualsWithDelta(-72.0, $a->quantile(0.0), self::MAX_DELTA);
         $this->assertEqualsWithDelta(106.0, $a->quantile(1.0), self::MAX_DELTA);
 
-        $single = Vector::quick([5.0]);
+        $single = new Vector([5.0]);
 
         $this->assertEqualsWithDelta(5.0, $single->quantile(0.0), self::MAX_DELTA);
         $this->assertEqualsWithDelta(5.0, $single->quantile(0.5), self::MAX_DELTA);
@@ -1511,7 +1511,7 @@ public function quantile() : void
      */
     public function variance() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(3227.609375, $a->variance(), self::MAX_DELTA);
     }
@@ -1521,11 +1521,11 @@ public function variance() : void
      */
     public function round() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->round(2);
 
-        $expected = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $expected = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -1535,11 +1535,11 @@ public function round() : void
      */
     public function floor() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->floor();
 
-        $expected = Vector::quick([4.0, 6.0, 2.0, 20.0, 2.0, 11.0]);
+        $expected = new Vector([4.0, 6.0, 2.0, 20.0, 2.0, 11.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1549,11 +1549,11 @@ public function floor() : void
      */
     public function ceil() : void
     {
-        $a = Vector::quick([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->ceil();
 
-        $expected = Vector::quick([4.0, 7.0, 3.0, 20.0, 3.0, 12.0]);
+        $expected = new Vector([4.0, 7.0, 3.0, 20.0, 3.0, 12.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1563,7 +1563,7 @@ public function ceil() : void
      */
     public function l1Norm() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(423.0, $a->l1Norm(), self::MAX_DELTA);
     }
@@ -1573,7 +1573,7 @@ public function l1Norm() : void
      */
     public function l2Norm() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(172.4441938715247, $a->l2Norm(), self::MAX_DELTA);
     }
@@ -1583,7 +1583,7 @@ public function l2Norm() : void
      */
     public function pNorm() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(135.15554088861361, $a->pNorm(3.0), self::MAX_DELTA);
     }
@@ -1593,7 +1593,7 @@ public function pNorm() : void
      */
     public function maxNorm() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(106.0, $a->maxNorm(), self::MAX_DELTA);
     }
@@ -1603,11 +1603,11 @@ public function maxNorm() : void
      */
     public function clip() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->clip(0.0, 100);
 
-        $expected = Vector::quick([0.0, 25, 35, 0.0, 0.0, 89, 100.0, 45]);
+        $expected = new Vector([0.0, 25, 35, 0.0, 0.0, 89, 100.0, 45]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1617,11 +1617,11 @@ public function clip() : void
      */
     public function clipLower() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->clipLower(60.0);
 
-        $expected = Vector::quick([60.0, 60.0, 60.0, 60.0, 60.0, 89, 106.0, 60.0]);
+        $expected = new Vector([60.0, 60.0, 60.0, 60.0, 60.0, 89, 106.0, 60.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1631,11 +1631,11 @@ public function clipLower() : void
      */
     public function clipUpper() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->clipUpper(50.0);
 
-        $expected = Vector::quick([-15.0, 25, 35, -36.0, -72.0, 50.0, 50.0, 45]);
+        $expected = new Vector([-15.0, 25, 35, -36.0, -72.0, 50.0, 50.0, 45]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1645,11 +1645,11 @@ public function clipUpper() : void
      */
     public function sign() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->sign();
 
-        $expected = Vector::quick([-1, 1, 1, -1, -1, 1, 1, 1]);
+        $expected = new Vector([-1, 1, 1, -1, -1, 1, 1, 1]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1659,11 +1659,11 @@ public function sign() : void
      */
     public function negate() : void
     {
-        $a = Vector::quick([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->negate();
 
-        $expected = Vector::quick([15, -25, -35, 36, 72, -89, -106, -45]);
+        $expected = new Vector([15, -25, -35, 36, 72, -89, -106, -45]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1765,7 +1765,7 @@ public function reshapeSizeMismatchThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Vector::quick([1.0, 2.0, 3.0, 4.0])->reshape(2, 3);
+        (new Vector([1.0, 2.0, 3.0, 4.0]))->reshape(2, 3);
     }
 
     /**
@@ -1775,7 +1775,7 @@ public function quantileOutOfRangeThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->quantile(-0.1);
+        (new Vector([1.0, 2.0, 3.0]))->quantile(-0.1);
     }
 
     /**
@@ -1785,7 +1785,7 @@ public function quantileAboveOneThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->quantile(1.1);
+        (new Vector([1.0, 2.0, 3.0]))->quantile(1.1);
     }
 
     /**
@@ -1795,7 +1795,7 @@ public function pNormNonPositiveThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->pNorm(0.0);
+        (new Vector([1.0, 2.0, 3.0]))->pNorm(0.0);
     }
 
     /**
@@ -1805,7 +1805,7 @@ public function dotDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->dot(Vector::quick([1.0, 2.0]));
+        (new Vector([1.0, 2.0, 3.0]))->dot(new Vector([1.0, 2.0]));
     }
 
     /**
@@ -1815,7 +1815,7 @@ public function multiplyDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->multiply(Vector::quick([1.0, 2.0]));
+        (new Vector([1.0, 2.0, 3.0]))->multiply(new Vector([1.0, 2.0]));
     }
 
     /**
@@ -1825,7 +1825,7 @@ public function divideDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->divide(Vector::quick([1.0, 2.0]));
+        (new Vector([1.0, 2.0, 3.0]))->divide(new Vector([1.0, 2.0]));
     }
 
     /**
@@ -1835,7 +1835,7 @@ public function addDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->add(Vector::quick([1.0, 2.0]));
+        (new Vector([1.0, 2.0, 3.0]))->add(new Vector([1.0, 2.0]));
     }
 
     /**
@@ -1845,7 +1845,7 @@ public function subtractDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->subtract(Vector::quick([1.0, 2.0]));
+        (new Vector([1.0, 2.0, 3.0]))->subtract(new Vector([1.0, 2.0]));
     }
 
     /**
@@ -1855,7 +1855,7 @@ public function powDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->pow(Vector::quick([1.0, 2.0]));
+        (new Vector([1.0, 2.0, 3.0]))->pow(new Vector([1.0, 2.0]));
     }
 
     /**
@@ -1865,7 +1865,7 @@ public function modDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->mod(Vector::quick([1.0, 2.0]));
+        (new Vector([1.0, 2.0, 3.0]))->mod(new Vector([1.0, 2.0]));
     }
 
     /**
@@ -1886,51 +1886,51 @@ public function arithmeticWithWrongOperandTypeThrows(callable $operation) : void
     public function wrongOperandTypeProvider() : Generator
     {
         yield 'multiply' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->multiply('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->multiply('not a valid operand');
         }];
 
         yield 'divide' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->divide('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->divide('not a valid operand');
         }];
 
         yield 'add' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->add('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->add('not a valid operand');
         }];
 
         yield 'subtract' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->subtract('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->subtract('not a valid operand');
         }];
 
         yield 'pow' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->pow('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->pow('not a valid operand');
         }];
 
         yield 'mod' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->mod('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->mod('not a valid operand');
         }];
 
         yield 'equal' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->equal('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->equal('not a valid operand');
         }];
 
         yield 'notEqual' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->notEqual('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->notEqual('not a valid operand');
         }];
 
         yield 'greater' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->greater('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->greater('not a valid operand');
         }];
 
         yield 'greaterEqual' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->greaterEqual('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->greaterEqual('not a valid operand');
         }];
 
         yield 'less' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->less('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->less('not a valid operand');
         }];
 
         yield 'lessEqual' => [function () {
-            Vector::quick([1.0, 2.0, 3.0])->lessEqual('not a valid operand');
+            (new Vector([1.0, 2.0, 3.0]))->lessEqual('not a valid operand');
         }];
     }
 
@@ -1941,7 +1941,7 @@ public function convolveStrideLessThanOneThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Vector::quick([1.0, 2.0, 3.0])->convolve(Vector::quick([1.0, 1.0]), 0);
+        (new Vector([1.0, 2.0, 3.0]))->convolve(new Vector([1.0, 1.0]), 0);
     }
 
     /**
@@ -1951,7 +1951,7 @@ public function convolveKernelLargerThanVectorThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        Vector::quick([1.0, 2.0])->convolve(Vector::quick([1.0, 2.0, 3.0]));
+        (new Vector([1.0, 2.0]))->convolve(new Vector([1.0, 2.0, 3.0]));
     }
 
     /**
@@ -1961,7 +1961,7 @@ public function offsetSetThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        $a = Vector::quick([1.0, 2.0, 3.0]);
+        $a = new Vector([1.0, 2.0, 3.0]);
 
         $a[0] = 4.0;
     }
@@ -1973,7 +1973,7 @@ public function offsetUnsetThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        $a = Vector::quick([1.0, 2.0, 3.0]);
+        $a = new Vector([1.0, 2.0, 3.0]);
 
         unset($a[0]);
     }
@@ -1985,7 +1985,7 @@ public function offsetGetOutOfBoundsThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        $a = Vector::quick([1.0, 2.0, 3.0]);
+        $a = new Vector([1.0, 2.0, 3.0]);
 
         $this->assertEquals(0.0, $a[10]);
     }

From b8d3406386a1eb20d534a29fea7de4651913bd3f Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Tue, 22 Sep 2026 17:08:28 -0500
Subject: [PATCH 21/51] Fix typo

---
 benchmarks/Random/GaussianVectorBench.php | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/benchmarks/Random/GaussianVectorBench.php b/benchmarks/Random/GaussianVectorBench.php
index d60fe61..2d8e993 100644
--- a/benchmarks/Random/GaussianVectorBench.php
+++ b/benchmarks/Random/GaussianVectorBench.php
@@ -7,7 +7,7 @@
 /**
  * @Groups({"Random"})
  */
-class GaussianMVectorBench
+class GaussianVectorBench
 {
     /**
      * @Subject
@@ -16,6 +16,6 @@ class GaussianMVectorBench
      */
     public function gaussian() : void
     {
-        Vector::gaussian(100000);
+        Vector::gaussian(250000);
     }
 }

From a5be5f1769170f58b913c7acab8eaee9c8f5f351 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Tue, 22 Sep 2026 17:46:20 -0500
Subject: [PATCH 22/51] Save game

---
 CHANGELOG.md                  |   1 +
 ext/tensor/matrix.zep.c       | 625 ++++++++++++++++++----------------
 ext/tensor/matrix.zep.h       |   6 -
 ext/tensor/tensorbuffer.zep.c |  95 +++++-
 ext/tensor/tensorbuffer.zep.h |   6 +
 ext/tensor/vector.zep.c       | 168 +++++++--
 tensor/matrix.zep             |  62 +---
 tensor/tensorbuffer.zep       |  25 ++
 tensor/vector.zep             |  24 +-
 9 files changed, 619 insertions(+), 393 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bdccfb2..158a102 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
     - Performance: the linear algebra operations (REF, RREF, Cholesky, LU, eigendecomposition, SVD), `rank()`, `symmetric()`, and the vector `outer()` product now read their input from, and return their output into, `TensorBuffer`s directly instead of round-tripping through PHP arrays, eliminating the intermediate array copies
     - Breaking: removed the `Vector::build()`, `Vector::quick()`, `Vector::fromTensorBuffer()`, `Matrix::build()`, `Matrix::quick()`, `Matrix::fromTensorBuffer()`, and `ColumnVector::build()`, `ColumnVector::quick()`, and `ColumnVector::fromTensorBuffer()` factory methods. Construct directly with `new Vector(...)` / `new ColumnVector(...)`, or build a `Matrix` with `Matrix::fromArray(...)` (or `new Matrix(...)` from a `TensorBuffer`)
     - Breaking: `Vector::__construct()` no longer accepts a `validate` argument; pass an array of elements (or a `TensorBuffer`) and it will be constructed directly
+    - Breaking: removed the `Matrix::fromTensorBuffers()` factory method in favor of the new `TensorBuffer::fromBuffers()` factory, which concatenates an array of `TensorBuffer`s into a single contiguous buffer
 
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 9096abe..5dd8411 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -14,12 +14,12 @@
 #include "kernel/main.h"
 #include "kernel/memory.h"
 #include "kernel/fcall.h"
-#include "kernel/array.h"
-#include "kernel/operators.h"
-#include "kernel/object.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
+#include "kernel/operators.h"
 #include "kernel/string.h"
+#include "kernel/array.h"
+#include "kernel/object.h"
 #include "math.h"
 #include "kernel/math.h"
 #include "ext/spl/spl_array.h"
@@ -66,93 +66,6 @@ ZEPHIR_INIT_CLASS(Tensor_Matrix)
 	return SUCCESS;
 }
 
-/**
- * Build a matrix by concatenating an array of TensorBuffers (each buffer
- * representing one row) into a single contiguous buffer.
- *
- * @param \Tensor\TensorBuffer[] buffers
- * @return self
- */
-PHP_METHOD(Tensor_Matrix, fromTensorBuffers)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_2 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, rows;
-	zval *buffers_param = NULL, nHat, _5, b, _11, _12, zero$$3, _0$$3, _1$$3, _3$$3, _4$$3, _6$$4, _7$$5, _8$$5, _9$$5, _10$$5;
-	zval buffers;
-
-	ZVAL_UNDEF(&buffers);
-	ZVAL_UNDEF(&nHat);
-	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_12);
-	ZVAL_UNDEF(&zero$$3);
-	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&_1$$3);
-	ZVAL_UNDEF(&_3$$3);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_6$$4);
-	ZVAL_UNDEF(&_7$$5);
-	ZVAL_UNDEF(&_8$$5);
-	ZVAL_UNDEF(&_9$$5);
-	ZVAL_UNDEF(&_10$$5);
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-		ZEPHIR_Z_PARAM_ARRAY(buffers, buffers_param)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 0, &buffers_param);
-	zephir_get_arrval(&buffers, buffers_param);
-	rows = zephir_fast_count_int(&buffers);
-	if (UNEXPECTED(rows < 1)) {
-		ZEPHIR_INIT_VAR(&zero$$3);
-		ZEPHIR_INIT_VAR(&_0$$3);
-		array_init(&_0$$3);
-		tensor_buffer_from_array(&zero$$3, &_0$$3);
-		object_init_ex(return_value, tensor_matrix_ce);
-		ZEPHIR_INIT_VAR(&_1$$3);
-		object_init_ex(&_1$$3, tensor_tensorbuffer_ce);
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", &_2, 14, &zero$$3);
-		zephir_check_call_status();
-		ZVAL_LONG(&_3$$3, 0);
-		ZVAL_LONG(&_4$$3, 0);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_1$$3, &_3$$3, &_4$$3);
-		zephir_check_call_status();
-		RETURN_MM();
-	}
-	zephir_memory_observe(&_5);
-	zephir_array_fetch_long(&_5, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 64);
-	ZEPHIR_CALL_METHOD(&nHat, &_5, "count", NULL, 0);
-	zephir_check_call_status();
-	if (UNEXPECTED(rows == 1)) {
-		zephir_memory_observe(&_6$$4);
-		zephir_array_fetch_long(&_6$$4, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 69);
-		ZEPHIR_CALL_METHOD(&b, &_6$$4, "asBuffer", NULL, 0);
-		zephir_check_call_status();
-	} else {
-		zephir_memory_observe(&_7$$5);
-		zephir_array_fetch_long(&_7$$5, &buffers, 0, PH_NOISY, "tensor/matrix.zep", 71);
-		ZVAL_LONG(&_8$$5, 1);
-		ZEPHIR_CALL_FUNCTION(&_9$$5, "array_slice", NULL, 27, &buffers, &_8$$5);
-		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&b, &_7$$5, "concat", NULL, 0, &_9$$5);
-		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_10$$5, &b, "asBuffer", NULL, 0);
-		zephir_check_call_status();
-		ZEPHIR_CPY_WRT(&b, &_10$$5);
-	}
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_INIT_VAR(&_11);
-	object_init_ex(&_11, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, &_11, "__construct", &_2, 14, &b);
-	zephir_check_call_status();
-	ZVAL_LONG(&_12, rows);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_11, &_12, &nHat);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
 /**
  * Build a new matrix from a PHP array of rows, each row being a PHP array
  * of numeric elements.
@@ -239,7 +152,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 28, &a);
+	ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 27, &a);
 	zephir_check_call_status();
 	if (UNEXPECTED(!(Z_TYPE_P(&firstRow) == IS_ARRAY))) {
 		ZEPHIR_INIT_VAR(&_5$$4);
@@ -248,7 +161,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Matrix requires an", " array of arrays.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 104);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 72);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -256,7 +169,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZVAL_LONG(&n, zephir_fast_count_int(&firstRow));
 	ZEPHIR_INIT_VAR(&flat);
 	array_init(&flat);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 128);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 96);
 	if (Z_TYPE_P(&a) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _7)
 		{
@@ -273,7 +186,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 				ZEPHIR_CONCAT_SS(&_10$$6, "Matrix requires an", " array of arrays.");
 				ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", NULL, 2, &_10$$6);
 				zephir_check_call_status();
-				zephir_throw_exception_debug(&_9$$6, "tensor/matrix.zep", 114);
+				zephir_throw_exception_debug(&_9$$6, "tensor/matrix.zep", 82);
 				ZEPHIR_MM_RESTORE();
 				return;
 			}
@@ -292,7 +205,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 				ZEPHIR_CONCAT_SSVSVS(&_16$$7, "The number of", " columns must be equal for all rows, ", &_13$$7, " needed but ", &_15$$7, " given.");
 				ZEPHIR_CALL_METHOD(NULL, &_12$$7, "__construct", NULL, 2, &_16$$7);
 				zephir_check_call_status();
-				zephir_throw_exception_debug(&_12$$7, "tensor/matrix.zep", 120);
+				zephir_throw_exception_debug(&_12$$7, "tensor/matrix.zep", 88);
 				ZEPHIR_MM_RESTORE();
 				return;
 			}
@@ -303,7 +216,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 			} else {
 				_17$$5 = &rowA;
 			}
-			zephir_is_iterable(_17$$5, 0, "tensor/matrix.zep", 126);
+			zephir_is_iterable(_17$$5, 0, "tensor/matrix.zep", 94);
 			if (Z_TYPE_P(_17$$5) == IS_ARRAY) {
 				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$5), _19$$5)
 				{
@@ -311,7 +224,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 					ZVAL_COPY(&valueA, _19$$5);
 					ZEPHIR_INIT_NVAR(&_20$$8);
 					ZVAL_DOUBLE(&_20$$8, zephir_get_doubleval(&valueA));
-					zephir_array_append(&flat, &_20$$8, PH_SEPARATE, "tensor/matrix.zep", 124);
+					zephir_array_append(&flat, &_20$$8, PH_SEPARATE, "tensor/matrix.zep", 92);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _17$$5, "rewind", NULL, 0);
@@ -333,7 +246,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 					zephir_check_call_status();
 						ZEPHIR_INIT_NVAR(&_23$$9);
 						ZVAL_DOUBLE(&_23$$9, zephir_get_doubleval(&valueA));
-						zephir_array_append(&flat, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 124);
+						zephir_array_append(&flat, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 92);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
@@ -367,7 +280,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 					ZEPHIR_CONCAT_SS(&_28$$11, "Matrix requires an", " array of arrays.");
 					ZEPHIR_CALL_METHOD(NULL, &_27$$11, "__construct", NULL, 2, &_28$$11);
 					zephir_check_call_status();
-					zephir_throw_exception_debug(&_27$$11, "tensor/matrix.zep", 114);
+					zephir_throw_exception_debug(&_27$$11, "tensor/matrix.zep", 82);
 					ZEPHIR_MM_RESTORE();
 					return;
 				}
@@ -386,7 +299,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 					ZEPHIR_CONCAT_SSVSVS(&_33$$12, "The number of", " columns must be equal for all rows, ", &_31$$12, " needed but ", &_32$$12, " given.");
 					ZEPHIR_CALL_METHOD(NULL, &_30$$12, "__construct", NULL, 2, &_33$$12);
 					zephir_check_call_status();
-					zephir_throw_exception_debug(&_30$$12, "tensor/matrix.zep", 120);
+					zephir_throw_exception_debug(&_30$$12, "tensor/matrix.zep", 88);
 					ZEPHIR_MM_RESTORE();
 					return;
 				}
@@ -397,7 +310,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 				} else {
 					_34$$10 = &rowA;
 				}
-				zephir_is_iterable(_34$$10, 0, "tensor/matrix.zep", 126);
+				zephir_is_iterable(_34$$10, 0, "tensor/matrix.zep", 94);
 				if (Z_TYPE_P(_34$$10) == IS_ARRAY) {
 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_34$$10), _36$$10)
 					{
@@ -405,7 +318,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 						ZVAL_COPY(&valueA, _36$$10);
 						ZEPHIR_INIT_NVAR(&_37$$13);
 						ZVAL_DOUBLE(&_37$$13, zephir_get_doubleval(&valueA));
-						zephir_array_append(&flat, &_37$$13, PH_SEPARATE, "tensor/matrix.zep", 124);
+						zephir_array_append(&flat, &_37$$13, PH_SEPARATE, "tensor/matrix.zep", 92);
 					} ZEND_HASH_FOREACH_END();
 				} else {
 					ZEPHIR_CALL_METHOD(NULL, _34$$10, "rewind", NULL, 0);
@@ -427,7 +340,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 						zephir_check_call_status();
 							ZEPHIR_INIT_NVAR(&_40$$14);
 							ZVAL_DOUBLE(&_40$$14, zephir_get_doubleval(&valueA));
-							zephir_array_append(&flat, &_40$$14, PH_SEPARATE, "tensor/matrix.zep", 124);
+							zephir_array_append(&flat, &_40$$14, PH_SEPARATE, "tensor/matrix.zep", 92);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
@@ -486,7 +399,7 @@ PHP_METHOD(Tensor_Matrix, identity)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 144);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 112);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -532,10 +445,10 @@ PHP_METHOD(Tensor_Matrix, identity)
 						ZEPHIR_INIT_NVAR(&_10$$5);
 						ZVAL_DOUBLE(&_10$$5, 0.0);
 					}
-					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 156);
+					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 124);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 159);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 127);
 		}
 	}
 	ZVAL_BOOL(&_11, 0);
@@ -637,7 +550,7 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 	zephir_fetch_params(1, 1, 0, &elements_param);
 	zephir_get_arrval(&elements, elements_param);
 	n = zephir_fast_count_int(&elements);
-	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 29, &elements);
+	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 28, &elements);
 	zephir_check_call_status();
 	ZEPHIR_CPY_WRT(&elements, &_0);
 	ZEPHIR_INIT_VAR(&a);
@@ -677,15 +590,15 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 					ZEPHIR_INIT_NVAR(&_7$$4);
 					if (i == j) {
 						ZEPHIR_OBS_NVAR(&_7$$4);
-						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 213);
+						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 181);
 					} else {
 						ZEPHIR_INIT_NVAR(&_7$$4);
 						ZVAL_DOUBLE(&_7$$4, 0.0);
 					}
-					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 213);
+					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 181);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 216);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 184);
 		}
 	}
 	ZVAL_BOOL(&_8, 0);
@@ -743,7 +656,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 235);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 203);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -757,7 +670,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 240);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 208);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -823,7 +736,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 258);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 226);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -837,7 +750,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 263);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 231);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -862,9 +775,9 @@ PHP_METHOD(Tensor_Matrix, rand)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_12$$6);
 			ZVAL_DOUBLE(&_12$$6, zephir_safe_div_zval_long(&_10$$6, max));
-			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 275);
+			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 243);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 278);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 246);
 	}
 	ZVAL_BOOL(&_13, 0);
 	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_13);
@@ -928,7 +841,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 296);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 264);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -942,7 +855,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 301);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 269);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -966,7 +879,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZEPHIR_CALL_FUNCTION(&_10$$6, "array_pop", &_11, 9, &extras);
 			ZEPHIR_UNREF(&extras);
 			zephir_check_call_status();
-			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 316);
+			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 284);
 		}
 		while (1) {
 			if (!(zephir_fast_count_int(&rowA) < n)) {
@@ -985,20 +898,20 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 			ZVAL_DOUBLE(&_18$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * sin(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 324);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 292);
 			ZVAL_DOUBLE(&_20$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * cos(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 325);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 293);
 		}
 		if (zephir_fast_count_int(&rowA) > n) {
 			ZEPHIR_MAKE_REF(&rowA);
 			ZEPHIR_CALL_FUNCTION(&_21$$8, "array_pop", &_11, 9, &rowA);
 			ZEPHIR_UNREF(&rowA);
 			zephir_check_call_status();
-			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 329);
+			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 297);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 332);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 300);
 	}
 	ZVAL_BOOL(&_22, 0);
 	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_22);
@@ -1070,7 +983,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 351);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 319);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1084,7 +997,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 356);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 324);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1098,7 +1011,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_12$$5, "Lambda must be", " greater than or equal to 0, ", &_11$$5, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 2, &_12$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 361);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 329);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1144,9 +1057,9 @@ PHP_METHOD(Tensor_Matrix, poisson)
 			}
 			ZEPHIR_INIT_NVAR(&_21$$8);
 			ZVAL_DOUBLE(&_21$$8, (k - 1.0));
-			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 390);
+			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 358);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 393);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 361);
 	}
 	ZVAL_BOOL(&_16, 0);
 	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_16);
@@ -1203,7 +1116,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 411);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 379);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1217,7 +1130,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 416);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 384);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1244,9 +1157,9 @@ PHP_METHOD(Tensor_Matrix, uniform)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_14$$6);
 			ZVAL_DOUBLE(&_14$$6, zephir_safe_div_zval_long(&_12$$6, max));
-			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 428);
+			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 396);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 431);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 399);
 	}
 	ZVAL_BOOL(&_15, 0);
 	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_15);
@@ -1496,7 +1409,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Row offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 523);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 491);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1567,7 +1480,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Column offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 540);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 508);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1632,7 +1545,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 556);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 524);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1740,7 +1653,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 601);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 569);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -1748,7 +1661,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 598);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 566);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -1770,7 +1683,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 598);
+				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 566);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -1869,7 +1782,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 637);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 605);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -1879,7 +1792,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 			object_init_ex(&_7$$4, tensor_vector_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", &_8, 5, &rowBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 634);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 602);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -1903,7 +1816,7 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 				object_init_ex(&_11$$5, tensor_vector_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_11$$5, "__construct", &_8, 5, &rowBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 634);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 602);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -1975,7 +1888,7 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 656);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 624);
 		}
 	}
 	RETURN_CTOR(&b);
@@ -2027,7 +1940,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 681);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 649);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -2037,7 +1950,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			object_init_ex(&_5$$4, tensor_columnvector_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_6, 5, &columnBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 678);
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 646);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -2061,7 +1974,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 				object_init_ex(&_9$$5, tensor_columnvector_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", &_6, 5, &columnBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 678);
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 646);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&columnBuffer);
@@ -2253,9 +2166,9 @@ PHP_METHOD(Tensor_Matrix, transpose)
 		RETURN_MM();
 	}
 	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 746);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 714);
 	ZVAL_LONG(&_3, 1);
-	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 27, &cols, &_3);
+	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 29, &cols, &_3);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_2, &col, "concat", NULL, 0, &_4);
 	zephir_check_call_status();
@@ -2318,7 +2231,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 763);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 731);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2331,7 +2244,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 30, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 768);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 736);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2346,7 +2259,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 30, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 775);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 743);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2406,7 +2319,7 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 30, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 792);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 760);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2456,7 +2369,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 808);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 776);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2665,7 +2578,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 876);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 844);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2740,7 +2653,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 896);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 864);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2838,7 +2751,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 2, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 914);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 882);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2852,7 +2765,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 2, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 919);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 887);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3189,7 +3102,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1063);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1031);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3260,7 +3173,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1096);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1064);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3332,7 +3245,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1130);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1098);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3404,7 +3317,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1164);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1132);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3476,7 +3389,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1198);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1166);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3548,7 +3461,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1232);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1200);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3620,7 +3533,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1266);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1234);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3692,7 +3605,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1300);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1268);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3764,7 +3677,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1334);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1302);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3836,7 +3749,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1368);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1336);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3908,7 +3821,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1402);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1370);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3980,7 +3893,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1436);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1404);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4702,7 +4615,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1622);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1590);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4710,7 +4623,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1619);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1587);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4732,7 +4645,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1619);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1587);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4789,7 +4702,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1640);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1608);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4797,7 +4710,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1637);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1605);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4819,7 +4732,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1637);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1605);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4876,7 +4789,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1658);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1626);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4884,7 +4797,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1655);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1623);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4906,7 +4819,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1655);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1623);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4963,7 +4876,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1676);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1644);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4971,7 +4884,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1673);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1641);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4993,7 +4906,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1673);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1641);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5098,7 +5011,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1715);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1683);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5122,7 +5035,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1712);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1680);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5160,7 +5073,7 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1712);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1680);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5247,7 +5160,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1729);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1697);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5268,7 +5181,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1757);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1725);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5284,7 +5197,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1747);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1715);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5296,7 +5209,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1754);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1722);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5326,7 +5239,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1747);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1715);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5338,7 +5251,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1754);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1722);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5414,7 +5327,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1773);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1741);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5434,7 +5347,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 2, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1779);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1747);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5523,7 +5436,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 2, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1804);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1772);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5555,7 +5468,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_17 = NULL, *_20 = NULL, *_25 = NULL, *_28 = NULL;
-	zval *precision_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, rowA, valueA, _9, _10, _11, *_12, _13, *_14, _21, _15$$5, _16$$6, _18$$6, _19$$6, _23$$7, _24$$8, _26$$8, _27$$8;
+	zval *precision_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, rowA, valueA, _9, _10, _11, *_12, _13, *_14, _21, _29, _30, _31, _15$$5, _16$$6, _18$$6, _19$$6, _23$$7, _24$$8, _26$$8, _27$$8;
 	zend_long precision, ZEPHIR_LAST_CALL_STATUS, i = 0;
 	zval *this_ptr = getThis();
 
@@ -5575,6 +5488,9 @@ PHP_METHOD(Tensor_Matrix, round)
 	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_13);
 	ZVAL_UNDEF(&_21);
+	ZVAL_UNDEF(&_29);
+	ZVAL_UNDEF(&_30);
+	ZVAL_UNDEF(&_31);
 	ZVAL_UNDEF(&_15$$5);
 	ZVAL_UNDEF(&_16$$6);
 	ZVAL_UNDEF(&_18$$6);
@@ -5630,7 +5546,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1832);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1800);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5647,7 +5563,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_12 = &_10;
 	}
-	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1855);
+	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1823);
 	if (Z_TYPE_P(_12) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
 		{
@@ -5670,7 +5586,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1852);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1820);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
@@ -5707,11 +5623,16 @@ PHP_METHOD(Tensor_Matrix, round)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1852);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1820);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &b);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_29, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &b);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_30, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_31, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_29, &_30, &_31);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5855,7 +5776,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1891);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1859);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6132,7 +6053,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1957);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1925);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6230,7 +6151,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1977);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1945);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6269,7 +6190,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_16 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _12, _13;
-	zval *b, b_sub, _0, _2, _3, i, bufferB, bufferA, _10, _4$$3, _5$$3, _7$$3, _14$$4, _15$$4, _17$$4, _18$$4, _19$$4, _20$$4, _21$$4;
+	zval *b, b_sub, _0, _2, _3, i, bufferB, bufferA, _10, _23, _24, _25, _26, _27, _4$$3, _5$$3, _7$$3, _14$$4, _15$$4, _17$$4, _18$$4, _19$$4, _20$$4, _21$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -6280,6 +6201,11 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 	ZVAL_UNDEF(&bufferB);
 	ZVAL_UNDEF(&bufferA);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_23);
+	ZVAL_UNDEF(&_24);
+	ZVAL_UNDEF(&_25);
+	ZVAL_UNDEF(&_26);
+	ZVAL_UNDEF(&_27);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -6335,7 +6261,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1997);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1965);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6378,10 +6304,19 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2011);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1979);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_23, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_24, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_25, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_26, b, "n", &_16, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&_27);
+	zephir_add_function(&_27, &_25, &_26);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_23, &_24, &_27);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6401,7 +6336,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_19 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _12, _13;
-	zval *b, b_sub, _0, _2, _3, i, bufferA, bufferB, _10, _4$$3, _5$$3, _7$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _20$$4, _21$$4;
+	zval *b, b_sub, _0, _2, _3, i, bufferA, bufferB, _10, _23, _24, _25, _26, _27, _4$$3, _5$$3, _7$$3, _14$$4, _15$$4, _16$$4, _17$$4, _18$$4, _20$$4, _21$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -6412,6 +6347,11 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 	ZVAL_UNDEF(&bufferA);
 	ZVAL_UNDEF(&bufferB);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_23);
+	ZVAL_UNDEF(&_24);
+	ZVAL_UNDEF(&_25);
+	ZVAL_UNDEF(&_26);
+	ZVAL_UNDEF(&_27);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -6467,7 +6407,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2029);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1997);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6510,10 +6450,19 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2043);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2011);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_23, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_24, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_25, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_26, b, "n", &_19, 0);
+	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&_27);
+	zephir_add_function(&_27, &_25, &_26);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_23, &_24, &_27);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6589,7 +6538,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2067);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2035);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -6598,7 +6547,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2065);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2033);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -6621,16 +6570,16 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2065);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2033);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2070);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2038);
 		ZVAL_LONG(&_13$$6, 1);
-		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 27, &bigRows, &_13$$6);
+		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 29, &bigRows, &_13$$6);
 		zephir_check_call_status();
 		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "concat", NULL, 0, &_14$$6);
 		zephir_check_call_status();
@@ -6716,7 +6665,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2093);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2061);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6792,7 +6741,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2112);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2080);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6868,7 +6817,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2131);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2099);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6944,7 +6893,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2150);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2118);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7021,7 +6970,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2170);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2138);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7098,7 +7047,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2190);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2158);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7175,7 +7124,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2210);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2178);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7251,7 +7200,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2229);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2197);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7328,7 +7277,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2249);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2217);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7405,7 +7354,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2269);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2237);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7481,7 +7430,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2288);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2256);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7557,7 +7506,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2307);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2275);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7587,7 +7536,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -7596,6 +7545,9 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -7643,7 +7595,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2327);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2295);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7676,10 +7628,15 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_multiply(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2337);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2305);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7698,7 +7655,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -7707,6 +7664,9 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -7754,7 +7714,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2355);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2323);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7787,10 +7747,15 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_divide(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2365);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2333);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7809,7 +7774,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -7818,6 +7783,9 @@ PHP_METHOD(Tensor_Matrix, addVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -7865,7 +7833,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2383);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2351);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7898,10 +7866,15 @@ PHP_METHOD(Tensor_Matrix, addVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_add(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2393);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2361);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7920,7 +7893,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -7929,6 +7902,9 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -7976,7 +7952,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2411);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2379);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8009,10 +7985,15 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_subtract(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2421);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2389);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8031,7 +8012,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -8040,6 +8021,9 @@ PHP_METHOD(Tensor_Matrix, powVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -8087,7 +8071,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2439);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2407);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8120,10 +8104,15 @@ PHP_METHOD(Tensor_Matrix, powVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_pow(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2449);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2417);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8142,7 +8131,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -8151,6 +8140,9 @@ PHP_METHOD(Tensor_Matrix, modVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -8198,7 +8190,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2467);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2435);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8231,10 +8223,15 @@ PHP_METHOD(Tensor_Matrix, modVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_mod(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2477);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2445);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8254,7 +8251,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -8263,6 +8260,9 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -8310,7 +8310,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2496);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2464);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8343,10 +8343,15 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2506);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2474);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8365,7 +8370,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -8374,6 +8379,9 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -8421,7 +8429,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2524);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2492);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8454,10 +8462,15 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_not_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2534);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2502);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8476,7 +8489,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -8485,6 +8498,9 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -8532,7 +8548,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2552);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2520);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8565,10 +8581,15 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2562);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2530);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8587,7 +8608,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -8596,6 +8617,9 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -8643,7 +8667,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2580);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2548);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8676,10 +8700,15 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_greater_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2590);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2558);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8698,7 +8727,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -8707,6 +8736,9 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -8754,7 +8786,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2608);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2576);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8787,10 +8819,15 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2618);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2586);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8810,7 +8847,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -8819,6 +8856,9 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_17);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -8866,7 +8906,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2637);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2605);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8899,10 +8939,15 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
 			zephir_check_call_status();
 			tensor_less_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2647);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2615);
 		}
 	}
-	ZEPHIR_RETURN_CALL_SELF("fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8972,7 +9017,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2665);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2633);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9055,7 +9100,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2688);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2656);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9138,7 +9183,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2711);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2679);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9221,7 +9266,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2734);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2702);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9304,7 +9349,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2757);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2725);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9387,7 +9432,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2780);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2748);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9470,7 +9515,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2803);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2771);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9553,7 +9598,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2826);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2794);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9636,7 +9681,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2849);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2817);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9719,7 +9764,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2872);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2840);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9802,7 +9847,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2895);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2863);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9885,7 +9930,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2918);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2886);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10549,7 +10594,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3102);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3070);
 	return;
 }
 
@@ -10600,7 +10645,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3126);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3094);
 	return;
 }
 
@@ -10660,7 +10705,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3140);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3108);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10677,7 +10722,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3145);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3113);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index 7b340bd..c39edd0 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -3,7 +3,6 @@ extern zend_class_entry *tensor_matrix_ce;
 
 ZEPHIR_INIT_CLASS(Tensor_Matrix);
 
-PHP_METHOD(Tensor_Matrix, fromTensorBuffers);
 PHP_METHOD(Tensor_Matrix, fromArray);
 PHP_METHOD(Tensor_Matrix, identity);
 PHP_METHOD(Tensor_Matrix, zeros);
@@ -161,10 +160,6 @@ PHP_METHOD(Tensor_Matrix, offsetUnset);
 PHP_METHOD(Tensor_Matrix, offsetGet);
 PHP_METHOD(Tensor_Matrix, getIterator);
 
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromtensorbuffers, 0, 1, Tensor\\Matrix, 0)
-	ZEND_ARG_ARRAY_INFO(0, buffers, 0)
-ZEND_END_ARG_INFO()
-
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromarray, 0, 1, Tensor\\Matrix, 0)
 	ZEND_ARG_ARRAY_INFO(0, a, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
@@ -749,7 +744,6 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_getiterator, 0, 0,
 ZEND_END_ARG_INFO()
 
 ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
-	PHP_ME(Tensor_Matrix, fromTensorBuffers, arginfo_tensor_matrix_fromtensorbuffers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, fromArray, arginfo_tensor_matrix_fromarray, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, identity, arginfo_tensor_matrix_identity, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, zeros, arginfo_tensor_matrix_zeros, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 7896e5f..40385f5 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -67,6 +67,73 @@ PHP_METHOD(Tensor_TensorBuffer, __construct)
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 20, buffer);
 }
 
+/**
+ * Build a buffer by concatenating an array of buffers into a single
+ * contiguous buffer.
+ *
+ * @param \Tensor\TensorBuffer[] buffers
+ * @return self
+ */
+PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, rows;
+	zval *buffers_param = NULL, b, _3, _4, _5, _6, zero$$3, _0$$3, _1$$4, _2$$4;
+	zval buffers;
+
+	ZVAL_UNDEF(&buffers);
+	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&zero$$3);
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_1$$4);
+	ZVAL_UNDEF(&_2$$4);
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		ZEPHIR_Z_PARAM_ARRAY(buffers, buffers_param)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &buffers_param);
+	zephir_get_arrval(&buffers, buffers_param);
+	rows = zephir_fast_count_int(&buffers);
+	if (UNEXPECTED(rows < 1)) {
+		ZEPHIR_INIT_VAR(&zero$$3);
+		ZEPHIR_INIT_VAR(&_0$$3);
+		array_init(&_0$$3);
+		tensor_buffer_from_array(&zero$$3, &_0$$3);
+		object_init_ex(return_value, tensor_tensorbuffer_ce);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &zero$$3);
+		zephir_check_call_status();
+		RETURN_MM();
+	}
+	if (UNEXPECTED(rows == 1)) {
+		object_init_ex(return_value, tensor_tensorbuffer_ce);
+		zephir_memory_observe(&_1$$4);
+		zephir_array_fetch_long(&_1$$4, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 49);
+		ZEPHIR_CALL_METHOD(&_2$$4, &_1$$4, "asBuffer", NULL, 0);
+		zephir_check_call_status();
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_2$$4);
+		zephir_check_call_status();
+		RETURN_MM();
+	}
+	zephir_memory_observe(&_3);
+	zephir_array_fetch_long(&_3, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 52);
+	ZVAL_LONG(&_4, 1);
+	ZEPHIR_CALL_FUNCTION(&_5, "array_slice", NULL, 29, &buffers, &_4);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&b, &_3, "concat", NULL, 0, &_5);
+	zephir_check_call_status();
+	object_init_ex(return_value, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(&_6, &b, "asBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_6);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
 /**
  * Return the underlying buffer.
  *
@@ -184,7 +251,7 @@ PHP_METHOD(Tensor_TensorBuffer, get)
 	zephir_fetch_params(1, 1, 0, &index_param);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
 	zephir_memory_observe(&_1);
-	zephir_array_fetch_long(&_1, &_0, index, PH_NOISY, "tensor/tensorbuffer.zep", 80);
+	zephir_array_fetch_long(&_1, &_0, index, PH_NOISY, "tensor/tensorbuffer.zep", 105);
 	RETURN_CCTOR(&_1);
 }
 
@@ -315,7 +382,7 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 		ZEPHIR_CONCAT_SS(&_5$$3, "Offset and length", " must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 118);
+		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 143);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -380,7 +447,7 @@ PHP_METHOD(Tensor_TensorBuffer, map)
 	} else {
 		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/tensorbuffer.zep", 146);
+	zephir_is_iterable(_1, 0, "tensor/tensorbuffer.zep", 171);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -388,7 +455,7 @@ PHP_METHOD(Tensor_TensorBuffer, map)
 			ZVAL_COPY(&value, _3);
 			ZEPHIR_CALL_ZVAL_FUNCTION(&_4$$3, callback, NULL, 0, &value);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 143);
+			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 168);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -410,7 +477,7 @@ PHP_METHOD(Tensor_TensorBuffer, map)
 			zephir_check_call_status();
 				ZEPHIR_CALL_ZVAL_FUNCTION(&_7$$4, callback, NULL, 0, &value);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 143);
+				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 168);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&value);
@@ -608,7 +675,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 		ZEPHIR_CONCAT_SS(&_7$$3, "Offset, length, and", " stride must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_6$$3, "tensor/tensorbuffer.zep", 225);
+		zephir_throw_exception_debug(&_6$$3, "tensor/tensorbuffer.zep", 250);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -662,7 +729,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_get_arrval(&buffers, buffers_param);
 	ZEPHIR_INIT_VAR(&unwrapped);
 	array_init(&unwrapped);
-	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 250);
+	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 275);
 	if (Z_TYPE_P(&buffers) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&buffers), _0)
 		{
@@ -670,7 +737,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			ZVAL_COPY(&buffer, _0);
 			ZEPHIR_CALL_METHOD(&_1$$3, &buffer, "asBuffer", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 247);
+			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 272);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, &buffers, "rewind", NULL, 0);
@@ -692,7 +759,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_4$$4, &buffer, "asBuffer", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 247);
+				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 272);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -757,7 +824,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Chunk length must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 267);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 292);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -774,7 +841,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 	} else {
 		_6 = &buffers;
 	}
-	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 280);
+	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 305);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -784,7 +851,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 14, &buffer);
 			zephir_check_call_status();
-			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 277);
+			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 302);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -808,7 +875,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 14, &buffer);
 				zephir_check_call_status();
-				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 277);
+				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 302);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -858,7 +925,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Times must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 295);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 320);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/tensorbuffer.zep.h b/ext/tensor/tensorbuffer.zep.h
index f71e676..d312d3f 100644
--- a/ext/tensor/tensorbuffer.zep.h
+++ b/ext/tensor/tensorbuffer.zep.h
@@ -4,6 +4,7 @@ extern zend_class_entry *tensor_tensorbuffer_ce;
 ZEPHIR_INIT_CLASS(Tensor_TensorBuffer);
 
 PHP_METHOD(Tensor_TensorBuffer, __construct);
+PHP_METHOD(Tensor_TensorBuffer, fromBuffers);
 PHP_METHOD(Tensor_TensorBuffer, asBuffer);
 PHP_METHOD(Tensor_TensorBuffer, count);
 PHP_METHOD(Tensor_TensorBuffer, type);
@@ -28,6 +29,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_tensorbuffer___construct, 0, 0, 1)
 	ZEND_ARG_OBJ_INFO(0, buffer, Tensor\\Buffer, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_frombuffers, 0, 1, Tensor\\TensorBuffer, 0)
+	ZEND_ARG_ARRAY_INFO(0, buffers, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_asbuffer, 0, 0, Tensor\\Buffer, 0)
 ZEND_END_ARG_INFO()
 
@@ -102,6 +107,7 @@ ZEND_END_ARG_INFO()
 
 ZEPHIR_INIT_FUNCS(tensor_tensorbuffer_method_entry) {
 	PHP_ME(Tensor_TensorBuffer, __construct, arginfo_tensor_tensorbuffer___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
+	PHP_ME(Tensor_TensorBuffer, fromBuffers, arginfo_tensor_tensorbuffer_frombuffers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_TensorBuffer, asBuffer, arginfo_tensor_tensorbuffer_asbuffer, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, count, arginfo_tensor_tensorbuffer_count, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, type, arginfo_tensor_tensorbuffer_type, ZEND_ACC_PUBLIC)
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 6065c29..e3b4ebf 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -3522,7 +3522,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -3532,6 +3532,9 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -3625,7 +3628,14 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3644,7 +3654,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -3654,6 +3664,9 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -3747,7 +3760,14 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3766,7 +3786,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -3776,6 +3796,9 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -3869,7 +3892,14 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3888,7 +3918,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -3898,6 +3928,9 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -3991,7 +4024,14 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4010,7 +4050,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -4020,6 +4060,9 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4113,7 +4156,14 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4132,7 +4182,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -4142,6 +4192,9 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4235,7 +4288,14 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4254,7 +4314,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -4264,6 +4324,9 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4357,7 +4420,14 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4376,7 +4446,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -4386,6 +4456,9 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4479,7 +4552,14 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4498,7 +4578,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -4508,6 +4588,9 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4601,7 +4684,14 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4620,7 +4710,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -4630,6 +4720,9 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4723,7 +4816,14 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4742,7 +4842,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -4752,6 +4852,9 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4845,7 +4948,14 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4864,7 +4974,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -4874,6 +4984,9 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_18);
+	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4967,7 +5080,14 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_matrix_ce, "fromTensorBuffers", NULL, 0, &c);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 582b66b..2c3ba3b 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -43,38 +43,6 @@ class Matrix implements Tensor
      */
     protected n;
 
-    /**
-     * Build a matrix by concatenating an array of TensorBuffers (each buffer
-     * representing one row) into a single contiguous buffer.
-     *
-     * @param \Tensor\TensorBuffer[] buffers
-     * @return self
-     */
-    public static function fromTensorBuffers(const array buffers) -> <Matrix>
-    {
-        int rows = count(buffers);
-
-        if unlikely rows < 1 {
-            var zero = tensor_buffer_from_array([]);
-            return new self(new TensorBuffer(<Buffer> zero), 0, 0);
-        }
-
-        var nHat;
-
-        let nHat = buffers[0]->count();
-
-        var b;
-
-        if unlikely rows == 1 {
-            let b = buffers[0]->asBuffer();
-        } else {
-            let b = buffers[0]->concat(array_slice(buffers, 1));
-            let b = b->asBuffer();
-        }
-
-        return new self(new TensorBuffer(<Buffer> b), rows, nHat);
-    }
-
     /**
      * Build a new matrix from a PHP array of rows, each row being a PHP array
      * of numeric elements.
@@ -1852,7 +1820,7 @@ class Matrix implements Tensor
             let b[] = rowA;
         }
 
-        return self::fromTensorBuffers(b);
+        return new self(TensorBuffer::fromBuffers(b), this->m, this->n);
     }
 
     /**
@@ -2011,7 +1979,7 @@ class Matrix implements Tensor
             let c[] = bufferB->concat([bufferA]);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n + b->n());
     }
 
     /**
@@ -2043,7 +2011,7 @@ class Matrix implements Tensor
             let c[] = bufferA->concat([bufferB]);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n + b->n());
     }
 
     /**
@@ -2337,7 +2305,7 @@ class Matrix implements Tensor
             let c[] = tensor_multiply(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2365,7 +2333,7 @@ class Matrix implements Tensor
             let c[] = tensor_divide(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2393,7 +2361,7 @@ class Matrix implements Tensor
             let c[] = tensor_add(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2421,7 +2389,7 @@ class Matrix implements Tensor
             let c[] = tensor_subtract(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2449,7 +2417,7 @@ class Matrix implements Tensor
             let c[] = tensor_pow(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2477,7 +2445,7 @@ class Matrix implements Tensor
             let c[] = tensor_mod(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2506,7 +2474,7 @@ class Matrix implements Tensor
             let c[] = tensor_equal(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2534,7 +2502,7 @@ class Matrix implements Tensor
             let c[] = tensor_not_equal(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2562,7 +2530,7 @@ class Matrix implements Tensor
             let c[] = tensor_greater(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2590,7 +2558,7 @@ class Matrix implements Tensor
             let c[] = tensor_greater_equal(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2618,7 +2586,7 @@ class Matrix implements Tensor
             let c[] = tensor_less(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
@@ -2647,7 +2615,7 @@ class Matrix implements Tensor
             let c[] = tensor_less_equal(this->a->slice(i * this->n, this->n), bHat);
         }
 
-        return self::fromTensorBuffers(c);
+        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
     }
 
     /**
diff --git a/tensor/tensorbuffer.zep b/tensor/tensorbuffer.zep
index 9be8a20..0ac1118 100644
--- a/tensor/tensorbuffer.zep
+++ b/tensor/tensorbuffer.zep
@@ -29,6 +29,31 @@ class TensorBuffer
         let this->buffer = buffer;
     }
 
+    /**
+     * Build a buffer by concatenating an array of buffers into a single
+     * contiguous buffer.
+     *
+     * @param \Tensor\TensorBuffer[] buffers
+     * @return self
+     */
+    public static function fromBuffers(const array buffers) -> <TensorBuffer>
+    {
+        int rows = count(buffers);
+
+        if unlikely rows < 1 {
+            var zero = tensor_buffer_from_array([]);
+            return new self(<Buffer> zero);
+        }
+
+        if unlikely rows == 1 {
+            return new self(buffers[0]->asBuffer());
+        }
+
+        var b = buffers[0]->concat(array_slice(buffers, 1));
+
+        return new self(b->asBuffer());
+    }
+
     /**
      * Return the underlying buffer.
      *
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 889d9cd..03079b0 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -1354,7 +1354,7 @@ class Vector implements Tensor
             let c[] = tensor_multiply(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1380,7 +1380,7 @@ class Vector implements Tensor
             let c[] = tensor_divide(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1406,7 +1406,7 @@ class Vector implements Tensor
             let c[] = tensor_add(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1432,7 +1432,7 @@ class Vector implements Tensor
             let c[] = tensor_subtract(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1458,7 +1458,7 @@ class Vector implements Tensor
             let c[] = tensor_pow(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1484,7 +1484,7 @@ class Vector implements Tensor
             let c[] = tensor_mod(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1510,7 +1510,7 @@ class Vector implements Tensor
             let c[] = tensor_equal(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1536,7 +1536,7 @@ class Vector implements Tensor
             let c[] = tensor_not_equal(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1562,7 +1562,7 @@ class Vector implements Tensor
             let c[] = tensor_greater(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1588,7 +1588,7 @@ class Vector implements Tensor
             let c[] = tensor_greater_equal(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1614,7 +1614,7 @@ class Vector implements Tensor
             let c[] = tensor_less(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**
@@ -1640,7 +1640,7 @@ class Vector implements Tensor
             let c[] = tensor_less_equal(this->a, rowB);
         }
  
-        return Matrix::fromTensorBuffers(c);
+        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
     }
 
     /**

From df70f3c1d4ea07313b2f72c0f79bf85742040867 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Tue, 22 Sep 2026 18:41:45 -0500
Subject: [PATCH 23/51] A little nicer

---
 ext/include/arithmetic.c                      | 108 +++
 ext/include/comparison.c                      | 108 +++
 ext/tensor/matrix.zep.c                       | 846 +++++-------------
 optimizers/TensorAddRowOptimizer.php          |  76 ++
 optimizers/TensorDivideRowOptimizer.php       |  76 ++
 optimizers/TensorEqualRowOptimizer.php        |  76 ++
 optimizers/TensorGreaterEqualRowOptimizer.php |  76 ++
 optimizers/TensorGreaterRowOptimizer.php      |  76 ++
 optimizers/TensorLessEqualRowOptimizer.php    |  76 ++
 optimizers/TensorLessRowOptimizer.php         |  76 ++
 optimizers/TensorModRowOptimizer.php          |  76 ++
 optimizers/TensorMultiplyRowOptimizer.php     |  76 ++
 optimizers/TensorNotEqualRowOptimizer.php     |  76 ++
 optimizers/TensorPowRowOptimizer.php          |  76 ++
 optimizers/TensorSubtractRowOptimizer.php     |  76 ++
 tensor/matrix.zep                             | 156 ++--
 16 files changed, 1395 insertions(+), 735 deletions(-)
 create mode 100644 optimizers/TensorAddRowOptimizer.php
 create mode 100644 optimizers/TensorDivideRowOptimizer.php
 create mode 100644 optimizers/TensorEqualRowOptimizer.php
 create mode 100644 optimizers/TensorGreaterEqualRowOptimizer.php
 create mode 100644 optimizers/TensorGreaterRowOptimizer.php
 create mode 100644 optimizers/TensorLessEqualRowOptimizer.php
 create mode 100644 optimizers/TensorLessRowOptimizer.php
 create mode 100644 optimizers/TensorModRowOptimizer.php
 create mode 100644 optimizers/TensorMultiplyRowOptimizer.php
 create mode 100644 optimizers/TensorNotEqualRowOptimizer.php
 create mode 100644 optimizers/TensorPowRowOptimizer.php
 create mode 100644 optimizers/TensorSubtractRowOptimizer.php

diff --git a/ext/include/arithmetic.c b/ext/include/arithmetic.c
index ceec2a4..4861ccc 100644
--- a/ext/include/arithmetic.c
+++ b/ext/include/arithmetic.c
@@ -514,4 +514,112 @@ void tensor_mod_col(zval * return_value, zval * a, zval * b, zval * n)
 void tensor_mod_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
 {
 	tensor_col_apply(return_value, a, b, n, tensor_col_mod_value, 1);
+}
+
+/* Binary operation applied to every element of a matrix using a shared
+ * row vector. The matrix is wrapped up in `a` (m * n doubles in row-major
+ * order) and the row vector in `b` (n doubles) so that element (i, j) of the
+ * result is op(a[i * n + j], b[j]). */
+
+typedef double (*tensor_row_op)(double x, double y);
+
+static double tensor_row_multiply_value(double x, double y)
+{
+	return x * y;
+}
+
+static double tensor_row_add_value(double x, double y)
+{
+	return x + y;
+}
+
+static double tensor_row_divide_value(double x, double y)
+{
+	return x / y;
+}
+
+static double tensor_row_subtract_value(double x, double y)
+{
+	return x - y;
+}
+
+static double tensor_row_pow_value(double x, double y)
+{
+	return pow(x, y);
+}
+
+static double tensor_row_mod_value(double x, double y)
+{
+	return fmod(x, y);
+}
+
+static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_row_op fn)
+{
+	zend_long nHat = 0, m = 0, total = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
+
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
+
+	nHat = zephir_get_intval(n_zval);
+
+	if (UNEXPECTED(nHat < 1 || nb != nHat || total < nHat || total % nHat != 0)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Matrix and vector dimensions must agree."));
+		return;
+	}
+
+	m = total / nHat;
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	zend_long i, j;
+
+	for (i = 0; i < m; ++i) {
+		for (j = 0; j < nHat; ++j) {
+			vc[i * nHat + j] = fn(va[i * nHat + j], vb[j]);
+		}
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+void tensor_multiply_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_multiply_value);
+}
+
+void tensor_add_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_add_value);
+}
+
+void tensor_divide_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_divide_value);
+}
+
+void tensor_subtract_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_subtract_value);
+}
+
+void tensor_pow_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_pow_value);
+}
+
+void tensor_mod_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_mod_value);
 }
\ No newline at end of file
diff --git a/ext/include/comparison.c b/ext/include/comparison.c
index c4f5b59..e5e7440 100644
--- a/ext/include/comparison.c
+++ b/ext/include/comparison.c
@@ -514,4 +514,112 @@ void tensor_less_equal_col(zval * return_value, zval * a, zval * b, zval * n)
 void tensor_less_equal_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
 {
 	tensor_col_apply(return_value, a, b, n, tensor_col_less_equal_value, 1);
+}
+
+/* Comparison applied to every element of a matrix using a shared row vector.
+ * The matrix is wrapped up in `a` (m * n doubles in row-major order) and the
+ * row vector in `b` (n doubles) so that element (i, j) of the result is 1.0
+ * when the comparison op(a[i * n + j], b[j]) holds and 0.0 otherwise. */
+
+typedef double (*tensor_row_op)(double x, double y);
+
+static double tensor_row_equal_value(double x, double y)
+{
+	return x == y ? 1.0 : 0.0;
+}
+
+static double tensor_row_not_equal_value(double x, double y)
+{
+	return x != y ? 1.0 : 0.0;
+}
+
+static double tensor_row_greater_value(double x, double y)
+{
+	return x > y ? 1.0 : 0.0;
+}
+
+static double tensor_row_greater_equal_value(double x, double y)
+{
+	return x >= y ? 1.0 : 0.0;
+}
+
+static double tensor_row_less_value(double x, double y)
+{
+	return x < y ? 1.0 : 0.0;
+}
+
+static double tensor_row_less_equal_value(double x, double y)
+{
+	return x <= y ? 1.0 : 0.0;
+}
+
+static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_row_op fn)
+{
+	zend_long nHat = 0, m = 0, total = 0, nb = 0;
+	int ok_a = 0, ok_b = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
+
+	if (UNEXPECTED(!ok_a || !ok_b)) {
+		return;
+	}
+
+	nHat = zephir_get_intval(n_zval);
+
+	if (UNEXPECTED(nHat < 1 || nb != nHat || total < nHat || total % nHat != 0)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Matrix and vector dimensions must agree."));
+		return;
+	}
+
+	m = total / nHat;
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	zend_long i, j;
+
+	for (i = 0; i < m; ++i) {
+		for (j = 0; j < nHat; ++j) {
+			vc[i * nHat + j] = fn(va[i * nHat + j], vb[j]);
+		}
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+void tensor_equal_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_equal_value);
+}
+
+void tensor_not_equal_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_not_equal_value);
+}
+
+void tensor_greater_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_greater_value);
+}
+
+void tensor_greater_equal_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_greater_equal_value);
+}
+
+void tensor_less_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_less_value);
+}
+
+void tensor_less_equal_row(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_less_equal_value);
 }
\ No newline at end of file
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 5dd8411..387ca89 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -7532,31 +7532,23 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 PHP_METHOD(Tensor_Matrix, multiplyVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -7567,10 +7559,10 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -7599,44 +7591,16 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_multiply(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2305);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_multiply_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7651,31 +7615,23 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 PHP_METHOD(Tensor_Matrix, divideVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -7686,10 +7642,10 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -7714,48 +7670,20 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2323);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2318);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_divide(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2333);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_divide_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7770,31 +7698,23 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 PHP_METHOD(Tensor_Matrix, addVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -7805,10 +7725,10 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -7833,48 +7753,20 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2351);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2341);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_add(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2361);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_add_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7889,31 +7781,23 @@ PHP_METHOD(Tensor_Matrix, addVector)
 PHP_METHOD(Tensor_Matrix, subtractVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -7924,10 +7808,10 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -7952,48 +7836,20 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2379);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2364);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_subtract(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2389);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_subtract_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8008,31 +7864,23 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 PHP_METHOD(Tensor_Matrix, powVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -8043,10 +7891,10 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -8071,48 +7919,20 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2407);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2387);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_pow(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2417);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_pow_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8127,31 +7947,23 @@ PHP_METHOD(Tensor_Matrix, powVector)
 PHP_METHOD(Tensor_Matrix, modVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -8162,10 +7974,10 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -8190,48 +8002,20 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2435);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2410);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_mod(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2445);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_mod_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8247,31 +8031,23 @@ PHP_METHOD(Tensor_Matrix, modVector)
 PHP_METHOD(Tensor_Matrix, equalVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -8282,10 +8058,10 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -8310,48 +8086,20 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2464);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2434);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2474);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_equal_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8366,31 +8114,23 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 PHP_METHOD(Tensor_Matrix, notEqualVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -8401,10 +8141,10 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -8429,48 +8169,20 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2492);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2457);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_not_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2502);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_not_equal_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8485,31 +8197,23 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 PHP_METHOD(Tensor_Matrix, greaterVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -8520,10 +8224,10 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -8548,48 +8252,20 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2520);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2480);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_greater(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2530);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_greater_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8604,31 +8280,23 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -8639,10 +8307,10 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -8667,48 +8335,20 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2548);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2503);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_greater_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2558);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_greater_equal_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8723,31 +8363,23 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 PHP_METHOD(Tensor_Matrix, lessVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -8758,10 +8390,10 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -8786,48 +8418,20 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2576);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2526);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_less(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2586);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_less_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8843,31 +8447,23 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 PHP_METHOD(Tensor_Matrix, lessEqualVector)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _9;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, _10, _11;
-	zval *b, b_sub, _0, _1, i, bHat, _8, _17, _18, _19, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _14$$4, _15$$4, _16$$4;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&i);
 	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_17);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_14$$4);
-	ZVAL_UNDEF(&_15$$4);
-	ZVAL_UNDEF(&_16$$4);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
@@ -8878,10 +8474,10 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("a", 1, 1);
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -8906,48 +8502,20 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2605);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2550);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	_11 = (zephir_get_numberval(&_8) - 1);
-	_10 = 0;
-	_9 = 0;
-	if (_10 <= _11) {
-		while (1) {
-			if (_9) {
-				_10++;
-				if (!(_10 <= _11)) {
-					break;
-				}
-			} else {
-				_9 = 1;
-			}
-			ZEPHIR_INIT_NVAR(&i);
-			ZVAL_LONG(&i, _10);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_INIT_NVAR(&_16$$4);
-			mul_function(&_16$$4, &i, &_15$$4);
-			zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_14$$4, &_13$$4, "slice", NULL, 0, &_16$$4, &_15$$4);
-			zephir_check_call_status();
-			tensor_less_equal(&_12$$4, &_14$$4, &bHat);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/matrix.zep", 2615);
-		}
-	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_less_equal_row(&result, &_8, &bHat, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_17, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_17, &_18, &_19);
+	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9017,7 +8585,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2633);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2573);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9100,7 +8668,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2656);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2596);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9183,7 +8751,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2679);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2619);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9266,7 +8834,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2702);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2642);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9349,7 +8917,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2725);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2665);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9432,7 +9000,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2748);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2688);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9515,7 +9083,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2771);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2711);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9598,7 +9166,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2794);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2734);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9681,7 +9249,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2817);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2757);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9764,7 +9332,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2840);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2780);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9847,7 +9415,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2863);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2803);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9930,7 +9498,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2886);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2826);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10594,7 +10162,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3070);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3010);
 	return;
 }
 
@@ -10645,7 +10213,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3094);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3034);
 	return;
 }
 
@@ -10705,7 +10273,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3108);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3048);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10722,7 +10290,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3113);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3053);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/optimizers/TensorAddRowOptimizer.php b/optimizers/TensorAddRowOptimizer.php
new file mode 100644
index 0000000..510bcf6
--- /dev/null
+++ b/optimizers/TensorAddRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorAddRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor add row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_add_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorDivideRowOptimizer.php b/optimizers/TensorDivideRowOptimizer.php
new file mode 100644
index 0000000..329462c
--- /dev/null
+++ b/optimizers/TensorDivideRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorDivideRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor divide row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_divide_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorEqualRowOptimizer.php b/optimizers/TensorEqualRowOptimizer.php
new file mode 100644
index 0000000..7086326
--- /dev/null
+++ b/optimizers/TensorEqualRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorEqualRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor equal row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_equal_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorGreaterEqualRowOptimizer.php b/optimizers/TensorGreaterEqualRowOptimizer.php
new file mode 100644
index 0000000..8428194
--- /dev/null
+++ b/optimizers/TensorGreaterEqualRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorGreaterEqualRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor greater equal row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_greater_equal_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorGreaterRowOptimizer.php b/optimizers/TensorGreaterRowOptimizer.php
new file mode 100644
index 0000000..9a9a458
--- /dev/null
+++ b/optimizers/TensorGreaterRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorGreaterRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor greater row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_greater_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLessEqualRowOptimizer.php b/optimizers/TensorLessEqualRowOptimizer.php
new file mode 100644
index 0000000..d27cfee
--- /dev/null
+++ b/optimizers/TensorLessEqualRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLessEqualRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor less equal row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_less_equal_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLessRowOptimizer.php b/optimizers/TensorLessRowOptimizer.php
new file mode 100644
index 0000000..101d6dd
--- /dev/null
+++ b/optimizers/TensorLessRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLessRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor less row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_less_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorModRowOptimizer.php b/optimizers/TensorModRowOptimizer.php
new file mode 100644
index 0000000..f2f5247
--- /dev/null
+++ b/optimizers/TensorModRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorModRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor mod row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_mod_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMultiplyRowOptimizer.php b/optimizers/TensorMultiplyRowOptimizer.php
new file mode 100644
index 0000000..8a81d91
--- /dev/null
+++ b/optimizers/TensorMultiplyRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMultiplyRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor multiply row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_multiply_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorNotEqualRowOptimizer.php b/optimizers/TensorNotEqualRowOptimizer.php
new file mode 100644
index 0000000..0533dad
--- /dev/null
+++ b/optimizers/TensorNotEqualRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorNotEqualRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor not equal row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_not_equal_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorPowRowOptimizer.php b/optimizers/TensorPowRowOptimizer.php
new file mode 100644
index 0000000..bb341b1
--- /dev/null
+++ b/optimizers/TensorPowRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorPowRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor pow row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_pow_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorSubtractRowOptimizer.php b/optimizers/TensorSubtractRowOptimizer.php
new file mode 100644
index 0000000..5bb785b
--- /dev/null
+++ b/optimizers/TensorSubtractRowOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorSubtractRowOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor subtract row accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_subtract_row($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 2c3ba3b..345e242 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -2295,17 +2295,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var i;
-
-        array c = [];
+        var bHat, result;
 
-        var bHat = b->asTensorBuffer();
+        let bHat = b->asTensorBuffer();
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_multiply(this->a->slice(i * this->n, this->n), bHat);
-        }
+        let result = tensor_multiply_row(this->a, bHat, this->n);
 
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2323,17 +2319,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var i;
+        var bHat, result;
 
-        array c = [];
+        let bHat = b->asTensorBuffer();
 
-        var bHat = b->asTensorBuffer();
+        let result = tensor_divide_row(this->a, bHat, this->n);
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_divide(this->a->slice(i * this->n, this->n), bHat);
-        }
-
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2351,17 +2343,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
     
-        var i;
+        var bHat, result;
 
-        array c = [];
+        let bHat = b->asTensorBuffer();
 
-        var bHat = b->asTensorBuffer();
+        let result = tensor_add_row(this->a, bHat, this->n);
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_add(this->a->slice(i * this->n, this->n), bHat);
-        }
-
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2379,17 +2367,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
     
-        var i;
-
-        array c = [];
+        var bHat, result;
 
-        var bHat = b->asTensorBuffer();
+        let bHat = b->asTensorBuffer();
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_subtract(this->a->slice(i * this->n, this->n), bHat);
-        }
+        let result = tensor_subtract_row(this->a, bHat, this->n);
 
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2407,17 +2391,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
     
-        var i;
-
-        array c = [];
+        var bHat, result;
 
-        var bHat = b->asTensorBuffer();
+        let bHat = b->asTensorBuffer();
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_pow(this->a->slice(i * this->n, this->n), bHat);
-        }
+        let result = tensor_pow_row(this->a, bHat, this->n);
 
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2435,17 +2415,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
     
-        var i;
+        var bHat, result;
 
-        array c = [];
+        let bHat = b->asTensorBuffer();
 
-        var bHat = b->asTensorBuffer();
+        let result = tensor_mod_row(this->a, bHat, this->n);
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_mod(this->a->slice(i * this->n, this->n), bHat);
-        }
-
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2464,17 +2440,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var i;
-
-        array c = [];
+        var bHat, result;
 
-        var bHat = b->asTensorBuffer();
+        let bHat = b->asTensorBuffer();
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_equal(this->a->slice(i * this->n, this->n), bHat);
-        }
+        let result = tensor_equal_row(this->a, bHat, this->n);
 
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2492,17 +2464,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var i;
-
-        array c = [];
+        var bHat, result;
 
-        var bHat = b->asTensorBuffer();
+        let bHat = b->asTensorBuffer();
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_not_equal(this->a->slice(i * this->n, this->n), bHat);
-        }
+        let result = tensor_not_equal_row(this->a, bHat, this->n);
 
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2520,17 +2488,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var i;
-
-        array c = [];
+        var bHat, result;
 
-        var bHat = b->asTensorBuffer();
+        let bHat = b->asTensorBuffer();
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_greater(this->a->slice(i * this->n, this->n), bHat);
-        }
+        let result = tensor_greater_row(this->a, bHat, this->n);
 
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2548,17 +2512,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var i;
-
-        array c = [];
+        var bHat, result;
 
-        var bHat = b->asTensorBuffer();
+        let bHat = b->asTensorBuffer();
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_greater_equal(this->a->slice(i * this->n, this->n), bHat);
-        }
+        let result = tensor_greater_equal_row(this->a, bHat, this->n);
 
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2576,17 +2536,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var i;
-
-        array c = [];
+        var bHat, result;
 
-        var bHat = b->asTensorBuffer();
+        let bHat = b->asTensorBuffer();
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_less(this->a->slice(i * this->n, this->n), bHat);
-        }
+        let result = tensor_less_row(this->a, bHat, this->n);
 
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2605,17 +2561,13 @@ class Matrix implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var i;
-
-        array c = [];
+        var bHat, result;
 
-        var bHat = b->asTensorBuffer();
+        let bHat = b->asTensorBuffer();
 
-        for i in range(0, this->m - 1) {
-            let c[] = tensor_less_equal(this->a->slice(i * this->n, this->n), bHat);
-        }
+        let result = tensor_less_equal_row(this->a, bHat, this->n);
 
-        return new self(TensorBuffer::fromBuffers(c), this->m, this->n);
+        return new self(result, this->m, this->n);
     }
 
     /**
@@ -2636,6 +2588,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_multiply_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2659,6 +2612,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_divide_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2682,6 +2636,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_add_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2705,6 +2660,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_subtract_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2728,6 +2684,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_pow_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2751,6 +2708,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_mod_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2774,6 +2732,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_equal_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2797,6 +2756,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_not_equal_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2820,6 +2780,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_greater_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2843,6 +2804,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_greater_equal_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2866,6 +2828,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_less_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -2889,6 +2852,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+        
         let result = tensor_less_equal_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);

From 879c1ce71dbbbc7755f0797d1eabc407e823f246 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 13:22:22 -0500
Subject: [PATCH 24/51] PHP array serial representation

---
 ext/tensor/matrix.zep.c           | 125 +++++++++++---
 ext/tensor/matrix.zep.h           |  11 ++
 ext/tensor/vector.zep.c           |  65 ++++++++
 ext/tensor/vector.zep.h           |  11 ++
 scripts/compare-serialization.php | 265 ++++++++++++++++++++++++++++++
 tensor/matrix.zep                 |  32 +++-
 tensor/vector.zep                 |  28 ++++
 tests/ColumnVectorTest.php        |  18 ++
 tests/MatrixTest.php              |  25 +++
 tests/VectorTest.php              |  18 ++
 10 files changed, 570 insertions(+), 28 deletions(-)
 create mode 100755 scripts/compare-serialization.php

diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 387ca89..455ad21 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -7670,7 +7670,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2318);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2319);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7753,7 +7753,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2341);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2343);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7836,7 +7836,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2364);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2367);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7919,7 +7919,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2387);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2391);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8002,7 +8002,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2410);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2415);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8086,7 +8086,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2434);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2440);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8169,7 +8169,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2457);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2464);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8252,7 +8252,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2480);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2488);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8335,7 +8335,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2503);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2512);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8418,7 +8418,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2526);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2536);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8502,7 +8502,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2550);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2561);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8585,7 +8585,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2573);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2585);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8668,7 +8668,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2596);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2609);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8751,7 +8751,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2619);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2633);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8834,7 +8834,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2642);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2657);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8917,7 +8917,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2665);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2681);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9000,7 +9000,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2688);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2705);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9083,7 +9083,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2711);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2729);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9166,7 +9166,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2734);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2753);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9249,7 +9249,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2757);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2777);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9332,7 +9332,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2780);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2801);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9415,7 +9415,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2803);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2825);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9498,7 +9498,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2826);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2849);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10162,7 +10162,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3010);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3034);
 	return;
 }
 
@@ -10213,7 +10213,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3034);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3058);
 	return;
 }
 
@@ -10273,7 +10273,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3048);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3072);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10290,7 +10290,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3053);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3077);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10331,3 +10331,74 @@ PHP_METHOD(Tensor_Matrix, getIterator)
 	RETURN_MM();
 }
 
+/**
+ * Return the elements of the matrix as a plain PHP array of rows so that
+ * only the values, and not the object structure, appear in the
+ * serialized form.
+ *
+ * @return array[]
+ */
+PHP_METHOD(Tensor_Matrix, __serialize)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "asArray", NULL, 0);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Restore the matrix from the plain array of rows produced by
+ * __serialize() by rebuilding its TensorBuffer and shape.
+ *
+ * @param float[][] data
+ * @throws \Tensor\Exceptions\InvalidArgumentException
+ */
+PHP_METHOD(Tensor_Matrix, __unserialize)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *data_param = NULL, rebuilt, _0, _1, _2;
+	zval data;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&data);
+	ZVAL_UNDEF(&rebuilt);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		ZEPHIR_Z_PARAM_ARRAY(data, data_param)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &data_param);
+	zephir_get_arrval(&data, data_param);
+	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &data);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_0, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_0);
+	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_1);
+	zephir_read_property_cached(&_2, &rebuilt, _zephir_prop_2, 0, PH_NOISY_CC | PH_READONLY);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_2);
+	ZEPHIR_MM_RESTORE();
+}
+
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index c39edd0..4b6b9a8 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -159,6 +159,8 @@ PHP_METHOD(Tensor_Matrix, offsetExists);
 PHP_METHOD(Tensor_Matrix, offsetUnset);
 PHP_METHOD(Tensor_Matrix, offsetGet);
 PHP_METHOD(Tensor_Matrix, getIterator);
+PHP_METHOD(Tensor_Matrix, __serialize);
+PHP_METHOD(Tensor_Matrix, __unserialize);
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromarray, 0, 1, Tensor\\Matrix, 0)
 	ZEND_ARG_ARRAY_INFO(0, a, 0)
@@ -743,6 +745,13 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_getiterator, 0, 0, Traversable, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix___serialize, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_matrix___unserialize, 0, 0, 1)
+	ZEND_ARG_ARRAY_INFO(0, data, 0)
+ZEND_END_ARG_INFO()
+
 ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, fromArray, arginfo_tensor_matrix_fromarray, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, identity, arginfo_tensor_matrix_identity, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
@@ -900,5 +909,7 @@ ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, offsetUnset, arginfo_tensor_matrix_offsetunset, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, offsetGet, arginfo_tensor_matrix_offsetget, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, getIterator, arginfo_tensor_matrix_getiterator, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, __serialize, arginfo_tensor_matrix___serialize, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, __unserialize, arginfo_tensor_matrix___unserialize, ZEND_ACC_PUBLIC)
 	PHP_FE_END
 };
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index e3b4ebf..2dc6107 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -6603,3 +6603,68 @@ PHP_METHOD(Tensor_Vector, getIterator)
 	RETURN_MM();
 }
 
+/**
+ * Return the elements of the vector as a plain PHP array so that only the
+ * values, and not the object structure, appear in the serialized form.
+ *
+ * @return list<float>
+ */
+PHP_METHOD(Tensor_Vector, __serialize)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "asArray", NULL, 0);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Restore the vector from the plain array of elements produced by
+ * __serialize() by rebuilding its TensorBuffer.
+ *
+ * @param float[] data
+ * @throws \Tensor\Exceptions\InvalidArgumentException
+ */
+PHP_METHOD(Tensor_Vector, __unserialize)
+{
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *data_param = NULL, rebuilt, _0, _1;
+	zval data;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&data);
+	ZVAL_UNDEF(&rebuilt);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		ZEPHIR_Z_PARAM_ARRAY(data, data_param)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 0, &data_param);
+	zephir_get_arrval(&data, data_param);
+	ZEPHIR_INIT_VAR(&rebuilt);
+	object_init_ex(&rebuilt, tensor_vector_ce);
+	ZEPHIR_CALL_METHOD(NULL, &rebuilt, "__construct", NULL, 5, &data);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_0, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, &_0);
+	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_1);
+	ZEPHIR_MM_RESTORE();
+}
+
diff --git a/ext/tensor/vector.zep.h b/ext/tensor/vector.zep.h
index 42dc598..d28ff91 100644
--- a/ext/tensor/vector.zep.h
+++ b/ext/tensor/vector.zep.h
@@ -121,6 +121,8 @@ PHP_METHOD(Tensor_Vector, offsetExists);
 PHP_METHOD(Tensor_Vector, offsetUnset);
 PHP_METHOD(Tensor_Vector, offsetGet);
 PHP_METHOD(Tensor_Vector, getIterator);
+PHP_METHOD(Tensor_Vector, __serialize);
+PHP_METHOD(Tensor_Vector, __unserialize);
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_zeros, 0, 1, Tensor\\Vector, 0)
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
@@ -567,6 +569,13 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_getiterator, 0, 0, Traversable, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_vector___serialize, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_vector___unserialize, 0, 0, 1)
+	ZEND_ARG_ARRAY_INFO(0, data, 0)
+ZEND_END_ARG_INFO()
+
 ZEPHIR_INIT_FUNCS(tensor_vector_method_entry) {
 	PHP_ME(Tensor_Vector, zeros, arginfo_tensor_vector_zeros, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, ones, arginfo_tensor_vector_ones, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
@@ -686,5 +695,7 @@ PHP_ME(Tensor_Vector, transpose, arginfo_tensor_vector_transpose, ZEND_ACC_PUBLI
 	PHP_ME(Tensor_Vector, offsetUnset, arginfo_tensor_vector_offsetunset, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, offsetGet, arginfo_tensor_vector_offsetget, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, getIterator, arginfo_tensor_vector_getiterator, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Vector, __serialize, arginfo_tensor_vector___serialize, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Vector, __unserialize, arginfo_tensor_vector___unserialize, ZEND_ACC_PUBLIC)
 	PHP_FE_END
 };
diff --git a/scripts/compare-serialization.php b/scripts/compare-serialization.php
new file mode 100755
index 0000000..fbcad4e
--- /dev/null
+++ b/scripts/compare-serialization.php
@@ -0,0 +1,265 @@
+#!/usr/bin/env php
+<?php
+
+/**
+ * Compare the serialized representation of a plain PHP array against each layer
+ * of the Tensor/Buffer object chain:
+ *
+ *   array -> Buffer -> TensorBuffer -> Vector / ColumnVector / Matrix
+ *
+ * For every representation the script reports:
+ *   - byte size of serialize() (and ratio vs the plain-array baseline)
+ *   - structure: class, own properties with their visibility, __serialize presence
+ *   - round-trip fidelity: unserialize -> class survived -> values match
+ *
+ * It then sweeps array size to separate the fixed wrapper overhead from the
+ * per-element cost, and exercises the empty-buffer edge case.
+ *
+ * Usage:
+ *   php scripts/compare-serialization.php
+ *
+ * The `tensor` extension must be loaded. If it is not, the exact command to
+ * load a locally built shared object is printed.
+ */
+if (!class_exists('\Tensor\Vector')) {
+    fwrite(STDERR, "The 'tensor' extension is not loaded.\n");
+
+    $localSo = __DIR__ . '/../ext/modules/tensor.so';
+
+    if (file_exists($localSo)) {
+        fwrite(
+            STDERR,
+            "Try again with:\n" .
+            '  php -n -d extension=' . $localSo . ' ' . __FILE__ . "\n"
+        );
+    }
+
+    exit(1);
+}
+
+echo 'PHP ' . phpversion() . ' | ', "\n";
+$extName = extension_loaded('tensor') ? 'tensor' : 'tensor_ext';
+echo 'extension: ', $extName, "\n\n";
+
+/*
+ * The canonical payload: the same four doubles reused at every layer so that
+ * only representation overhead varies, never the data.
+ */
+$elements = [1.5, -2.25, 3.0, 4.75];
+$matrixRows = [
+    [1.5, -2.25],
+    [3.0, 4.75],
+];
+
+$maxDelta = 1e-8;
+
+/**
+ * The own properties of an object, with their visibility.
+ *
+ * @param object $subject
+ *
+ * @return array<int, array{name: string, visibility: string}>
+ */
+function ownProperties(object $subject) : array
+{
+    $reflection = new ReflectionObject($subject);
+
+    $properties = [];
+
+    foreach ($reflection->getProperties() as $property) {
+        if ($property->isStatic()) {
+            continue;
+        }
+
+        $visibility = $property->isPrivate()
+            ? 'private'
+            : ($property->isProtected() ? 'protected' : 'public');
+
+        $properties[] = ['name' => $property->getName(), 'visibility' => $visibility];
+    }
+
+    return $properties;
+}
+
+function declaresSerialize(object $subject) : bool
+{
+    return $subject instanceof Tensor\Buffer || method_exists($subject, '__serialize');
+}
+
+/**
+ * Extract the element values from a tensor or plain array, for round-trip checks.
+ *
+ * @param object|array<int>|array<int, array<float>> $subject
+ *
+ * @return array
+ */
+function elementValues($subject) : array
+{
+    if (is_array($subject)) {
+        return $subject;
+    }
+
+    if (method_exists($subject, 'toArray')) {
+        return $subject->toArray();
+    }
+
+    if (method_exists($subject, 'asArray')) {
+        return $subject->asArray();
+    }
+
+    throw new LogicException('Unable to read values from ' . get_class($subject));
+}
+
+function valuesEqual(array $a, array $b, float $delta) : bool
+{
+    $a = array_map('floatval', array_values($a));
+    $b = array_map('floatval', array_values($b));
+
+    $count = count($a);
+
+    if ($count !== count($b)) {
+        return false;
+    }
+
+    for ($i = 0; $i < $count; ++$i) {
+        if (abs($a[$i] - $b[$i]) > $delta) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * @param object|array $subject
+ * @param float $maxDelta
+ * @return array{class: string, ok: bool}
+ */
+function roundTrip($subject, float $maxDelta) : array
+{
+    $originalClass = is_object($subject) ? get_class($subject) : 'array';
+    $expected = elementValues($subject);
+
+    $deserialized = unserialize(serialize($subject));
+
+    $newClass = is_object($deserialized) ? get_class($deserialized) : 'array';
+
+    return [
+        'class' => $newClass,
+        'ok' => $newClass === $originalClass && valuesEqual(elementValues($deserialized), $expected, $maxDelta),
+    ];
+}
+
+function bytes($payload) : int
+{
+    return strlen(serialize($payload));
+}
+
+echo "=== A. Size, structure and round-trip ===\n\n";
+
+$representations = [
+    'array (baseline)' => fn () => $elements,
+    'Buffer::fromArray()' => fn () => Tensor\Buffer::fromArray($elements),
+    'new TensorBuffer()' => fn () => new Tensor\TensorBuffer(Tensor\Buffer::fromArray($elements)),
+    'new Vector()' => fn () => new Tensor\Vector($elements),
+    'new ColumnVector()' => fn () => new Tensor\ColumnVector($elements),
+    'Matrix::fromArray() 2x2' => fn () => Tensor\Matrix::fromArray($matrixRows),
+];
+
+$arrayBytes = bytes($elements);
+
+foreach ($representations as $label => $build) {
+    $object = $build();
+    $size = bytes($object);
+    $ratio = round($size / $arrayBytes, 2);
+
+    echo str_pad($label, 24) . "  {$size} B  ({$ratio}x)\n";
+
+    if (is_object($object)) {
+        $properties = ownProperties($object);
+        $propertyList = $properties
+            ? implode(', ', array_map(static fn ($p) => $p['visibility'] . ' ' . $p['name'], $properties))
+            : '(none)';
+
+        echo '     class:      ', get_class($object), "\n";
+        echo "     properties: {$propertyList}\n";
+        echo '     __serialize:', declaresSerialize($object) ? 'yes' : 'no', "\n";
+    } else {
+        echo "     class:      array\n";
+        echo "     __serialize: n/a\n";
+    }
+
+    $raw = serialize($object);
+    echo '     raw:        ', substr($raw, 0, 120), (strlen($raw) > 120 ? '...' : ''), "\n";
+
+    $result = roundTrip($object, $maxDelta);
+    echo '     round-trip: ', $result['ok'] ? 'OK' : 'FAILED', " (as {$result['class']})\n\n";
+}
+
+echo "=== B. Size vs element count (wrapper overhead vs per-element cost) ===\n\n";
+
+echo "  n            array      Buffer       Vector      Matrix      ratio(V/array)\n";
+
+foreach ([4, 64, 1024, 8192] as $n) {
+    $data = array_map(fn (int $i) => ($i % 9) - 4.0, range(0, $n - 1));
+
+    $arraySize = strlen(serialize($data));
+    $bufferSize = bytes(Tensor\Buffer::fromArray($data));
+    $vectorSize = bytes(new Tensor\Vector($data));
+    $matrixSize = $n % 2 === 0 ? bytes(Tensor\Matrix::fromArray(array_chunk($data, $n / 2))) : null;
+    $ratio = round($vectorSize / $arraySize, 2);
+
+    $matrixCell = $matrixSize === null ? '      n/a' : (string) $matrixSize;
+
+    printf(
+        "  %-11d %-10d %-11d %-11d %-11s %s\n",
+        $n,
+        $arraySize,
+        $bufferSize,
+        $vectorSize,
+        $matrixCell,
+        $ratio . 'x'
+    );
+}
+
+echo "\n";
+echo "  As n grows, the fixed wrapper (class name, property keys, shape ints)\n";
+echo "  amortises and the ratio converges toward ~1x (the raw element array).\n\n";
+
+echo "=== C. Empty-buffer edge case ===\n\n";
+
+$empty = [];
+
+foreach ([
+    'array' => static fn () => $empty,
+    'Buffer' => static function () use ($empty) {
+        return Tensor\Buffer::fromArray($empty);
+    },
+    'TensorBuffer' => static function () use ($empty) {
+        return new Tensor\TensorBuffer(Tensor\Buffer::fromArray($empty));
+    },
+    'Vector' => static function () use ($empty) {
+        return new Tensor\Vector($empty);
+    },
+] as $label => $build) {
+    $object = $build();
+    $size = bytes($object);
+    $result = roundTrip($object, $maxDelta);
+
+    echo '  ', str_pad($label, 14), '  ', $size, ' B    round-trip: ', $result['ok'] ? 'OK' : 'FAILED', "\n";
+}
+
+echo "\n";
+echo "=== Summary (canonical payload: {$elements[0]}, {$elements[1]}, {$elements[2]}, {$elements[3]}) ===\n\n";
+
+echo '  Array      ', str_pad((string) strlen(serialize($elements)), 8), "B  (baseline)\n";
+echo '  Buffer     ', str_pad((string) bytes(Tensor\Buffer::fromArray($elements)), 8), "B\n";
+echo '  TensorBuffer ', str_pad((string) bytes(new Tensor\TensorBuffer(Tensor\Buffer::fromArray($elements))), 8), "B\n";
+echo '  Vector     ', str_pad((string) bytes(new Tensor\Vector($elements)), 8), "B\n";
+echo '  ColumnVector ', str_pad((string) bytes(new Tensor\ColumnVector($elements)), 8), "B\n";
+echo '  Matrix 2x2 ', str_pad((string) bytes(Tensor\Matrix::fromArray($matrixRows)), 8), "B\n\n";
+
+echo "  Overhead: a plain array and the raw Buffer carry a little per-element\n";
+echo "  overhead. Vector, ColumnVector and Matrix declare __serialize/__unserialize,\n";
+echo "  so the element payload is written value-only (a nested array) and rebuilt\n";
+echo "  into a TensorBuffer on unserialize - only the object envelope remains.\n";
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 345e242..bba7cd5 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -2852,7 +2852,7 @@ class Matrix implements Tensor
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
-        
+
         let result = tensor_less_equal_col(this->a, bHat, this->n);
 
         return new self(result, this->m, this->n);
@@ -3089,4 +3089,34 @@ class Matrix implements Tensor
     {
         return new ArrayIterator(this->asVectors());
     }
+
+    /**
+     * Return the elements of the matrix as a plain PHP array of rows so that
+     * only the values, and not the object structure, appear in the
+     * serialized form.
+     *
+     * @return array[]
+     */
+    public function __serialize() -> array
+    {
+        return this->asArray();
+    }
+
+    /**
+     * Restore the matrix from the plain array of rows produced by
+     * __serialize() by rebuilding its TensorBuffer and shape.
+     *
+     * @param float[][] data
+     * @throws \Tensor\Exceptions\InvalidArgumentException
+     */
+    public function __unserialize(const array data)
+    {
+        var rebuilt;
+
+        let rebuilt = Matrix::fromArray(data);
+
+        let this->a = rebuilt->a;
+        let this->m = rebuilt->m;
+        let this->n = rebuilt->n;
+    }
 }
\ No newline at end of file
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 03079b0..814326d 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -2064,4 +2064,32 @@ class Vector implements Tensor
     {
         return new ArrayIterator(this->a->toArray());
     }
+
+    /**
+     * Return the elements of the vector as a plain PHP array so that only the
+     * values, and not the object structure, appear in the serialized form.
+     *
+     * @return list<float>
+     */
+    public function __serialize() -> array
+    {
+        return this->asArray();
+    }
+
+    /**
+     * Restore the vector from the plain array of elements produced by
+     * __serialize() by rebuilding its TensorBuffer.
+     *
+     * @param float[] data
+     * @throws \Tensor\Exceptions\InvalidArgumentException
+     */
+    public function __unserialize(const array data)
+    {
+        var rebuilt;
+
+        let rebuilt = new self(data);
+
+        let this->a = rebuilt->a;
+        let this->n = rebuilt->n;
+    }
 }
\ No newline at end of file
diff --git a/tests/ColumnVectorTest.php b/tests/ColumnVectorTest.php
index dde88c9..7849578 100644
--- a/tests/ColumnVectorTest.php
+++ b/tests/ColumnVectorTest.php
@@ -76,6 +76,24 @@ public function size() : void
         $this->assertEquals(3, $vector->size());
     }
 
+    /**
+     * @test
+     */
+    public function serialization() : void
+    {
+        $vector = new ColumnVector([-15, 25, 35]);
+
+        $serialized = serialize($vector);
+
+        $this->assertStringNotContainsString('TensorBuffer', $serialized);
+
+        $restored = unserialize($serialized);
+
+        $this->assertInstanceOf(ColumnVector::class, $restored);
+        $this->assertEquals([-15.0, 25.0, 35.0], $restored->asArray());
+        $this->assertSame(serialize($vector), serialize($restored));
+    }
+
     /**
      * @test
      */
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index 822c693..a3bf100 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -413,6 +413,31 @@ public function asArray() : void
         $this->assertEquals($expected, $matrix->asArray());
     }
 
+    /**
+     * @test
+     */
+    public function serialization() : void
+    {
+        $matrix = Matrix::fromArray([
+            [22, -17, 12],
+            [4, 11, -2],
+        ]);
+
+        $serialized = serialize($matrix);
+
+        $this->assertStringNotContainsString('TensorBuffer', $serialized);
+
+        $restored = unserialize($serialized);
+
+        $this->assertInstanceOf(Matrix::class, $restored);
+        $this->assertEquals([2, 3], $restored->shape());
+        $this->assertEquals([
+            [22, -17, 12],
+            [4, 11, -2],
+        ], $restored->asArray());
+        $this->assertSame(serialize($matrix), serialize($restored));
+    }
+
     /**
      * @test
      */
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index 80ea2f9..9962920 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -376,6 +376,24 @@ public function asArray() : void
         $this->assertEquals($expected, $vector->asArray());
     }
 
+    /**
+     * @test
+     */
+    public function serialization() : void
+    {
+        $vector = new Vector([-15.0, 25.0, 35.0, -36.0]);
+
+        $serialized = serialize($vector);
+
+        $this->assertStringNotContainsString('TensorBuffer', $serialized);
+
+        $restored = unserialize($serialized);
+
+        $this->assertInstanceOf(Vector::class, $restored);
+        $this->assertEquals([-15.0, 25.0, 35.0, -36.0], $restored->asArray());
+        $this->assertSame(serialize($vector), serialize($restored));
+    }
+
     /**
      * @test
      */

From c912bb703165f59bf1e2e6e04f199c8a0483476c Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 15:49:15 -0500
Subject: [PATCH 25/51] A little nicer

---
 .github/workflows/ci.yml          |    3 -
 AGENTS.md                         |    2 +-
 CHANGELOG.md                      |    5 +-
 composer.json                     |    5 -
 docs/ColumnVector.md              |    1 +
 docs/Vector.md                    |   17 +-
 ext/tensor/columnvector.zep.c     |    2 +-
 ext/tensor/matrix.zep.c           | 1449 +++++++++++++++--------------
 ext/tensor/matrix.zep.h           |   54 +-
 ext/tensor/tensorbuffer.zep.c     |  200 ++--
 ext/tensor/tensorbuffer.zep.h     |   38 +-
 ext/tensor/vector.zep.c           |  557 ++++++-----
 ext/tensor/vector.zep.h           |    9 +-
 phpstan.neon                      |    9 -
 scripts/compare-serialization.php |    4 +-
 tensor/columnvector.zep           |   12 +
 tensor/matrix.zep                 |  275 +++---
 tensor/tensorbuffer.zep           |   68 +-
 tensor/vector.zep                 |   73 +-
 tests/ColumnVectorTest.php        |   56 +-
 tests/MatrixTest.php              |   96 +-
 tests/VectorTest.php              |  398 ++++----
 22 files changed, 1745 insertions(+), 1588 deletions(-)
 delete mode 100644 phpstan.neon

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f27772c..c282f6f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -79,9 +79,6 @@ jobs:
       - name: Install Dependencies
         run: composer install
 
-      - name: Static Analysis
-        run: composer analyze
-
       - name: Unit Tests
         run: composer test
 
diff --git a/AGENTS.md b/AGENTS.md
index e7b2e57..b444bd9 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -17,7 +17,7 @@ Guidance for AI coding agents contributing to **Tensor** — a scientific-comput
 
 ## Environment
 
-- PHP **8.1+** (CI matrix is 8.1 → 8.5). `composer.json` declares `>=1.0`.
+- PHP **8.1+** (CI matrix is 8.1 → 8.5). `composer.json` declares `>=8.1`.
 - Dev tooling is installed as Composer dev dependencies (PHPStan, php-cs-fixer, phpunit, phpbench, Zephir).
 - Compiling the extension additionally needs a C compiler, GFortran, `phpize`, OpenBLAS dev headers, LAPACKE, and re2c (see README for per-OS install commands).
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 158a102..2059677 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,8 +2,9 @@
 
 - 4.0.0
     - Performance: the linear algebra operations (REF, RREF, Cholesky, LU, eigendecomposition, SVD), `rank()`, `symmetric()`, and the vector `outer()` product now read their input from, and return their output into, `TensorBuffer`s directly instead of round-tripping through PHP arrays, eliminating the intermediate array copies
-    - Breaking: removed the `Vector::build()`, `Vector::quick()`, `Vector::fromTensorBuffer()`, `Matrix::build()`, `Matrix::quick()`, `Matrix::fromTensorBuffer()`, and `ColumnVector::build()`, `ColumnVector::quick()`, and `ColumnVector::fromTensorBuffer()` factory methods. Construct directly with `new Vector(...)` / `new ColumnVector(...)`, or build a `Matrix` with `Matrix::fromArray(...)` (or `new Matrix(...)` from a `TensorBuffer`)
-    - Breaking: `Vector::__construct()` no longer accepts a `validate` argument; pass an array of elements (or a `TensorBuffer`) and it will be constructed directly
+    - Breaking: removed the `Vector::build()`, `Vector::quick()`, `Vector::fromTensorBuffer()`, `Matrix::build()`, `Matrix::quick()`, `Matrix::fromTensorBuffer()`, and `ColumnVector::build()`, `ColumnVector::quick()`, and `ColumnVector::fromTensorBuffer()` factory methods. Build a `Vector` / `ColumnVector` with `Vector::fromArray(...)` / `ColumnVector::fromArray(...)` (or `new Vector(...)` / `new ColumnVector(...)` from a `TensorBuffer`), or a `Matrix` with `Matrix::fromArray(...)` (or `new Matrix(...)` from a `TensorBuffer`)
+    - Breaking: `Vector::__construct()` no longer accepts a `validate` argument or a PHP array; it now takes a `TensorBuffer` only. To build from an array use the new `Vector::fromArray(array $a, bool $validate = true)` static factory (inherited by `ColumnVector`)
+    - Added `Vector::fromArray(array $a, bool $validate = true)` (inherited by `ColumnVector`) mirroring `Matrix::fromArray(...)`
     - Breaking: removed the `Matrix::fromTensorBuffers()` factory method in favor of the new `TensorBuffer::fromBuffers()` factory, which concatenates an array of `TensorBuffer`s into a single contiguous buffer
 
 - 3.1.0
diff --git a/composer.json b/composer.json
index 93d7fe4..8257892 100644
--- a/composer.json
+++ b/composer.json
@@ -33,9 +33,6 @@
         "friendsofphp/php-cs-fixer": "^3.0",
         "phalcon/zephir": "dev-development",
         "phpbench/phpbench": "^1.0",
-        "phpstan/extension-installer": "^1.0",
-        "phpstan/phpstan": "^1.0",
-        "phpstan/phpstan-phpunit": "^1.0",
         "phpunit/phpunit": "^9.0"
     },
     "autoload": {
@@ -53,11 +50,9 @@
         "build": [
             "@composer validate",
             "@composer install",
-            "@analyze",
             "@test",
             "@check"
         ],
-        "analyze": "phpstan analyse -c phpstan.neon --memory-limit=1G",
         "benchmark": "phpbench run --report=env --report=aggregate",
         "check": [
             "@putenv PHP_CS_FIXER_IGNORE_ENV=1",
diff --git a/docs/ColumnVector.md b/docs/ColumnVector.md
index c833145..76795be 100644
--- a/docs/ColumnVector.md
+++ b/docs/ColumnVector.md
@@ -16,6 +16,7 @@ This page documents only the methods **defined on `ColumnVector`** and how they
 - Element-wise operations against a `Matrix` broadcast **down the rows** of the matrix (each matrix row is scaled by one vector element), whereas a `Vector` broadcasts **across the columns**.
 - `transpose()` rotates the column vector into a horizontal `Vector`.
 - All inherited factory/operators operate on `static`, so they return `ColumnVector` instances where applicable.
+- `ColumnVector::fromArray(array $a, bool $validate = true)` is inherited from `Vector` and returns a `ColumnVector` instance directly.
 
 ## Dimensionality
 
diff --git a/docs/Vector.md b/docs/Vector.md
index 7cfc2bd..bf3243c 100644
--- a/docs/Vector.md
+++ b/docs/Vector.md
@@ -14,12 +14,21 @@ Interface methods are implemented by Vectors with scalar-level semantics — red
 
 ## Constructors & Factories
 
-### `__construct(array $a)`
+### `__construct(\Tensor\TensorBuffer $a)`
 
-Instantiate a vector directly from an array of elements.
+Instantiate a vector from a `TensorBuffer` holding its elements.
 
-- **Parameters:** `$a` — the 1-dimensional element array `(int|float)[]`
-- **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$a` is not an array or a `TensorBuffer`
+- **Parameters:** `$a` — the `TensorBuffer` of elements
+
+### `Vector::fromArray(array $a, bool $validate = true) : Vector`
+
+Build a vector from a flat PHP array of numeric elements, casting each value to a float.
+
+- **Parameters:**
+  - `$a` — `list<int|float>`, a flat array of numeric elements
+  - `$validate` — whether to reject nested arrays (default `true`)
+- **Returns:** `Vector` (or `ColumnVector` when called on `Tensor\ColumnVector`)
+- **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$a` is not a flat array of numeric elements (i.e. contains a nested array, when `$validate` is `true`)
 
 ### `Vector::zeros(int $n) : Vector`
 
diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index 383054a..f3e48f1 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -82,7 +82,7 @@ PHP_METHOD(Tensor_ColumnVector, transpose)
 
 	object_init_ex(return_value, tensor_vector_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 3, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 455ad21..1f9c6a6 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -12,15 +12,15 @@
 #include <Zend/zend_interfaces.h>
 
 #include "kernel/main.h"
+#include "kernel/exception.h"
 #include "kernel/memory.h"
 #include "kernel/fcall.h"
-#include "kernel/exception.h"
 #include "kernel/concat.h"
-#include "kernel/operators.h"
-#include "kernel/string.h"
 #include "kernel/array.h"
+#include "kernel/operators.h"
 #include "kernel/object.h"
 #include "math.h"
+#include "kernel/string.h"
 #include "kernel/math.h"
 #include "ext/spl/spl_array.h"
 #include "include/buffer.h"
@@ -66,300 +66,6 @@ ZEPHIR_INIT_CLASS(Tensor_Matrix)
 	return SUCCESS;
 }
 
-/**
- * Build a new matrix from a PHP array of rows, each row being a PHP array
- * of numeric elements.
- *
- * @param array[] a
- * @param bool validate
- * @throws \Tensor\Exceptions\InvalidArgumentException
- * @return self
- */
-PHP_METHOD(Tensor_Matrix, fromArray)
-{
-	zval _6$$4, _10$$6, _28$$11;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_2 = NULL, *_14 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, rows;
-	zend_bool validate, _25, _8$$5, _11$$5, _22$$5, _26$$10, _29$$10, _39$$10;
-	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, *_7, _24, buffer, _41, _42, zero$$3, _0$$3, _1$$3, _3$$3, _4$$3, _5$$4, *_17$$5, _18$$5, *_19$$5, _21$$5, _9$$6, _12$$7, _13$$7, _15$$7, _16$$7, _20$$8, _23$$9, *_34$$10, _35$$10, *_36$$10, _38$$10, _27$$11, _30$$12, _31$$12, _32$$12, _33$$12, _37$$13, _40$$14;
-	zval a, flat;
-
-	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&flat);
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&firstRow);
-	ZVAL_UNDEF(&n);
-	ZVAL_UNDEF(&_24);
-	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_41);
-	ZVAL_UNDEF(&_42);
-	ZVAL_UNDEF(&zero$$3);
-	ZVAL_UNDEF(&_0$$3);
-	ZVAL_UNDEF(&_1$$3);
-	ZVAL_UNDEF(&_3$$3);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$5);
-	ZVAL_UNDEF(&_9$$6);
-	ZVAL_UNDEF(&_12$$7);
-	ZVAL_UNDEF(&_13$$7);
-	ZVAL_UNDEF(&_15$$7);
-	ZVAL_UNDEF(&_16$$7);
-	ZVAL_UNDEF(&_20$$8);
-	ZVAL_UNDEF(&_23$$9);
-	ZVAL_UNDEF(&_35$$10);
-	ZVAL_UNDEF(&_38$$10);
-	ZVAL_UNDEF(&_27$$11);
-	ZVAL_UNDEF(&_30$$12);
-	ZVAL_UNDEF(&_31$$12);
-	ZVAL_UNDEF(&_32$$12);
-	ZVAL_UNDEF(&_33$$12);
-	ZVAL_UNDEF(&_37$$13);
-	ZVAL_UNDEF(&_40$$14);
-	ZVAL_UNDEF(&_6$$4);
-	ZVAL_UNDEF(&_10$$6);
-	ZVAL_UNDEF(&_28$$11);
-	ZEND_PARSE_PARAMETERS_START(1, 2)
-		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
-		Z_PARAM_OPTIONAL
-		Z_PARAM_BOOL(validate)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 1, &a_param, &validate_param);
-	zephir_get_arrval(&a, a_param);
-	if (!validate_param) {
-		validate = 1;
-	} else {
-		}
-	rows = zephir_fast_count_int(&a);
-	if (UNEXPECTED(rows < 1)) {
-		ZEPHIR_INIT_VAR(&zero$$3);
-		ZEPHIR_INIT_VAR(&_0$$3);
-		array_init(&_0$$3);
-		tensor_buffer_from_array(&zero$$3, &_0$$3);
-		object_init_ex(return_value, tensor_matrix_ce);
-		ZEPHIR_INIT_VAR(&_1$$3);
-		object_init_ex(&_1$$3, tensor_tensorbuffer_ce);
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", &_2, 14, &zero$$3);
-		zephir_check_call_status();
-		ZVAL_LONG(&_3$$3, 0);
-		ZVAL_LONG(&_4$$3, 0);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_1$$3, &_3$$3, &_4$$3);
-		zephir_check_call_status();
-		RETURN_MM();
-	}
-	ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 27, &a);
-	zephir_check_call_status();
-	if (UNEXPECTED(!(Z_TYPE_P(&firstRow) == IS_ARRAY))) {
-		ZEPHIR_INIT_VAR(&_5$$4);
-		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_INIT_VAR(&_6$$4);
-		ZEPHIR_CONCAT_SS(&_6$$4, "Matrix requires an", " array of arrays.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_6$$4);
-		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 72);
-		ZEPHIR_MM_RESTORE();
-		return;
-	}
-	ZEPHIR_INIT_VAR(&n);
-	ZVAL_LONG(&n, zephir_fast_count_int(&firstRow));
-	ZEPHIR_INIT_VAR(&flat);
-	array_init(&flat);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 96);
-	if (Z_TYPE_P(&a) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _7)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _7);
-			_8$$5 = validate;
-			if (_8$$5) {
-				_8$$5 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
-			}
-			if (UNEXPECTED(_8$$5)) {
-				ZEPHIR_INIT_NVAR(&_9$$6);
-				object_init_ex(&_9$$6, tensor_exceptions_invalidargumentexception_ce);
-				ZEPHIR_INIT_NVAR(&_10$$6);
-				ZEPHIR_CONCAT_SS(&_10$$6, "Matrix requires an", " array of arrays.");
-				ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", NULL, 2, &_10$$6);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_9$$6, "tensor/matrix.zep", 82);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-			_11$$5 = validate;
-			if (_11$$5) {
-				_11$$5 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
-			}
-			if (UNEXPECTED(_11$$5)) {
-				ZEPHIR_INIT_NVAR(&_12$$7);
-				object_init_ex(&_12$$7, tensor_exceptions_invalidargumentexception_ce);
-				ZEPHIR_CALL_FUNCTION(&_13$$7, "strval", &_14, 3, &n);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$7);
-				ZVAL_LONG(&_15$$7, zephir_fast_count_int(&rowA));
-				ZEPHIR_INIT_NVAR(&_16$$7);
-				ZEPHIR_CONCAT_SSVSVS(&_16$$7, "The number of", " columns must be equal for all rows, ", &_13$$7, " needed but ", &_15$$7, " given.");
-				ZEPHIR_CALL_METHOD(NULL, &_12$$7, "__construct", NULL, 2, &_16$$7);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_12$$7, "tensor/matrix.zep", 88);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_18$$5);
-				zephir_string_to_char_array(&_18$$5, &rowA);
-				_17$$5 = &_18$$5;
-			} else {
-				_17$$5 = &rowA;
-			}
-			zephir_is_iterable(_17$$5, 0, "tensor/matrix.zep", 94);
-			if (Z_TYPE_P(_17$$5) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$5), _19$$5)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _19$$5);
-					ZEPHIR_INIT_NVAR(&_20$$8);
-					ZVAL_DOUBLE(&_20$$8, zephir_get_doubleval(&valueA));
-					zephir_array_append(&flat, &_20$$8, PH_SEPARATE, "tensor/matrix.zep", 92);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _17$$5, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_22$$5 = 1;
-				while (1) {
-					if (_22$$5) {
-						_22$$5 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _17$$5, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_21$$5, _17$$5, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_21$$5)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _17$$5, "current", NULL, 0);
-					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_23$$9);
-						ZVAL_DOUBLE(&_23$$9, zephir_get_doubleval(&valueA));
-						zephir_array_append(&flat, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 92);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueA);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, &a, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_25 = 1;
-		while (1) {
-			if (_25) {
-				_25 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, &a, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_24, &a, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_24)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, &a, "current", NULL, 0);
-			zephir_check_call_status();
-				_26$$10 = validate;
-				if (_26$$10) {
-					_26$$10 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
-				}
-				if (UNEXPECTED(_26$$10)) {
-					ZEPHIR_INIT_NVAR(&_27$$11);
-					object_init_ex(&_27$$11, tensor_exceptions_invalidargumentexception_ce);
-					ZEPHIR_INIT_NVAR(&_28$$11);
-					ZEPHIR_CONCAT_SS(&_28$$11, "Matrix requires an", " array of arrays.");
-					ZEPHIR_CALL_METHOD(NULL, &_27$$11, "__construct", NULL, 2, &_28$$11);
-					zephir_check_call_status();
-					zephir_throw_exception_debug(&_27$$11, "tensor/matrix.zep", 82);
-					ZEPHIR_MM_RESTORE();
-					return;
-				}
-				_29$$10 = validate;
-				if (_29$$10) {
-					_29$$10 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
-				}
-				if (UNEXPECTED(_29$$10)) {
-					ZEPHIR_INIT_NVAR(&_30$$12);
-					object_init_ex(&_30$$12, tensor_exceptions_invalidargumentexception_ce);
-					ZEPHIR_CALL_FUNCTION(&_31$$12, "strval", &_14, 3, &n);
-					zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&_32$$12);
-					ZVAL_LONG(&_32$$12, zephir_fast_count_int(&rowA));
-					ZEPHIR_INIT_NVAR(&_33$$12);
-					ZEPHIR_CONCAT_SSVSVS(&_33$$12, "The number of", " columns must be equal for all rows, ", &_31$$12, " needed but ", &_32$$12, " given.");
-					ZEPHIR_CALL_METHOD(NULL, &_30$$12, "__construct", NULL, 2, &_33$$12);
-					zephir_check_call_status();
-					zephir_throw_exception_debug(&_30$$12, "tensor/matrix.zep", 88);
-					ZEPHIR_MM_RESTORE();
-					return;
-				}
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_35$$10);
-					zephir_string_to_char_array(&_35$$10, &rowA);
-					_34$$10 = &_35$$10;
-				} else {
-					_34$$10 = &rowA;
-				}
-				zephir_is_iterable(_34$$10, 0, "tensor/matrix.zep", 94);
-				if (Z_TYPE_P(_34$$10) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_34$$10), _36$$10)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _36$$10);
-						ZEPHIR_INIT_NVAR(&_37$$13);
-						ZVAL_DOUBLE(&_37$$13, zephir_get_doubleval(&valueA));
-						zephir_array_append(&flat, &_37$$13, PH_SEPARATE, "tensor/matrix.zep", 92);
-					} ZEND_HASH_FOREACH_END();
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _34$$10, "rewind", NULL, 0);
-					zephir_check_call_status();
-					_39$$10 = 1;
-					while (1) {
-						if (_39$$10) {
-							_39$$10 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _34$$10, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_38$$10, _34$$10, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_38$$10)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _34$$10, "current", NULL, 0);
-						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_40$$14);
-							ZVAL_DOUBLE(&_40$$14, zephir_get_doubleval(&valueA));
-							zephir_array_append(&flat, &_40$$14, PH_SEPARATE, "tensor/matrix.zep", 92);
-					}
-				}
-				ZEPHIR_INIT_NVAR(&valueA);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
-	ZEPHIR_INIT_VAR(&buffer);
-	tensor_buffer_from_array(&buffer, &flat);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_INIT_VAR(&_41);
-	object_init_ex(&_41, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, &_41, "__construct", &_2, 14, &buffer);
-	zephir_check_call_status();
-	ZVAL_LONG(&_42, rows);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_41, &_42, &n);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
 /**
  * Return an identity matrix with dimensionality n x n.
  *
@@ -399,7 +105,7 @@ PHP_METHOD(Tensor_Matrix, identity)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "N must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 112);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 57);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -445,10 +151,10 @@ PHP_METHOD(Tensor_Matrix, identity)
 						ZEPHIR_INIT_NVAR(&_10$$5);
 						ZVAL_DOUBLE(&_10$$5, 0.0);
 					}
-					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 124);
+					zephir_array_append(&rowA, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 69);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 127);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 72);
 		}
 	}
 	ZVAL_BOOL(&_11, 0);
@@ -550,7 +256,7 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 	zephir_fetch_params(1, 1, 0, &elements_param);
 	zephir_get_arrval(&elements, elements_param);
 	n = zephir_fast_count_int(&elements);
-	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 28, &elements);
+	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 27, &elements);
 	zephir_check_call_status();
 	ZEPHIR_CPY_WRT(&elements, &_0);
 	ZEPHIR_INIT_VAR(&a);
@@ -590,15 +296,15 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 					ZEPHIR_INIT_NVAR(&_7$$4);
 					if (i == j) {
 						ZEPHIR_OBS_NVAR(&_7$$4);
-						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 181);
+						zephir_array_fetch_long(&_7$$4, &elements, i, PH_NOISY, "tensor/matrix.zep", 126);
 					} else {
 						ZEPHIR_INIT_NVAR(&_7$$4);
 						ZVAL_DOUBLE(&_7$$4, 0.0);
 					}
-					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 181);
+					zephir_array_append(&rowA, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 126);
 				}
 			}
-			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 184);
+			zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 129);
 		}
 	}
 	ZVAL_BOOL(&_8, 0);
@@ -656,7 +362,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 203);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 148);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -670,7 +376,7 @@ PHP_METHOD(Tensor_Matrix, fill)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 208);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 153);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -736,7 +442,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 226);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 171);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -750,7 +456,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 231);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 176);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -758,7 +464,7 @@ PHP_METHOD(Tensor_Matrix, rand)
 	array_init(&a);
 	ZEPHIR_INIT_VAR(&rowA);
 	array_init(&rowA);
-	ZEPHIR_CALL_FUNCTION(&_9, "getrandmax", NULL, 6);
+	ZEPHIR_CALL_FUNCTION(&_9, "getrandmax", NULL, 5);
 	zephir_check_call_status();
 	max = zephir_get_intval(&_9);
 	while (1) {
@@ -771,13 +477,13 @@ PHP_METHOD(Tensor_Matrix, rand)
 			if (!(zephir_fast_count_int(&rowA) < n)) {
 				break;
 			}
-			ZEPHIR_CALL_FUNCTION(&_10$$6, "rand", &_11, 7);
+			ZEPHIR_CALL_FUNCTION(&_10$$6, "rand", &_11, 6);
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_12$$6);
 			ZVAL_DOUBLE(&_12$$6, zephir_safe_div_zval_long(&_10$$6, max));
-			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 243);
+			zephir_array_append(&rowA, &_12$$6, PH_SEPARATE, "tensor/matrix.zep", 188);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 246);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 191);
 	}
 	ZVAL_BOOL(&_13, 0);
 	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_13);
@@ -841,7 +547,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 264);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 209);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -855,7 +561,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 269);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 214);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -865,7 +571,7 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 	array_init(&rowA);
 	ZEPHIR_INIT_VAR(&extras);
 	array_init(&extras);
-	ZEPHIR_CALL_FUNCTION(&_9, "getrandmax", NULL, 6);
+	ZEPHIR_CALL_FUNCTION(&_9, "getrandmax", NULL, 5);
 	zephir_check_call_status();
 	max = zephir_get_intval(&_9);
 	while (1) {
@@ -876,42 +582,42 @@ PHP_METHOD(Tensor_Matrix, gaussian)
 		array_init(&rowA);
 		if (!(ZEPHIR_IS_EMPTY(&extras))) {
 			ZEPHIR_MAKE_REF(&extras);
-			ZEPHIR_CALL_FUNCTION(&_10$$6, "array_pop", &_11, 9, &extras);
+			ZEPHIR_CALL_FUNCTION(&_10$$6, "array_pop", &_11, 8, &extras);
 			ZEPHIR_UNREF(&extras);
 			zephir_check_call_status();
-			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 284);
+			zephir_array_append(&rowA, &_10$$6, PH_SEPARATE, "tensor/matrix.zep", 229);
 		}
 		while (1) {
 			if (!(zephir_fast_count_int(&rowA) < n)) {
 				break;
 			}
-			ZEPHIR_CALL_FUNCTION(&_12$$7, "rand", &_13, 7);
+			ZEPHIR_CALL_FUNCTION(&_12$$7, "rand", &_13, 6);
 			zephir_check_call_status();
 			ZVAL_DOUBLE(&_14$$7, zephir_safe_div_zval_long(&_12$$7, max));
-			ZEPHIR_CALL_FUNCTION(&_15$$7, "log", &_16, 8, &_14$$7);
+			ZEPHIR_CALL_FUNCTION(&_15$$7, "log", &_16, 7, &_14$$7);
 			zephir_check_call_status();
 			ZVAL_DOUBLE(&_14$$7, (-2.0 * zephir_get_numberval(&_15$$7)));
 			r =  (sqrt((-2.0 * zephir_get_numberval(&_15$$7))));
-			ZEPHIR_CALL_FUNCTION(&_17$$7, "rand", &_13, 7);
+			ZEPHIR_CALL_FUNCTION(&_17$$7, "rand", &_13, 6);
 			zephir_check_call_status();
 			phi =  ((zephir_safe_div_zval_long(&_17$$7, max) * 6.28318530718));
 			ZVAL_DOUBLE(&_18$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * sin(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 292);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 237);
 			ZVAL_DOUBLE(&_20$$7, phi);
 			ZEPHIR_INIT_NVAR(&_19$$7);
 			ZVAL_DOUBLE(&_19$$7, (r * cos(phi)));
-			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 293);
+			zephir_array_append(&rowA, &_19$$7, PH_SEPARATE, "tensor/matrix.zep", 238);
 		}
 		if (zephir_fast_count_int(&rowA) > n) {
 			ZEPHIR_MAKE_REF(&rowA);
-			ZEPHIR_CALL_FUNCTION(&_21$$8, "array_pop", &_11, 9, &rowA);
+			ZEPHIR_CALL_FUNCTION(&_21$$8, "array_pop", &_11, 8, &rowA);
 			ZEPHIR_UNREF(&rowA);
 			zephir_check_call_status();
-			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 297);
+			zephir_array_append(&extras, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 242);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 300);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 245);
 	}
 	ZVAL_BOOL(&_22, 0);
 	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_22);
@@ -983,7 +689,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 319);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 264);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -997,7 +703,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 324);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 269);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1011,7 +717,7 @@ PHP_METHOD(Tensor_Matrix, poisson)
 		ZEPHIR_CONCAT_SSVS(&_12$$5, "Lambda must be", " greater than or equal to 0, ", &_11$$5, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 2, &_12$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 329);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 274);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1028,10 +734,10 @@ PHP_METHOD(Tensor_Matrix, poisson)
 	ZEPHIR_INIT_VAR(&rowA);
 	array_init(&rowA);
 	ZVAL_DOUBLE(&_16, -lambda);
-	ZEPHIR_CALL_FUNCTION(&_17, "exp", NULL, 10, &_16);
+	ZEPHIR_CALL_FUNCTION(&_17, "exp", NULL, 9, &_16);
 	zephir_check_call_status();
 	l =  (zephir_get_doubleval(&_17));
-	ZEPHIR_CALL_FUNCTION(&_18, "getrandmax", NULL, 6);
+	ZEPHIR_CALL_FUNCTION(&_18, "getrandmax", NULL, 5);
 	zephir_check_call_status();
 	max = zephir_get_intval(&_18);
 	while (1) {
@@ -1051,15 +757,15 @@ PHP_METHOD(Tensor_Matrix, poisson)
 					break;
 				}
 				k++;
-				ZEPHIR_CALL_FUNCTION(&_19$$9, "rand", &_20, 7);
+				ZEPHIR_CALL_FUNCTION(&_19$$9, "rand", &_20, 6);
 				zephir_check_call_status();
 				p *=  (zephir_safe_div_zval_long(&_19$$9, max));
 			}
 			ZEPHIR_INIT_NVAR(&_21$$8);
 			ZVAL_DOUBLE(&_21$$8, (k - 1.0));
-			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 358);
+			zephir_array_append(&rowA, &_21$$8, PH_SEPARATE, "tensor/matrix.zep", 303);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 361);
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 306);
 	}
 	ZVAL_BOOL(&_16, 0);
 	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_16);
@@ -1116,7 +822,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "M must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 379);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 324);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1130,7 +836,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "N must be", " greater than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 384);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 329);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1138,7 +844,7 @@ PHP_METHOD(Tensor_Matrix, uniform)
 	array_init(&a);
 	ZEPHIR_INIT_VAR(&rowA);
 	array_init(&rowA);
-	ZEPHIR_CALL_FUNCTION(&_9, "getrandmax", NULL, 6);
+	ZEPHIR_CALL_FUNCTION(&_9, "getrandmax", NULL, 5);
 	zephir_check_call_status();
 	max = zephir_get_intval(&_9);
 	while (1) {
@@ -1153,16 +859,310 @@ PHP_METHOD(Tensor_Matrix, uniform)
 			}
 			ZVAL_LONG(&_10$$6, -max);
 			ZVAL_LONG(&_11$$6, max);
-			ZEPHIR_CALL_FUNCTION(&_12$$6, "rand", &_13, 7, &_10$$6, &_11$$6);
+			ZEPHIR_CALL_FUNCTION(&_12$$6, "rand", &_13, 6, &_10$$6, &_11$$6);
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_14$$6);
 			ZVAL_DOUBLE(&_14$$6, zephir_safe_div_zval_long(&_12$$6, max));
-			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 396);
+			zephir_array_append(&rowA, &_14$$6, PH_SEPARATE, "tensor/matrix.zep", 341);
+		}
+		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 344);
+	}
+	ZVAL_BOOL(&_15, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_15);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Build a new matrix from a PHP array of rows, each row being a PHP array
+ * of numeric elements.
+ *
+ * @param array[] a
+ * @param bool validate
+ * @throws \Tensor\Exceptions\InvalidArgumentException
+ * @return self
+ */
+PHP_METHOD(Tensor_Matrix, fromArray)
+{
+	zval _6$$4, _10$$6, _28$$11;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zephir_fcall_cache_entry *_2 = NULL, *_14 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, rows;
+	zend_bool validate, _25, _8$$5, _11$$5, _22$$5, _26$$10, _29$$10, _39$$10;
+	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, *_7, _24, buffer, _41, _42, buffer$$3, _0$$3, _1$$3, _3$$3, _4$$3, _5$$4, *_17$$5, _18$$5, *_19$$5, _21$$5, _9$$6, _12$$7, _13$$7, _15$$7, _16$$7, _20$$8, _23$$9, *_34$$10, _35$$10, *_36$$10, _38$$10, _27$$11, _30$$12, _31$$12, _32$$12, _33$$12, _37$$13, _40$$14;
+	zval a, flat;
+
+	ZVAL_UNDEF(&a);
+	ZVAL_UNDEF(&flat);
+	ZVAL_UNDEF(&rowA);
+	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&firstRow);
+	ZVAL_UNDEF(&n);
+	ZVAL_UNDEF(&_24);
+	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&_41);
+	ZVAL_UNDEF(&_42);
+	ZVAL_UNDEF(&buffer$$3);
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_18$$5);
+	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_9$$6);
+	ZVAL_UNDEF(&_12$$7);
+	ZVAL_UNDEF(&_13$$7);
+	ZVAL_UNDEF(&_15$$7);
+	ZVAL_UNDEF(&_16$$7);
+	ZVAL_UNDEF(&_20$$8);
+	ZVAL_UNDEF(&_23$$9);
+	ZVAL_UNDEF(&_35$$10);
+	ZVAL_UNDEF(&_38$$10);
+	ZVAL_UNDEF(&_27$$11);
+	ZVAL_UNDEF(&_30$$12);
+	ZVAL_UNDEF(&_31$$12);
+	ZVAL_UNDEF(&_32$$12);
+	ZVAL_UNDEF(&_33$$12);
+	ZVAL_UNDEF(&_37$$13);
+	ZVAL_UNDEF(&_40$$14);
+	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_10$$6);
+	ZVAL_UNDEF(&_28$$11);
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_BOOL(validate)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 1, &a_param, &validate_param);
+	zephir_get_arrval(&a, a_param);
+	if (!validate_param) {
+		validate = 1;
+	} else {
+		}
+	rows = zephir_fast_count_int(&a);
+	if (UNEXPECTED(rows < 1)) {
+		ZEPHIR_INIT_VAR(&buffer$$3);
+		ZEPHIR_INIT_VAR(&_0$$3);
+		array_init(&_0$$3);
+		tensor_buffer_from_array(&buffer$$3, &_0$$3);
+		object_init_ex(return_value, tensor_matrix_ce);
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_tensorbuffer_ce);
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", &_2, 13, &buffer$$3);
+		zephir_check_call_status();
+		ZVAL_LONG(&_3$$3, 0);
+		ZVAL_LONG(&_4$$3, 0);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_1$$3, &_3$$3, &_4$$3);
+		zephir_check_call_status();
+		RETURN_MM();
+	}
+	ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 28, &a);
+	zephir_check_call_status();
+	if (UNEXPECTED(!(Z_TYPE_P(&firstRow) == IS_ARRAY))) {
+		ZEPHIR_INIT_VAR(&_5$$4);
+		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_6$$4);
+		ZEPHIR_CONCAT_SS(&_6$$4, "Matrix requires an", " array of arrays.");
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_6$$4);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 377);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&n);
+	ZVAL_LONG(&n, zephir_fast_count_int(&firstRow));
+	ZEPHIR_INIT_VAR(&flat);
+	array_init(&flat);
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 401);
+	if (Z_TYPE_P(&a) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _7)
+		{
+			ZEPHIR_INIT_NVAR(&rowA);
+			ZVAL_COPY(&rowA, _7);
+			_8$$5 = validate;
+			if (_8$$5) {
+				_8$$5 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
+			}
+			if (UNEXPECTED(_8$$5)) {
+				ZEPHIR_INIT_NVAR(&_9$$6);
+				object_init_ex(&_9$$6, tensor_exceptions_invalidargumentexception_ce);
+				ZEPHIR_INIT_NVAR(&_10$$6);
+				ZEPHIR_CONCAT_SS(&_10$$6, "Matrix requires an", " array of arrays.");
+				ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", NULL, 2, &_10$$6);
+				zephir_check_call_status();
+				zephir_throw_exception_debug(&_9$$6, "tensor/matrix.zep", 387);
+				ZEPHIR_MM_RESTORE();
+				return;
+			}
+			_11$$5 = validate;
+			if (_11$$5) {
+				_11$$5 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
+			}
+			if (UNEXPECTED(_11$$5)) {
+				ZEPHIR_INIT_NVAR(&_12$$7);
+				object_init_ex(&_12$$7, tensor_exceptions_invalidargumentexception_ce);
+				ZEPHIR_CALL_FUNCTION(&_13$$7, "strval", &_14, 3, &n);
+				zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_15$$7);
+				ZVAL_LONG(&_15$$7, zephir_fast_count_int(&rowA));
+				ZEPHIR_INIT_NVAR(&_16$$7);
+				ZEPHIR_CONCAT_SSVSVS(&_16$$7, "The number of", " columns must be equal for all rows, ", &_13$$7, " needed but ", &_15$$7, " given.");
+				ZEPHIR_CALL_METHOD(NULL, &_12$$7, "__construct", NULL, 2, &_16$$7);
+				zephir_check_call_status();
+				zephir_throw_exception_debug(&_12$$7, "tensor/matrix.zep", 393);
+				ZEPHIR_MM_RESTORE();
+				return;
+			}
+			if (Z_TYPE_P(&rowA) == IS_STRING) {
+				ZEPHIR_INIT_NVAR(&_18$$5);
+				zephir_string_to_char_array(&_18$$5, &rowA);
+				_17$$5 = &_18$$5;
+			} else {
+				_17$$5 = &rowA;
+			}
+			zephir_is_iterable(_17$$5, 0, "tensor/matrix.zep", 399);
+			if (Z_TYPE_P(_17$$5) == IS_ARRAY) {
+				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$5), _19$$5)
+				{
+					ZEPHIR_INIT_NVAR(&valueA);
+					ZVAL_COPY(&valueA, _19$$5);
+					ZEPHIR_INIT_NVAR(&_20$$8);
+					ZVAL_DOUBLE(&_20$$8, zephir_get_doubleval(&valueA));
+					zephir_array_append(&flat, &_20$$8, PH_SEPARATE, "tensor/matrix.zep", 397);
+				} ZEND_HASH_FOREACH_END();
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _17$$5, "rewind", NULL, 0);
+				zephir_check_call_status();
+				_22$$5 = 1;
+				while (1) {
+					if (_22$$5) {
+						_22$$5 = 0;
+					} else {
+						ZEPHIR_CALL_METHOD(NULL, _17$$5, "next", NULL, 0);
+						zephir_check_call_status();
+					}
+					ZEPHIR_CALL_METHOD(&_21$$5, _17$$5, "valid", NULL, 0);
+					zephir_check_call_status();
+					if (!zend_is_true(&_21$$5)) {
+						break;
+					}
+					ZEPHIR_CALL_METHOD(&valueA, _17$$5, "current", NULL, 0);
+					zephir_check_call_status();
+						ZEPHIR_INIT_NVAR(&_23$$9);
+						ZVAL_DOUBLE(&_23$$9, zephir_get_doubleval(&valueA));
+						zephir_array_append(&flat, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 397);
+				}
+			}
+			ZEPHIR_INIT_NVAR(&valueA);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, &a, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_25 = 1;
+		while (1) {
+			if (_25) {
+				_25 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, &a, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_24, &a, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_24)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowA, &a, "current", NULL, 0);
+			zephir_check_call_status();
+				_26$$10 = validate;
+				if (_26$$10) {
+					_26$$10 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
+				}
+				if (UNEXPECTED(_26$$10)) {
+					ZEPHIR_INIT_NVAR(&_27$$11);
+					object_init_ex(&_27$$11, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_INIT_NVAR(&_28$$11);
+					ZEPHIR_CONCAT_SS(&_28$$11, "Matrix requires an", " array of arrays.");
+					ZEPHIR_CALL_METHOD(NULL, &_27$$11, "__construct", NULL, 2, &_28$$11);
+					zephir_check_call_status();
+					zephir_throw_exception_debug(&_27$$11, "tensor/matrix.zep", 387);
+					ZEPHIR_MM_RESTORE();
+					return;
+				}
+				_29$$10 = validate;
+				if (_29$$10) {
+					_29$$10 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
+				}
+				if (UNEXPECTED(_29$$10)) {
+					ZEPHIR_INIT_NVAR(&_30$$12);
+					object_init_ex(&_30$$12, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_CALL_FUNCTION(&_31$$12, "strval", &_14, 3, &n);
+					zephir_check_call_status();
+					ZEPHIR_INIT_NVAR(&_32$$12);
+					ZVAL_LONG(&_32$$12, zephir_fast_count_int(&rowA));
+					ZEPHIR_INIT_NVAR(&_33$$12);
+					ZEPHIR_CONCAT_SSVSVS(&_33$$12, "The number of", " columns must be equal for all rows, ", &_31$$12, " needed but ", &_32$$12, " given.");
+					ZEPHIR_CALL_METHOD(NULL, &_30$$12, "__construct", NULL, 2, &_33$$12);
+					zephir_check_call_status();
+					zephir_throw_exception_debug(&_30$$12, "tensor/matrix.zep", 393);
+					ZEPHIR_MM_RESTORE();
+					return;
+				}
+				if (Z_TYPE_P(&rowA) == IS_STRING) {
+					ZEPHIR_INIT_NVAR(&_35$$10);
+					zephir_string_to_char_array(&_35$$10, &rowA);
+					_34$$10 = &_35$$10;
+				} else {
+					_34$$10 = &rowA;
+				}
+				zephir_is_iterable(_34$$10, 0, "tensor/matrix.zep", 399);
+				if (Z_TYPE_P(_34$$10) == IS_ARRAY) {
+					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_34$$10), _36$$10)
+					{
+						ZEPHIR_INIT_NVAR(&valueA);
+						ZVAL_COPY(&valueA, _36$$10);
+						ZEPHIR_INIT_NVAR(&_37$$13);
+						ZVAL_DOUBLE(&_37$$13, zephir_get_doubleval(&valueA));
+						zephir_array_append(&flat, &_37$$13, PH_SEPARATE, "tensor/matrix.zep", 397);
+					} ZEND_HASH_FOREACH_END();
+				} else {
+					ZEPHIR_CALL_METHOD(NULL, _34$$10, "rewind", NULL, 0);
+					zephir_check_call_status();
+					_39$$10 = 1;
+					while (1) {
+						if (_39$$10) {
+							_39$$10 = 0;
+						} else {
+							ZEPHIR_CALL_METHOD(NULL, _34$$10, "next", NULL, 0);
+							zephir_check_call_status();
+						}
+						ZEPHIR_CALL_METHOD(&_38$$10, _34$$10, "valid", NULL, 0);
+						zephir_check_call_status();
+						if (!zend_is_true(&_38$$10)) {
+							break;
+						}
+						ZEPHIR_CALL_METHOD(&valueA, _34$$10, "current", NULL, 0);
+						zephir_check_call_status();
+							ZEPHIR_INIT_NVAR(&_40$$14);
+							ZVAL_DOUBLE(&_40$$14, zephir_get_doubleval(&valueA));
+							zephir_array_append(&flat, &_40$$14, PH_SEPARATE, "tensor/matrix.zep", 397);
+					}
+				}
+				ZEPHIR_INIT_NVAR(&valueA);
 		}
-		zephir_array_append(&a, &rowA, PH_SEPARATE, "tensor/matrix.zep", 399);
 	}
-	ZVAL_BOOL(&_15, 0);
-	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_15);
+	ZEPHIR_INIT_NVAR(&rowA);
+	ZEPHIR_INIT_VAR(&buffer);
+	tensor_buffer_from_array(&buffer, &flat);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_INIT_VAR(&_41);
+	object_init_ex(&_41, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, &_41, "__construct", &_2, 13, &buffer);
+	zephir_check_call_status();
+	ZVAL_LONG(&_42, rows);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_41, &_42, &n);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1177,12 +1177,17 @@ PHP_METHOD(Tensor_Matrix, uniform)
  */
 PHP_METHOD(Tensor_Matrix, __construct)
 {
-	zend_long m, n;
-	zval *a, a_sub, *m_param = NULL, *n_param = NULL, _0;
+	zval _2$$3;
+	zend_bool _0;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long m, n, ZEPHIR_LAST_CALL_STATUS;
+	zval *a, a_sub, *m_param = NULL, *n_param = NULL, _3, _1$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&a_sub);
-	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
@@ -1201,14 +1206,32 @@ PHP_METHOD(Tensor_Matrix, __construct)
 		Z_PARAM_LONG(m)
 		Z_PARAM_LONG(n)
 	ZEND_PARSE_PARAMETERS_END();
-	zephir_fetch_params_without_memory_grow(3, 0, &a, &m_param, &n_param);
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 3, 0, &a, &m_param, &n_param);
+	_0 = m < 0;
+	if (!(_0)) {
+		_0 = n < 0;
+	}
+	if (UNEXPECTED(_0)) {
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_2$$3);
+		ZEPHIR_CONCAT_SS(&_2$$3, "Matrix dimensions must be", " non-negative.");
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 418);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, a);
-	ZVAL_UNDEF(&_0);
-	ZVAL_LONG(&_0, m);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_0);
-	ZVAL_UNDEF(&_0);
-	ZVAL_LONG(&_0, n);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_0);
+	ZVAL_UNDEF(&_3);
+	ZVAL_LONG(&_3, m);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_3);
+	ZVAL_UNDEF(&_3);
+	ZVAL_LONG(&_3, n);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_3);
+	ZEPHIR_MM_RESTORE();
 }
 
 /**
@@ -1409,7 +1432,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Row offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 491);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 497);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1420,7 +1443,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 	ZVAL_LONG(&_8, (index * (zend_long) zephir_get_numberval(&_6)));
 	ZEPHIR_CALL_METHOD(&_5, &_4, "slice", NULL, 0, &_8, &_7);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1480,7 +1503,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Column offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 508);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 514);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1491,7 +1514,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 	ZVAL_LONG(&_8, index);
 	ZEPHIR_CALL_METHOD(&_5, &_4, "sliceStrided", NULL, 0, &_8, &_6, &_7);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1545,7 +1568,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 524);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 530);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1557,60 +1580,23 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 	ZVAL_LONG(&_9, (zephir_get_numberval(&_7) + 1));
 	ZEPHIR_CALL_METHOD(&_5, &_4, "sliceStrided", NULL, 0, &_8, &_6, &_9);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_5);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
-/**
- * Return the elements of the matrix as a vector taken in row-major order.
- *
- * @return \Tensor\Vector
- */
-PHP_METHOD(Tensor_Matrix, asVector)
-{
-	zval _0;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
-	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
-	object_init_ex(return_value, tensor_vector_ce);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
 
 /**
- * Return the underlying TensorBuffer of the matrix.
- *
- * @return \Tensor\TensorBuffer
- */
-PHP_METHOD(Tensor_Matrix, asTensorBuffer)
-{
-
-	RETURN_MEMBER(getThis(), "a");
-}
-
-/**
- * Return the matrix as an array of arrays.
+ * Return the rows of the matrix as an array of Vector objects.
  *
- * @return array[]
+ * @return \Tensor\Vector[]
  */
-PHP_METHOD(Tensor_Matrix, asArray)
+PHP_METHOD(Tensor_Matrix, asVectors)
 {
-	zend_bool _9;
+	zend_bool _10;
 	zval b;
-	zval rowBuffer, _0, _1, _2, _3, *_4, _5, *_6, _8, _7$$4, _10$$5;
+	zval rowBuffer, _0, _1, _2, _3, *_4, _5, *_6, _9, _7$$4, _11$$5;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zephir_fcall_cache_entry *_8 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
@@ -1620,9 +1606,9 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_10$$5);
+	ZVAL_UNDEF(&_11$$5);
 	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
@@ -1653,37 +1639,41 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 569);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 555);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
 			ZEPHIR_INIT_NVAR(&rowBuffer);
 			ZVAL_COPY(&rowBuffer, _6);
-			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
+			ZEPHIR_INIT_NVAR(&_7$$4);
+			object_init_ex(&_7$$4, tensor_vector_ce);
+			ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", &_8, 14, &rowBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 566);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 552);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_9 = 1;
+		_10 = 1;
 		while (1) {
-			if (_9) {
-				_9 = 0;
+			if (_10) {
+				_10 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _4, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_8, _4, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_9, _4, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_8)) {
+			if (!zend_is_true(&_9)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&rowBuffer, _4, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
+				ZEPHIR_INIT_NVAR(&_11$$5);
+				object_init_ex(&_11$$5, tensor_vector_ce);
+				ZEPHIR_CALL_METHOD(NULL, &_11$$5, "__construct", &_8, 14, &rowBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 566);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 552);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -1691,55 +1681,130 @@ PHP_METHOD(Tensor_Matrix, asArray)
 }
 
 /**
- * Return each row of the matrix as a TensorBuffer.
+ * Return the columns of the matrix as an array of ColumnVector objects.
  *
- * @return \Tensor\TensorBuffer[]
+ * @return \Tensor\ColumnVector[]
  */
-PHP_METHOD(Tensor_Matrix, asRowBuffers)
+PHP_METHOD(Tensor_Matrix, asColumnVectors)
 {
-	zval _0, _1, _2;
+	zend_bool _8;
+	zval b;
+	zval columnBuffer, _0, _1, *_2, _3, *_4, _7, _5$$4, _9$$5;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zephir_fcall_cache_entry *_6 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&columnBuffer);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_9$$5);
+	ZVAL_UNDEF(&b);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		array_init(return_value);
+		RETURN_MM();
+	}
+	ZEPHIR_CALL_METHOD(&_1, this_ptr, "asColumnBuffers", NULL, 0);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_3);
+		zephir_string_to_char_array(&_3, &_1);
+		_2 = &_3;
+	} else {
+		_2 = &_1;
+	}
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 577);
+	if (Z_TYPE_P(_2) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
+		{
+			ZEPHIR_INIT_NVAR(&columnBuffer);
+			ZVAL_COPY(&columnBuffer, _4);
+			ZEPHIR_INIT_NVAR(&_5$$4);
+			object_init_ex(&_5$$4, tensor_columnvector_ce);
+			ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_6, 14, &columnBuffer);
+			zephir_check_call_status();
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 574);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_8 = 1;
+		while (1) {
+			if (_8) {
+				_8 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _2, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_7, _2, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_7)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&columnBuffer, _2, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_9$$5);
+				object_init_ex(&_9$$5, tensor_columnvector_ce);
+				ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", &_6, 14, &columnBuffer);
+				zephir_check_call_status();
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 574);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&columnBuffer);
+	RETURN_CTOR(&b);
+}
+
+/**
+ * Return the elements of the matrix as a vector taken in row-major order.
+ *
+ * @return \Tensor\Vector
+ */
+PHP_METHOD(Tensor_Matrix, flatten)
+{
+	zval _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("n", 1, 1);
-	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
-		array_init(return_value);
-		RETURN_MM();
-	}
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_1, "split", NULL, 0, &_2);
+	object_init_ex(return_value, tensor_vector_ce);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
 
 /**
- * Return the rows of the matrix as an array of Vector objects.
+ * Return the matrix as an array of arrays.
  *
- * @return \Tensor\Vector[]
+ * @return array[]
  */
-PHP_METHOD(Tensor_Matrix, asRowVectors)
+PHP_METHOD(Tensor_Matrix, asArray)
 {
-	zend_bool _10;
+	zend_bool _9;
 	zval b;
-	zval rowBuffer, _0, _1, _2, _3, *_4, _5, *_6, _9, _7$$4, _11$$5;
+	zval rowBuffer, _0, _1, _2, _3, *_4, _5, *_6, _8, _7$$4, _10$$5;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_8 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
@@ -1749,9 +1814,9 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_11$$5);
+	ZVAL_UNDEF(&_10$$5);
 	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
@@ -1782,50 +1847,101 @@ PHP_METHOD(Tensor_Matrix, asRowVectors)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 605);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 610);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
 			ZEPHIR_INIT_NVAR(&rowBuffer);
 			ZVAL_COPY(&rowBuffer, _6);
-			ZEPHIR_INIT_NVAR(&_7$$4);
-			object_init_ex(&_7$$4, tensor_vector_ce);
-			ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", &_8, 5, &rowBuffer);
+			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 602);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 607);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_10 = 1;
+		_9 = 1;
 		while (1) {
-			if (_10) {
-				_10 = 0;
+			if (_9) {
+				_9 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _4, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_9, _4, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_8, _4, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_9)) {
+			if (!zend_is_true(&_8)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&rowBuffer, _4, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_11$$5);
-				object_init_ex(&_11$$5, tensor_vector_ce);
-				ZEPHIR_CALL_METHOD(NULL, &_11$$5, "__construct", &_8, 5, &rowBuffer);
+				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 602);
+				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 607);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
 	RETURN_CTOR(&b);
 }
 
+/**
+ * Return the underlying TensorBuffer of the matrix.
+ *
+ * @internal
+ *
+ * @return \Tensor\TensorBuffer
+ */
+PHP_METHOD(Tensor_Matrix, asTensorBuffer)
+{
+
+	RETURN_MEMBER(getThis(), "a");
+}
+
+/**
+ * Return each row of the matrix as a TensorBuffer.
+ *
+ * @internal
+ *
+ * @return \Tensor\TensorBuffer[]
+ */
+PHP_METHOD(Tensor_Matrix, asRowBuffers)
+{
+	zval _0, _1, _2;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		array_init(return_value);
+		RETURN_MM();
+	}
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_METHOD(&_1, "split", NULL, 0, &_2);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
 /**
  * Return each column of the matrix as a TensorBuffer.
  *
+ * @internal
+ *
  * @return \Tensor\TensorBuffer[]
  */
 PHP_METHOD(Tensor_Matrix, asColumnBuffers)
@@ -1888,144 +2004,12 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 624);
-		}
-	}
-	RETURN_CTOR(&b);
-}
-
-/**
- * Return the columns of the matrix as an array of ColumnVector objects.
- *
- * @return \Tensor\ColumnVector[]
- */
-PHP_METHOD(Tensor_Matrix, asColumnVectors)
-{
-	zend_bool _8;
-	zval b;
-	zval columnBuffer, _0, _1, *_2, _3, *_4, _7, _5$$4, _9$$5;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_6 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&columnBuffer);
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_3);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_9$$5);
-	ZVAL_UNDEF(&b);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("n", 1, 1);
-	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
-		array_init(return_value);
-		RETURN_MM();
-	}
-	ZEPHIR_CALL_METHOD(&_1, this_ptr, "asColumnBuffers", NULL, 0);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_3);
-		zephir_string_to_char_array(&_3, &_1);
-		_2 = &_3;
-	} else {
-		_2 = &_1;
-	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 649);
-	if (Z_TYPE_P(_2) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
-		{
-			ZEPHIR_INIT_NVAR(&columnBuffer);
-			ZVAL_COPY(&columnBuffer, _4);
-			ZEPHIR_INIT_NVAR(&_5$$4);
-			object_init_ex(&_5$$4, tensor_columnvector_ce);
-			ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_6, 5, &columnBuffer);
-			zephir_check_call_status();
-			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 646);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_8 = 1;
-		while (1) {
-			if (_8) {
-				_8 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _2, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_7, _2, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_7)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&columnBuffer, _2, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_9$$5);
-				object_init_ex(&_9$$5, tensor_columnvector_ce);
-				ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", &_6, 5, &columnBuffer);
-				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 646);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 659);
 		}
 	}
-	ZEPHIR_INIT_NVAR(&columnBuffer);
 	RETURN_CTOR(&b);
 }
 
-/**
- * Return the rows of the matrix as an array of Vector objects.
- *
- * @return \Tensor\Vector[]
- */
-PHP_METHOD(Tensor_Matrix, asVectors)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *this_ptr = getThis();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "asRowVectors", NULL, 0);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
-/**
- * Return the elements of the matrix as a vector taken in row-major order.
- *
- * @return \Tensor\Vector
- */
-PHP_METHOD(Tensor_Matrix, flatten)
-{
-	zval _0;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
-	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
-	object_init_ex(return_value, tensor_vector_ce);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
 /**
  * Run a function over all of the elements in the matrix.
  *
@@ -2166,7 +2150,7 @@ PHP_METHOD(Tensor_Matrix, transpose)
 		RETURN_MM();
 	}
 	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 714);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 707);
 	ZVAL_LONG(&_3, 1);
 	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 29, &cols, &_3);
 	zephir_check_call_status();
@@ -2231,7 +2215,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 731);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 724);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2244,7 +2228,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 30, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 736);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 729);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2259,7 +2243,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 30, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 743);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 736);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2319,7 +2303,7 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 30, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 760);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 753);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2369,7 +2353,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 776);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 769);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2578,7 +2562,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 844);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 837);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2653,7 +2637,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 864);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 857);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2751,7 +2735,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 2, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 882);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 875);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2765,7 +2749,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 2, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 887);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 880);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3102,7 +3086,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1031);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1024);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3173,7 +3157,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1064);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1057);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3245,7 +3229,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1098);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1091);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3317,7 +3301,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1132);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1125);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3389,7 +3373,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1166);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1159);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3461,7 +3445,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1200);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1193);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3533,7 +3517,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1234);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1227);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3605,7 +3589,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1268);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1261);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3677,7 +3661,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1302);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1295);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3749,7 +3733,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1336);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1329);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3821,7 +3805,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1370);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1363);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3893,7 +3877,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1404);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1397);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4577,7 +4561,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 {
 	zend_bool _8;
 	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _6$$3, _9$$4;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4588,6 +4572,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_9$$4);
 	ZVAL_UNDEF(&b);
@@ -4615,7 +4600,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1590);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1582);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4623,7 +4608,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1587);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1579);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4645,12 +4630,12 @@ PHP_METHOD(Tensor_Matrix, sum)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1587);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1579);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	object_init_ex(return_value, tensor_columnvector_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
+	ZVAL_BOOL(&_10, 0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4664,7 +4649,7 @@ PHP_METHOD(Tensor_Matrix, product)
 {
 	zend_bool _8;
 	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _6$$3, _9$$4;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4675,6 +4660,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_9$$4);
 	ZVAL_UNDEF(&b);
@@ -4702,7 +4688,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1608);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1600);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4710,7 +4696,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1605);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1597);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4732,12 +4718,12 @@ PHP_METHOD(Tensor_Matrix, product)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1605);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1597);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	object_init_ex(return_value, tensor_columnvector_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
+	ZVAL_BOOL(&_10, 0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4751,7 +4737,7 @@ PHP_METHOD(Tensor_Matrix, min)
 {
 	zend_bool _8;
 	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _6$$3, _9$$4;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4762,6 +4748,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_9$$4);
 	ZVAL_UNDEF(&b);
@@ -4789,7 +4776,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1626);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1618);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4797,7 +4784,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1623);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1615);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4819,12 +4806,12 @@ PHP_METHOD(Tensor_Matrix, min)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1623);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1615);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	object_init_ex(return_value, tensor_columnvector_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
+	ZVAL_BOOL(&_10, 0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4838,7 +4825,7 @@ PHP_METHOD(Tensor_Matrix, max)
 {
 	zend_bool _8;
 	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _6$$3, _9$$4;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4849,6 +4836,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_9$$4);
 	ZVAL_UNDEF(&b);
@@ -4876,7 +4864,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1644);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1636);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4884,7 +4872,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1641);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1633);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4906,12 +4894,12 @@ PHP_METHOD(Tensor_Matrix, max)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1641);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1633);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	object_init_ex(return_value, tensor_columnvector_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
+	ZVAL_BOOL(&_10, 0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4954,7 +4942,7 @@ PHP_METHOD(Tensor_Matrix, median)
 {
 	zend_bool odd, _15;
 	zval b;
-	zval rowBuffer, median, _0, _1, _2, _3, _4, _5, *_6, _7, *_8, _14, _9$$4, _10$$5, _11$$5, _12$$5, _13$$5, _16$$7, _17$$8, _18$$8, _19$$8, _20$$8;
+	zval rowBuffer, median, _0, _1, _2, _3, _4, _5, *_6, _7, *_8, _14, _21, _9$$4, _10$$5, _11$$5, _12$$5, _13$$5, _16$$7, _17$$8, _18$$8, _19$$8, _20$$8;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, mid;
 	zval *this_ptr = getThis();
@@ -4969,6 +4957,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	ZVAL_UNDEF(&_5);
 	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_21);
 	ZVAL_UNDEF(&_9$$4);
 	ZVAL_UNDEF(&_10$$5);
 	ZVAL_UNDEF(&_11$$5);
@@ -5011,7 +5000,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1683);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1676);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5035,7 +5024,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1680);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1673);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5073,12 +5062,12 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1680);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1673);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	object_init_ex(return_value, tensor_columnvector_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
+	ZVAL_BOOL(&_21, 0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_21);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5096,7 +5085,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	zend_bool _0, _22;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, xHat;
-	zval *q_param = NULL, rowBuffer, _5, _6, _7, _8, *_9, _10, *_11, _21, _1$$3, _2$$3, _3$$3, _4$$3, _12$$4, _17$$4, _18$$4, _19$$4, _20$$4, _13$$5, _14$$5, _15$$5, _16$$5, _23$$6, _28$$6, _29$$6, _30$$6, _31$$6, _24$$7, _25$$7, _26$$7, _27$$7;
+	zval *q_param = NULL, rowBuffer, _5, _6, _7, _8, *_9, _10, *_11, _21, _32, _1$$3, _2$$3, _3$$3, _4$$3, _12$$4, _17$$4, _18$$4, _19$$4, _20$$4, _13$$5, _14$$5, _15$$5, _16$$5, _23$$6, _28$$6, _29$$6, _30$$6, _31$$6, _24$$7, _25$$7, _26$$7, _27$$7;
 	double q, t = 0, x, remainder;
 	zval *this_ptr = getThis();
 
@@ -5107,6 +5096,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_21);
+	ZVAL_UNDEF(&_32);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
@@ -5160,7 +5150,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1697);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1690);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5181,7 +5171,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1725);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1719);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5197,7 +5187,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1715);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1709);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5209,7 +5199,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1722);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1716);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5239,7 +5229,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1715);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1709);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5251,12 +5241,12 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1722);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1716);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
-	object_init_ex(return_value, tensor_columnvector_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &b);
+	ZVAL_BOOL(&_32, 0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_32);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5327,7 +5317,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1741);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1735);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5347,7 +5337,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 2, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1747);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1741);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5436,7 +5426,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 2, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1772);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1766);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5546,7 +5536,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1800);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1793);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5563,7 +5553,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_12 = &_10;
 	}
-	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1823);
+	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1816);
 	if (Z_TYPE_P(_12) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
 		{
@@ -5586,7 +5576,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1820);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1813);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
@@ -5623,7 +5613,7 @@ PHP_METHOD(Tensor_Matrix, round)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1820);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1813);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5776,7 +5766,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1859);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1852);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6053,7 +6043,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1925);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1918);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6151,7 +6141,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1945);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1938);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6261,7 +6251,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1965);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1958);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6304,7 +6294,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1979);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1972);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -6407,7 +6397,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1997);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1990);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6450,7 +6440,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2011);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2004);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -6538,7 +6528,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2035);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2028);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -6547,7 +6537,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2033);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2026);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -6570,14 +6560,14 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2033);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2026);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2038);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2031);
 		ZVAL_LONG(&_13$$6, 1);
 		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 29, &bigRows, &_13$$6);
 		zephir_check_call_status();
@@ -6665,7 +6655,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2061);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2054);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6741,7 +6731,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2080);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2073);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6817,7 +6807,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2099);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2092);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6893,7 +6883,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2118);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2111);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6970,7 +6960,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2138);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2131);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7047,7 +7037,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2158);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2151);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7124,7 +7114,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2178);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2171);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7200,7 +7190,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2197);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2190);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7277,7 +7267,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2217);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2210);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7354,7 +7344,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2237);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2230);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7430,7 +7420,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2256);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2249);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7506,7 +7496,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2275);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2268);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7587,7 +7577,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2295);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2288);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7670,7 +7660,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2319);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2312);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7753,7 +7743,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2343);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2336);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7836,7 +7826,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2367);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2360);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7919,7 +7909,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2391);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2384);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8002,7 +7992,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2415);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2408);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8086,7 +8076,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2440);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2433);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8169,7 +8159,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2464);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2457);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8252,7 +8242,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2488);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2481);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8335,7 +8325,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2512);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2505);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8418,7 +8408,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2536);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2529);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8502,7 +8492,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2561);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2554);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8585,7 +8575,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2585);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2578);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8668,7 +8658,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2609);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2602);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8751,7 +8741,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2633);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2626);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8834,7 +8824,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2657);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2650);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8917,7 +8907,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2681);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2674);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9000,7 +8990,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2705);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2698);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9083,7 +9073,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2729);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2722);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9166,7 +9156,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2753);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2746);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9249,7 +9239,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2777);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2770);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9332,7 +9322,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2801);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2794);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9415,7 +9405,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2825);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2818);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9498,7 +9488,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2849);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2842);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10162,7 +10152,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3034);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3027);
 	return;
 }
 
@@ -10213,7 +10203,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3058);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3051);
 	return;
 }
 
@@ -10273,7 +10263,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3072);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3065);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10290,7 +10280,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3077);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3070);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10302,7 +10292,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_9, &_8, "slice", NULL, 0, &_11, &_10);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10340,14 +10330,34 @@ PHP_METHOD(Tensor_Matrix, getIterator)
  */
 PHP_METHOD(Tensor_Matrix, __serialize)
 {
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "asArray", NULL, 0);
+	zephir_create_array(return_value, 3, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asArray", NULL, 0);
 	zephir_check_call_status();
+	zephir_array_update_string(return_value, SL("data"), &_0, PH_COPY | PH_SEPARATE);
+	zephir_memory_observe(&_1);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC);
+	zephir_array_update_string(return_value, SL("m"), &_1, PH_COPY | PH_SEPARATE);
+	ZEPHIR_OBS_NVAR(&_1);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC);
+	zephir_array_update_string(return_value, SL("n"), &_1, PH_COPY | PH_SEPARATE);
 	RETURN_MM();
 }
 
@@ -10355,14 +10365,14 @@ PHP_METHOD(Tensor_Matrix, __serialize)
  * Restore the matrix from the plain array of rows produced by
  * __serialize() by rebuilding its TensorBuffer and shape.
  *
- * @param float[][] data
+ * @param array<array<float>> data
  * @throws \Tensor\Exceptions\InvalidArgumentException
  */
 PHP_METHOD(Tensor_Matrix, __unserialize)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *data_param = NULL, rebuilt, _0, _1, _2;
+	zval *data_param = NULL, rebuilt, _0, _1, _2, _3, _4;
 	zval data;
 	zval *this_ptr = getThis();
 
@@ -10371,6 +10381,8 @@ PHP_METHOD(Tensor_Matrix, __unserialize)
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
@@ -10391,14 +10403,17 @@ PHP_METHOD(Tensor_Matrix, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &data);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_0, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_0);
-	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_1);
-	zephir_read_property_cached(&_2, &rebuilt, _zephir_prop_2, 0, PH_NOISY_CC | PH_READONLY);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_2);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3113);
+	ZVAL_BOOL(&_1, 0);
+	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_2, &rebuilt, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_2);
+	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3116);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_3);
+	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3117);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_4);
 	ZEPHIR_MM_RESTORE();
 }
 
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index 4b6b9a8..0ae0733 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -3,7 +3,6 @@ extern zend_class_entry *tensor_matrix_ce;
 
 ZEPHIR_INIT_CLASS(Tensor_Matrix);
 
-PHP_METHOD(Tensor_Matrix, fromArray);
 PHP_METHOD(Tensor_Matrix, identity);
 PHP_METHOD(Tensor_Matrix, zeros);
 PHP_METHOD(Tensor_Matrix, ones);
@@ -13,6 +12,7 @@ PHP_METHOD(Tensor_Matrix, rand);
 PHP_METHOD(Tensor_Matrix, gaussian);
 PHP_METHOD(Tensor_Matrix, poisson);
 PHP_METHOD(Tensor_Matrix, uniform);
+PHP_METHOD(Tensor_Matrix, fromArray);
 PHP_METHOD(Tensor_Matrix, __construct);
 PHP_METHOD(Tensor_Matrix, shape);
 PHP_METHOD(Tensor_Matrix, shapeString);
@@ -23,15 +23,13 @@ PHP_METHOD(Tensor_Matrix, n);
 PHP_METHOD(Tensor_Matrix, rowAsVector);
 PHP_METHOD(Tensor_Matrix, columnAsVector);
 PHP_METHOD(Tensor_Matrix, diagonalAsVector);
-PHP_METHOD(Tensor_Matrix, asVector);
-PHP_METHOD(Tensor_Matrix, asTensorBuffer);
+PHP_METHOD(Tensor_Matrix, asVectors);
+PHP_METHOD(Tensor_Matrix, asColumnVectors);
+PHP_METHOD(Tensor_Matrix, flatten);
 PHP_METHOD(Tensor_Matrix, asArray);
+PHP_METHOD(Tensor_Matrix, asTensorBuffer);
 PHP_METHOD(Tensor_Matrix, asRowBuffers);
-PHP_METHOD(Tensor_Matrix, asRowVectors);
 PHP_METHOD(Tensor_Matrix, asColumnBuffers);
-PHP_METHOD(Tensor_Matrix, asColumnVectors);
-PHP_METHOD(Tensor_Matrix, asVectors);
-PHP_METHOD(Tensor_Matrix, flatten);
 PHP_METHOD(Tensor_Matrix, map);
 PHP_METHOD(Tensor_Matrix, reduce);
 PHP_METHOD(Tensor_Matrix, transpose);
@@ -162,11 +160,6 @@ PHP_METHOD(Tensor_Matrix, getIterator);
 PHP_METHOD(Tensor_Matrix, __serialize);
 PHP_METHOD(Tensor_Matrix, __unserialize);
 
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromarray, 0, 1, Tensor\\Matrix, 0)
-	ZEND_ARG_ARRAY_INFO(0, a, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
-ZEND_END_ARG_INFO()
-
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_identity, 0, 1, Tensor\\Matrix, 0)
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
@@ -212,6 +205,11 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_uniform, 0, 2, Tens
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_fromarray, 0, 1, Tensor\\Matrix, 0)
+	ZEND_ARG_ARRAY_INFO(0, a, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_matrix___construct, 0, 0, 3)
 	ZEND_ARG_OBJ_INFO(0, a, Tensor\\TensorBuffer, 0)
 	ZEND_ARG_TYPE_INFO(0, m, IS_LONG, 0)
@@ -247,31 +245,25 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_diagonalasvector, 0, 0, Tensor\\Vector, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_asvector, 0, 0, Tensor\\Vector, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_astensorbuffer, 0, 0, Tensor\\TensorBuffer, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asarray, 0, 0, IS_ARRAY, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asvectors, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asrowbuffers, 0, 0, IS_ARRAY, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_ascolumnvectors, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asrowvectors, 0, 0, IS_ARRAY, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_flatten, 0, 0, Tensor\\Vector, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_ascolumnbuffers, 0, 0, IS_ARRAY, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asarray, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_ascolumnvectors, 0, 0, IS_ARRAY, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_astensorbuffer, 0, 0, Tensor\\TensorBuffer, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asvectors, 0, 0, IS_ARRAY, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_asrowbuffers, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_flatten, 0, 0, Tensor\\Vector, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_matrix_ascolumnbuffers, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_map, 0, 1, Tensor\\Matrix, 0)
@@ -753,7 +745,6 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_matrix___unserialize, 0, 0, 1)
 ZEND_END_ARG_INFO()
 
 ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
-	PHP_ME(Tensor_Matrix, fromArray, arginfo_tensor_matrix_fromarray, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, identity, arginfo_tensor_matrix_identity, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, zeros, arginfo_tensor_matrix_zeros, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, ones, arginfo_tensor_matrix_ones, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
@@ -763,6 +754,7 @@ ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, gaussian, arginfo_tensor_matrix_gaussian, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, poisson, arginfo_tensor_matrix_poisson, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, uniform, arginfo_tensor_matrix_uniform, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	PHP_ME(Tensor_Matrix, fromArray, arginfo_tensor_matrix_fromarray, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Matrix, __construct, arginfo_tensor_matrix___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 	PHP_ME(Tensor_Matrix, shape, arginfo_tensor_matrix_shape, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, shapeString, arginfo_tensor_matrix_shapestring, ZEND_ACC_PUBLIC)
@@ -773,15 +765,13 @@ ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, rowAsVector, arginfo_tensor_matrix_rowasvector, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, columnAsVector, arginfo_tensor_matrix_columnasvector, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, diagonalAsVector, arginfo_tensor_matrix_diagonalasvector, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_Matrix, asVector, arginfo_tensor_matrix_asvector, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_Matrix, asTensorBuffer, arginfo_tensor_matrix_astensorbuffer, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, asVectors, arginfo_tensor_matrix_asvectors, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, asColumnVectors, arginfo_tensor_matrix_ascolumnvectors, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, flatten, arginfo_tensor_matrix_flatten, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asArray, arginfo_tensor_matrix_asarray, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, asTensorBuffer, arginfo_tensor_matrix_astensorbuffer, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asRowBuffers, arginfo_tensor_matrix_asrowbuffers, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_Matrix, asRowVectors, arginfo_tensor_matrix_asrowvectors, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, asColumnBuffers, arginfo_tensor_matrix_ascolumnbuffers, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_Matrix, asColumnVectors, arginfo_tensor_matrix_ascolumnvectors, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_Matrix, asVectors, arginfo_tensor_matrix_asvectors, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_Matrix, flatten, arginfo_tensor_matrix_flatten, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, map, arginfo_tensor_matrix_map, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, reduce, arginfo_tensor_matrix_reduce, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, transpose, arginfo_tensor_matrix_transpose, ZEND_ACC_PUBLIC)
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 40385f5..6806290 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -12,11 +12,11 @@
 #include <Zend/zend_interfaces.h>
 
 #include "kernel/main.h"
-#include "kernel/object.h"
 #include "kernel/memory.h"
 #include "kernel/fcall.h"
 #include "kernel/array.h"
 #include "kernel/operators.h"
+#include "kernel/object.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
 #include "kernel/string.h"
@@ -29,6 +29,8 @@
  * A decorator that wraps the kernel Buffer class and provides additional
  * operations such as sorting and slicing.
  *
+ * @internal
+ *
  * @category    Scientific Computing
  * @package     Rubix/Tensor
  * @author      Andrew DalPino
@@ -46,27 +48,6 @@ ZEPHIR_INIT_CLASS(Tensor_TensorBuffer)
 	return SUCCESS;
 }
 
-/**
- * @param \Tensor\Buffer buffer
- */
-PHP_METHOD(Tensor_TensorBuffer, __construct)
-{
-	zval *buffer, buffer_sub;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&buffer_sub);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
-	}
-
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_OBJECT_OF_CLASS(buffer, zephir_get_internal_ce(SL("tensor\\buffer")))
-	ZEND_PARSE_PARAMETERS_END();
-	zephir_fetch_params_without_memory_grow(1, 0, &buffer);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 20, buffer);
-}
-
 /**
  * Build a buffer by concatenating an array of buffers into a single
  * contiguous buffer.
@@ -105,22 +86,22 @@ PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
 		array_init(&_0$$3);
 		tensor_buffer_from_array(&zero$$3, &_0$$3);
 		object_init_ex(return_value, tensor_tensorbuffer_ce);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &zero$$3);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &zero$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
 	if (UNEXPECTED(rows == 1)) {
 		object_init_ex(return_value, tensor_tensorbuffer_ce);
 		zephir_memory_observe(&_1$$4);
-		zephir_array_fetch_long(&_1$$4, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 49);
+		zephir_array_fetch_long(&_1$$4, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 43);
 		ZEPHIR_CALL_METHOD(&_2$$4, &_1$$4, "asBuffer", NULL, 0);
 		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_2$$4);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_2$$4);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
 	zephir_memory_observe(&_3);
-	zephir_array_fetch_long(&_3, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 52);
+	zephir_array_fetch_long(&_3, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 46);
 	ZVAL_LONG(&_4, 1);
 	ZEPHIR_CALL_FUNCTION(&_5, "array_slice", NULL, 29, &buffers, &_4);
 	zephir_check_call_status();
@@ -129,46 +110,30 @@ PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
 	ZEPHIR_CALL_METHOD(&_6, &b, "asBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_6);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
 
 /**
- * Return the underlying buffer.
- *
- * @return \Tensor\Buffer
- */
-PHP_METHOD(Tensor_TensorBuffer, asBuffer)
-{
-
-	RETURN_MEMBER(getThis(), "buffer");
-}
-
-/**
- * Return the number of elements in the buffer.
- *
- * @return int
+ * @param \Tensor\Buffer buffer
  */
-PHP_METHOD(Tensor_TensorBuffer, count)
+PHP_METHOD(Tensor_TensorBuffer, __construct)
 {
-	zval _0;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *buffer, buffer_sub;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&buffer_sub);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
 	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "count", NULL, 0);
-	zephir_check_call_status();
-	RETURN_MM();
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_OBJECT_OF_CLASS(buffer, zephir_get_internal_ce(SL("tensor\\buffer")))
+	ZEND_PARSE_PARAMETERS_END();
+	zephir_fetch_params_without_memory_grow(1, 0, &buffer);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 20, buffer);
 }
 
 /**
@@ -197,32 +162,6 @@ PHP_METHOD(Tensor_TensorBuffer, type)
 	RETURN_MM();
 }
 
-/**
- * Return the buffer as a PHP array.
- *
- * @return list<float>
- */
-PHP_METHOD(Tensor_TensorBuffer, toArray)
-{
-	zval _0;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
-	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "toArray", NULL, 0);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
 /**
  * Return the element at the given index.
  *
@@ -251,7 +190,7 @@ PHP_METHOD(Tensor_TensorBuffer, get)
 	zephir_fetch_params(1, 1, 0, &index_param);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
 	zephir_memory_observe(&_1);
-	zephir_array_fetch_long(&_1, &_0, index, PH_NOISY, "tensor/tensorbuffer.zep", 105);
+	zephir_array_fetch_long(&_1, &_0, index, PH_NOISY, "tensor/tensorbuffer.zep", 77);
 	RETURN_CCTOR(&_1);
 }
 
@@ -382,7 +321,7 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 		ZEPHIR_CONCAT_SS(&_5$$3, "Offset and length", " must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 143);
+		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 115);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -392,7 +331,7 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 	ZVAL_LONG(&_8, length);
 	tensor_buffer_slice(&b, &_6, &_7, &_8);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -447,7 +386,7 @@ PHP_METHOD(Tensor_TensorBuffer, map)
 	} else {
 		_1 = &a;
 	}
-	zephir_is_iterable(_1, 0, "tensor/tensorbuffer.zep", 171);
+	zephir_is_iterable(_1, 0, "tensor/tensorbuffer.zep", 143);
 	if (Z_TYPE_P(_1) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
 		{
@@ -455,7 +394,7 @@ PHP_METHOD(Tensor_TensorBuffer, map)
 			ZVAL_COPY(&value, _3);
 			ZEPHIR_CALL_ZVAL_FUNCTION(&_4$$3, callback, NULL, 0, &value);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 168);
+			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 140);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
@@ -477,14 +416,14 @@ PHP_METHOD(Tensor_TensorBuffer, map)
 			zephir_check_call_status();
 				ZEPHIR_CALL_ZVAL_FUNCTION(&_7$$4, callback, NULL, 0, &value);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 168);
+				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 140);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&value);
 	ZEPHIR_INIT_VAR(&buffer);
 	tensor_buffer_from_array(&buffer, &b);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &buffer);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &buffer);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -675,7 +614,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 		ZEPHIR_CONCAT_SS(&_7$$3, "Offset, length, and", " stride must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_6$$3, "tensor/tensorbuffer.zep", 250);
+		zephir_throw_exception_debug(&_6$$3, "tensor/tensorbuffer.zep", 222);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -686,7 +625,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 	ZVAL_LONG(&_11, stride);
 	tensor_buffer_slice_strided(&b, &_8, &_9, &_10, &_11);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -729,7 +668,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_get_arrval(&buffers, buffers_param);
 	ZEPHIR_INIT_VAR(&unwrapped);
 	array_init(&unwrapped);
-	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 275);
+	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 247);
 	if (Z_TYPE_P(&buffers) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&buffers), _0)
 		{
@@ -737,7 +676,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			ZVAL_COPY(&buffer, _0);
 			ZEPHIR_CALL_METHOD(&_1$$3, &buffer, "asBuffer", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 272);
+			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 244);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, &buffers, "rewind", NULL, 0);
@@ -759,7 +698,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_4$$4, &buffer, "asBuffer", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 272);
+				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 244);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -767,7 +706,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
 	tensor_buffer_concat(&b, &_5, &unwrapped);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -824,7 +763,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Chunk length must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 292);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 264);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -841,7 +780,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 	} else {
 		_6 = &buffers;
 	}
-	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 305);
+	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 277);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -849,9 +788,9 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			ZVAL_COPY(&buffer, _8);
 			ZEPHIR_INIT_NVAR(&_9$$4);
 			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
-			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 14, &buffer);
+			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 13, &buffer);
 			zephir_check_call_status();
-			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 302);
+			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 274);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -873,9 +812,9 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_13$$5);
 				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
-				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 14, &buffer);
+				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 13, &buffer);
 				zephir_check_call_status();
-				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 302);
+				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 274);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -925,7 +864,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Times must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 320);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 292);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -934,7 +873,70 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 	ZVAL_LONG(&_5, times);
 	tensor_buffer_repeat(&b, &_4, &_5);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &b);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return the underlying buffer.
+ *
+ * @return \Tensor\Buffer
+ */
+PHP_METHOD(Tensor_TensorBuffer, asBuffer)
+{
+
+	RETURN_MEMBER(getThis(), "buffer");
+}
+
+/**
+ * Return the number of elements in the buffer.
+ *
+ * @return int
+ */
+PHP_METHOD(Tensor_TensorBuffer, count)
+{
+	zval _0;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "count", NULL, 0);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return the buffer as a PHP array.
+ *
+ * @return list<float>
+ */
+PHP_METHOD(Tensor_TensorBuffer, toArray)
+{
+	zval _0;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_RETURN_CALL_METHOD(&_0, "toArray", NULL, 0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/tensorbuffer.zep.h b/ext/tensor/tensorbuffer.zep.h
index d312d3f..1a6154f 100644
--- a/ext/tensor/tensorbuffer.zep.h
+++ b/ext/tensor/tensorbuffer.zep.h
@@ -3,12 +3,9 @@ extern zend_class_entry *tensor_tensorbuffer_ce;
 
 ZEPHIR_INIT_CLASS(Tensor_TensorBuffer);
 
-PHP_METHOD(Tensor_TensorBuffer, __construct);
 PHP_METHOD(Tensor_TensorBuffer, fromBuffers);
-PHP_METHOD(Tensor_TensorBuffer, asBuffer);
-PHP_METHOD(Tensor_TensorBuffer, count);
+PHP_METHOD(Tensor_TensorBuffer, __construct);
 PHP_METHOD(Tensor_TensorBuffer, type);
-PHP_METHOD(Tensor_TensorBuffer, toArray);
 PHP_METHOD(Tensor_TensorBuffer, get);
 PHP_METHOD(Tensor_TensorBuffer, set);
 PHP_METHOD(Tensor_TensorBuffer, sort);
@@ -24,27 +21,21 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided);
 PHP_METHOD(Tensor_TensorBuffer, concat);
 PHP_METHOD(Tensor_TensorBuffer, split);
 PHP_METHOD(Tensor_TensorBuffer, repeat);
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_tensorbuffer___construct, 0, 0, 1)
-	ZEND_ARG_OBJ_INFO(0, buffer, Tensor\\Buffer, 0)
-ZEND_END_ARG_INFO()
+PHP_METHOD(Tensor_TensorBuffer, asBuffer);
+PHP_METHOD(Tensor_TensorBuffer, count);
+PHP_METHOD(Tensor_TensorBuffer, toArray);
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_frombuffers, 0, 1, Tensor\\TensorBuffer, 0)
 	ZEND_ARG_ARRAY_INFO(0, buffers, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_asbuffer, 0, 0, Tensor\\Buffer, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_count, 0, 0, IS_LONG, 0)
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_tensorbuffer___construct, 0, 0, 1)
+	ZEND_ARG_OBJ_INFO(0, buffer, Tensor\\Buffer, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_type, 0, 0, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_toarray, 0, 0, IS_ARRAY, 0)
-ZEND_END_ARG_INFO()
-
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_tensorbuffer_get, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, index, IS_LONG, 0)
 ZEND_END_ARG_INFO()
@@ -105,13 +96,19 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_repeat, 0, 1,
 	ZEND_ARG_TYPE_INFO(0, times, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_asbuffer, 0, 0, Tensor\\Buffer, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_count, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_toarray, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
 ZEPHIR_INIT_FUNCS(tensor_tensorbuffer_method_entry) {
-	PHP_ME(Tensor_TensorBuffer, __construct, arginfo_tensor_tensorbuffer___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 	PHP_ME(Tensor_TensorBuffer, fromBuffers, arginfo_tensor_tensorbuffer_frombuffers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	PHP_ME(Tensor_TensorBuffer, asBuffer, arginfo_tensor_tensorbuffer_asbuffer, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_TensorBuffer, count, arginfo_tensor_tensorbuffer_count, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, __construct, arginfo_tensor_tensorbuffer___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 	PHP_ME(Tensor_TensorBuffer, type, arginfo_tensor_tensorbuffer_type, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_TensorBuffer, toArray, arginfo_tensor_tensorbuffer_toarray, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, get, arginfo_tensor_tensorbuffer_get, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, set, arginfo_tensor_tensorbuffer_set, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, sort, arginfo_tensor_tensorbuffer_sort, ZEND_ACC_PUBLIC)
@@ -127,5 +124,8 @@ ZEPHIR_INIT_FUNCS(tensor_tensorbuffer_method_entry) {
 	PHP_ME(Tensor_TensorBuffer, concat, arginfo_tensor_tensorbuffer_concat, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, split, arginfo_tensor_tensorbuffer_split, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, repeat, arginfo_tensor_tensorbuffer_repeat, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, asBuffer, arginfo_tensor_tensorbuffer_asbuffer, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, count, arginfo_tensor_tensorbuffer_count, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_TensorBuffer, toArray, arginfo_tensor_tensorbuffer_toarray, ZEND_ACC_PUBLIC)
 	PHP_FE_END
 };
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 2dc6107..04615a0 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -190,13 +190,13 @@ PHP_METHOD(Tensor_Vector, fill)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZVAL_LONG(&_2, 0);
 	ZVAL_LONG(&_12, n);
 	ZVAL_DOUBLE(&_13, value);
 	ZEPHIR_CALL_FUNCTION(&_14, "array_fill", NULL, 4, &_2, &_12, &_13);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_14);
+	ZVAL_BOOL(&_2, 0);
+	ZEPHIR_RETURN_CALL_STATIC("fromArray", NULL, 0, &_14, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -213,7 +213,7 @@ PHP_METHOD(Tensor_Vector, rand)
 	zval a;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_6 = NULL;
-	zval *n_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4, _5$$4, _7$$4;
+	zval *n_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4, _8, _5$$4, _7$$4;
 	zend_long n, ZEPHIR_LAST_CALL_STATUS, max;
 
 	ZVAL_UNDEF(&_0$$3);
@@ -221,6 +221,7 @@ PHP_METHOD(Tensor_Vector, rand)
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_5$$4);
 	ZVAL_UNDEF(&_7$$4);
 	ZVAL_UNDEF(&a);
@@ -246,21 +247,21 @@ PHP_METHOD(Tensor_Vector, rand)
 	}
 	ZEPHIR_INIT_VAR(&a);
 	array_init(&a);
-	ZEPHIR_CALL_FUNCTION(&_4, "getrandmax", NULL, 6);
+	ZEPHIR_CALL_FUNCTION(&_4, "getrandmax", NULL, 5);
 	zephir_check_call_status();
 	max = zephir_get_intval(&_4);
 	while (1) {
 		if (!(zephir_fast_count_int(&a) < n)) {
 			break;
 		}
-		ZEPHIR_CALL_FUNCTION(&_5$$4, "rand", &_6, 7);
+		ZEPHIR_CALL_FUNCTION(&_5$$4, "rand", &_6, 6);
 		zephir_check_call_status();
 		ZEPHIR_INIT_NVAR(&_7$$4);
 		ZVAL_DOUBLE(&_7$$4, zephir_safe_div_zval_long(&_5$$4, max));
 		zephir_array_append(&a, &_7$$4, PH_SEPARATE, "tensor/vector.zep", 100);
 	}
-	object_init_ex(return_value, zend_get_called_scope(execute_data));
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
+	ZVAL_BOOL(&_8, 0);
+	ZEPHIR_RETURN_CALL_STATIC("fromArray", NULL, 0, &a, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -279,7 +280,7 @@ PHP_METHOD(Tensor_Vector, gaussian)
 	double r = 0, phi = 0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_6 = NULL, *_9 = NULL;
-	zval *n_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4, _5$$4, _7$$4, _8$$4, _10$$4, _11$$4, _12$$4, _13$$4;
+	zval *n_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4, _14, _5$$4, _7$$4, _8$$4, _10$$4, _11$$4, _12$$4, _13$$4;
 	zend_long n, ZEPHIR_LAST_CALL_STATUS, max;
 
 	ZVAL_UNDEF(&_0$$3);
@@ -287,6 +288,7 @@ PHP_METHOD(Tensor_Vector, gaussian)
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_14);
 	ZVAL_UNDEF(&_5$$4);
 	ZVAL_UNDEF(&_7$$4);
 	ZVAL_UNDEF(&_8$$4);
@@ -317,21 +319,21 @@ PHP_METHOD(Tensor_Vector, gaussian)
 	}
 	ZEPHIR_INIT_VAR(&a);
 	array_init(&a);
-	ZEPHIR_CALL_FUNCTION(&_4, "getrandmax", NULL, 6);
+	ZEPHIR_CALL_FUNCTION(&_4, "getrandmax", NULL, 5);
 	zephir_check_call_status();
 	max = zephir_get_intval(&_4);
 	while (1) {
 		if (!(zephir_fast_count_int(&a) < n)) {
 			break;
 		}
-		ZEPHIR_CALL_FUNCTION(&_5$$4, "rand", &_6, 7);
+		ZEPHIR_CALL_FUNCTION(&_5$$4, "rand", &_6, 6);
 		zephir_check_call_status();
 		ZVAL_DOUBLE(&_7$$4, zephir_safe_div_zval_long(&_5$$4, max));
-		ZEPHIR_CALL_FUNCTION(&_8$$4, "log", &_9, 8, &_7$$4);
+		ZEPHIR_CALL_FUNCTION(&_8$$4, "log", &_9, 7, &_7$$4);
 		zephir_check_call_status();
 		ZVAL_DOUBLE(&_7$$4, (-2.0 * zephir_get_numberval(&_8$$4)));
 		r =  (sqrt((-2.0 * zephir_get_numberval(&_8$$4))));
-		ZEPHIR_CALL_FUNCTION(&_10$$4, "rand", &_6, 7);
+		ZEPHIR_CALL_FUNCTION(&_10$$4, "rand", &_6, 6);
 		zephir_check_call_status();
 		phi =  ((zephir_safe_div_zval_long(&_10$$4, max) * 6.28318530718));
 		ZVAL_DOUBLE(&_11$$4, phi);
@@ -345,12 +347,12 @@ PHP_METHOD(Tensor_Vector, gaussian)
 	}
 	if (zephir_fast_count_int(&a) > n) {
 		ZEPHIR_MAKE_REF(&a);
-		ZEPHIR_CALL_FUNCTION(NULL, "array_pop", NULL, 9, &a);
+		ZEPHIR_CALL_FUNCTION(NULL, "array_pop", NULL, 8, &a);
 		ZEPHIR_UNREF(&a);
 		zephir_check_call_status();
 	}
-	object_init_ex(return_value, zend_get_called_scope(execute_data));
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
+	ZVAL_BOOL(&_14, 0);
+	ZEPHIR_RETURN_CALL_STATIC("fromArray", NULL, 0, &a, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -439,10 +441,10 @@ PHP_METHOD(Tensor_Vector, poisson)
 	ZEPHIR_INIT_VAR(&a);
 	array_init(&a);
 	ZVAL_DOUBLE(&_11, -lambda);
-	ZEPHIR_CALL_FUNCTION(&_12, "exp", NULL, 10, &_11);
+	ZEPHIR_CALL_FUNCTION(&_12, "exp", NULL, 9, &_11);
 	zephir_check_call_status();
 	l =  (zephir_get_doubleval(&_12));
-	ZEPHIR_CALL_FUNCTION(&_13, "getrandmax", NULL, 6);
+	ZEPHIR_CALL_FUNCTION(&_13, "getrandmax", NULL, 5);
 	zephir_check_call_status();
 	max = zephir_get_intval(&_13);
 	while (1) {
@@ -456,7 +458,7 @@ PHP_METHOD(Tensor_Vector, poisson)
 				break;
 			}
 			k++;
-			ZEPHIR_CALL_FUNCTION(&_14$$7, "rand", &_15, 7);
+			ZEPHIR_CALL_FUNCTION(&_14$$7, "rand", &_15, 6);
 			zephir_check_call_status();
 			p *=  (zephir_safe_div_zval_long(&_14$$7, max));
 		}
@@ -464,8 +466,8 @@ PHP_METHOD(Tensor_Vector, poisson)
 		ZVAL_DOUBLE(&_16$$6, (k - 1.0));
 		zephir_array_append(&a, &_16$$6, PH_SEPARATE, "tensor/vector.zep", 185);
 	}
-	object_init_ex(return_value, zend_get_called_scope(execute_data));
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
+	ZVAL_BOOL(&_11, 0);
+	ZEPHIR_RETURN_CALL_STATIC("fromArray", NULL, 0, &a, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -482,7 +484,7 @@ PHP_METHOD(Tensor_Vector, uniform)
 	zval a;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_8 = NULL;
-	zval *n_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4, _5$$4, _6$$4, _7$$4, _9$$4;
+	zval *n_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4, _10, _5$$4, _6$$4, _7$$4, _9$$4;
 	zend_long n, ZEPHIR_LAST_CALL_STATUS, max;
 
 	ZVAL_UNDEF(&_0$$3);
@@ -490,6 +492,7 @@ PHP_METHOD(Tensor_Vector, uniform)
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_5$$4);
 	ZVAL_UNDEF(&_6$$4);
 	ZVAL_UNDEF(&_7$$4);
@@ -517,7 +520,7 @@ PHP_METHOD(Tensor_Vector, uniform)
 	}
 	ZEPHIR_INIT_VAR(&a);
 	array_init(&a);
-	ZEPHIR_CALL_FUNCTION(&_4, "getrandmax", NULL, 6);
+	ZEPHIR_CALL_FUNCTION(&_4, "getrandmax", NULL, 5);
 	zephir_check_call_status();
 	max = zephir_get_intval(&_4);
 	while (1) {
@@ -526,14 +529,14 @@ PHP_METHOD(Tensor_Vector, uniform)
 		}
 		ZVAL_LONG(&_5$$4, -max);
 		ZVAL_LONG(&_6$$4, max);
-		ZEPHIR_CALL_FUNCTION(&_7$$4, "rand", &_8, 7, &_5$$4, &_6$$4);
+		ZEPHIR_CALL_FUNCTION(&_7$$4, "rand", &_8, 6, &_5$$4, &_6$$4);
 		zephir_check_call_status();
 		ZEPHIR_INIT_NVAR(&_9$$4);
 		ZVAL_DOUBLE(&_9$$4, zephir_safe_div_zval_long(&_7$$4, max));
 		zephir_array_append(&a, &_9$$4, PH_SEPARATE, "tensor/vector.zep", 210);
 	}
-	object_init_ex(return_value, zend_get_called_scope(execute_data));
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
+	ZVAL_BOOL(&_10, 0);
+	ZEPHIR_RETURN_CALL_STATIC("fromArray", NULL, 0, &a, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -573,13 +576,13 @@ PHP_METHOD(Tensor_Vector, range)
 	} else {
 		interval = zephir_get_doubleval(interval_param);
 	}
-	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZVAL_DOUBLE(&_0, start);
 	ZVAL_DOUBLE(&_1, end);
 	ZVAL_DOUBLE(&_2, interval);
-	ZEPHIR_CALL_FUNCTION(&_3, "range", NULL, 11, &_0, &_1, &_2);
+	ZEPHIR_CALL_FUNCTION(&_3, "range", NULL, 10, &_0, &_1, &_2);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_3);
+	ZVAL_BOOL(&_0, 0);
+	ZEPHIR_RETURN_CALL_STATIC("fromArray", NULL, 0, &_3, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -642,7 +645,7 @@ PHP_METHOD(Tensor_Vector, linspace)
 	}
 	k = (n - 1);
 	ZVAL_DOUBLE(&_4, (max - min));
-	ZEPHIR_CALL_FUNCTION(&_5, "abs", NULL, 12, &_4);
+	ZEPHIR_CALL_FUNCTION(&_5, "abs", NULL, 11, &_4);
 	zephir_check_call_status();
 	interval =  (zephir_safe_div_zval_long(&_5, k));
 	ZEPHIR_INIT_VAR(&a);
@@ -655,7 +658,7 @@ PHP_METHOD(Tensor_Vector, linspace)
 			break;
 		}
 		ZEPHIR_MAKE_REF(&a);
-		ZEPHIR_CALL_FUNCTION(&_7$$5, "end", &_8, 13, &a);
+		ZEPHIR_CALL_FUNCTION(&_7$$5, "end", &_8, 12, &a);
 		ZEPHIR_UNREF(&a);
 		zephir_check_call_status();
 		ZEPHIR_INIT_NVAR(&_9$$5);
@@ -665,33 +668,153 @@ PHP_METHOD(Tensor_Vector, linspace)
 	ZEPHIR_INIT_NVAR(&_6);
 	ZVAL_DOUBLE(&_6, max);
 	zephir_array_append(&a, &_6, PH_SEPARATE, "tensor/vector.zep", 259);
-	object_init_ex(return_value, tensor_vector_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &a);
+	ZVAL_BOOL(&_4, 0);
+	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &a, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
 
 /**
- * Construct a new vector from a PHP array of elements or an existing
- * TensorBuffer.
+ * Build a new vector from a flat PHP array of numeric elements.
  *
- * @param float[] a
+ * @param array a
+ * @param bool validate
+ * @throws \Tensor\Exceptions\InvalidArgumentException
+ * @return self
+ */
+PHP_METHOD(Tensor_Vector, fromArray)
+{
+	zval _5$$4, _12$$6;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zephir_fcall_cache_entry *_6 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zend_bool validate, _9, _3$$3, _10$$5;
+	zval *a_param = NULL, *validate_param = NULL, valueA, _0, *_2, _8, buffer, _14, _7$$3, _4$$4, _13$$5, _11$$6;
+	zval a, flat, _1;
+
+	ZVAL_UNDEF(&a);
+	ZVAL_UNDEF(&flat);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&buffer);
+	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_7$$3);
+	ZVAL_UNDEF(&_4$$4);
+	ZVAL_UNDEF(&_13$$5);
+	ZVAL_UNDEF(&_11$$6);
+	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_12$$6);
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_BOOL(validate)
+	ZEND_PARSE_PARAMETERS_END();
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_fetch_params(1, 1, 1, &a_param, &validate_param);
+	zephir_get_arrval(&a, a_param);
+	if (!validate_param) {
+		validate = 1;
+	} else {
+		}
+	ZEPHIR_INIT_VAR(&flat);
+	array_init(&flat);
+	ZEPHIR_CPY_WRT(&_0, &a);
+	zephir_get_arrval(&_1, &_0);
+	zephir_is_iterable(&_1, 0, "tensor/vector.zep", 287);
+	if (Z_TYPE_P(&_1) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_1), _2)
+		{
+			ZEPHIR_INIT_NVAR(&valueA);
+			ZVAL_COPY(&valueA, _2);
+			_3$$3 = validate;
+			if (_3$$3) {
+				_3$$3 = Z_TYPE_P(&valueA) == IS_ARRAY;
+			}
+			if (UNEXPECTED(_3$$3)) {
+				ZEPHIR_INIT_NVAR(&_4$$4);
+				object_init_ex(&_4$$4, tensor_exceptions_invalidargumentexception_ce);
+				ZEPHIR_INIT_NVAR(&_5$$4);
+				ZEPHIR_CONCAT_SS(&_5$$4, "Vector requires a", " flat array of numeric elements.");
+				ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", &_6, 2, &_5$$4);
+				zephir_check_call_status();
+				zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 281);
+				ZEPHIR_MM_RESTORE();
+				return;
+			}
+			ZEPHIR_INIT_NVAR(&_7$$3);
+			ZVAL_DOUBLE(&_7$$3, zephir_get_doubleval(&valueA));
+			zephir_array_append(&flat, &_7$$3, PH_SEPARATE, "tensor/vector.zep", 284);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, &_1, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_9 = 1;
+		while (1) {
+			if (_9) {
+				_9 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, &_1, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_8, &_1, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_8)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&valueA, &_1, "current", NULL, 0);
+			zephir_check_call_status();
+				_10$$5 = validate;
+				if (_10$$5) {
+					_10$$5 = Z_TYPE_P(&valueA) == IS_ARRAY;
+				}
+				if (UNEXPECTED(_10$$5)) {
+					ZEPHIR_INIT_NVAR(&_11$$6);
+					object_init_ex(&_11$$6, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_INIT_NVAR(&_12$$6);
+					ZEPHIR_CONCAT_SS(&_12$$6, "Vector requires a", " flat array of numeric elements.");
+					ZEPHIR_CALL_METHOD(NULL, &_11$$6, "__construct", &_6, 2, &_12$$6);
+					zephir_check_call_status();
+					zephir_throw_exception_debug(&_11$$6, "tensor/vector.zep", 281);
+					ZEPHIR_MM_RESTORE();
+					return;
+				}
+				ZEPHIR_INIT_NVAR(&_13$$5);
+				ZVAL_DOUBLE(&_13$$5, zephir_get_doubleval(&valueA));
+				zephir_array_append(&flat, &_13$$5, PH_SEPARATE, "tensor/vector.zep", 284);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&valueA);
+	ZEPHIR_INIT_VAR(&buffer);
+	tensor_buffer_from_array(&buffer, &flat);
+	object_init_ex(return_value, zend_get_called_scope(execute_data));
+	ZEPHIR_INIT_VAR(&_14);
+	object_init_ex(&_14, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, &_14, "__construct", NULL, 13, &buffer);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_14);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Construct a new vector from a TensorBuffer holding its elements.
+ *
+ * @param \Tensor\TensorBuffer a
  * @throws \Tensor\Exceptions\InvalidArgumentException
  */
 PHP_METHOD(Tensor_Vector, __construct)
 {
-	zval _1$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *a = NULL, a_sub, buffer, _2, _3, _0$$4;
+	zval *a, a_sub, _0, _1;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&a_sub);
-	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_3);
-	ZVAL_UNDEF(&_0$$4);
-	ZVAL_UNDEF(&_1$$4);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -702,35 +825,16 @@ PHP_METHOD(Tensor_Vector, __construct)
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_ZVAL(a)
+		Z_PARAM_OBJECT_OF_CLASS(a, zephir_get_internal_ce(SL("tensor\\tensorbuffer")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &a);
-	ZEPHIR_SEPARATE_PARAM(a);
-	if (Z_TYPE_P(a) == IS_ARRAY) {
-		ZEPHIR_INIT_VAR(&buffer);
-		tensor_buffer_from_array(&buffer, a);
-		ZEPHIR_INIT_NVAR(a);
-		object_init_ex(a, tensor_tensorbuffer_ce);
-		ZEPHIR_CALL_METHOD(NULL, a, "__construct", NULL, 14, &buffer);
-		zephir_check_call_status();
-	} else if (!(zephir_instance_of_ev(a, tensor_tensorbuffer_ce))) {
-		ZEPHIR_INIT_VAR(&_0$$4);
-		object_init_ex(&_0$$4, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_INIT_VAR(&_1$$4);
-		ZEPHIR_CONCAT_SS(&_1$$4, "Vector requires", " an array or TensorBuffer object.");
-		ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_1$$4);
-		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$4, "tensor/vector.zep", 281);
-		ZEPHIR_MM_RESTORE();
-		return;
-	}
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, a);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_3, &_2, "count", NULL, 0);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "count", NULL, 0);
 	zephir_check_call_status();
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_3);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_1);
 	ZEPHIR_MM_RESTORE();
 }
 
@@ -981,7 +1085,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_SS(&_2$$3, "The number of rows", " and/or columns cannot be less than 0.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 390);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 406);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -998,7 +1102,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_VSSVS(&_7$$4, &_6$$4, " elements", " are needed but vector only has ", &_5$$4, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 397);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 413);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1033,7 +1137,7 @@ PHP_METHOD(Tensor_Vector, transpose)
 
 	object_init_ex(return_value, tensor_columnvector_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1050,13 +1154,14 @@ PHP_METHOD(Tensor_Vector, map)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *callback, callback_sub, _0, _1, _2;
+	zval *callback, callback_sub, _0, _1, _2, _3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&callback_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
@@ -1068,13 +1173,13 @@ PHP_METHOD(Tensor_Vector, map)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &callback);
-	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 16, callback, &_1);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_2);
+	ZVAL_BOOL(&_3, 0);
+	ZEPHIR_RETURN_CALL_STATIC("fromArray", NULL, 0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1184,7 +1289,7 @@ PHP_METHOD(Tensor_Vector, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " elements but vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 452);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 468);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1254,7 +1359,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Vector B cannot be", " larger than Vector A.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 470);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 486);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1268,7 +1373,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Stride cannot be", " less than 1, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 475);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 491);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1278,7 +1383,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_11, stride);
 	tensor_convolve_1d(&_8, &_9, &_10, &_11);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1481,7 +1586,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "P must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 547);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 563);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1583,7 +1688,7 @@ PHP_METHOD(Tensor_Vector, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 590);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 606);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1649,7 +1754,7 @@ PHP_METHOD(Tensor_Vector, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 620);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 636);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1716,7 +1821,7 @@ PHP_METHOD(Tensor_Vector, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 651);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 667);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1783,7 +1888,7 @@ PHP_METHOD(Tensor_Vector, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " vector from the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 682);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 698);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1850,7 +1955,7 @@ PHP_METHOD(Tensor_Vector, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " vector to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 713);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 729);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1917,7 +2022,7 @@ PHP_METHOD(Tensor_Vector, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " vector with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 744);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 760);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1984,7 +2089,7 @@ PHP_METHOD(Tensor_Vector, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 775);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 791);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2051,7 +2156,7 @@ PHP_METHOD(Tensor_Vector, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 806);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 822);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2118,7 +2223,7 @@ PHP_METHOD(Tensor_Vector, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 837);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 853);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2185,7 +2290,7 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 868);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 884);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2252,7 +2357,7 @@ PHP_METHOD(Tensor_Vector, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 899);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 915);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2319,7 +2424,7 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 930);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 946);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2378,7 +2483,7 @@ PHP_METHOD(Tensor_Vector, abs)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_abs(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2426,7 +2531,7 @@ PHP_METHOD(Tensor_Vector, sqrt)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_sqrt(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2456,7 +2561,7 @@ PHP_METHOD(Tensor_Vector, exp)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_exp(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2486,7 +2591,7 @@ PHP_METHOD(Tensor_Vector, expm1)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_expm1(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2541,7 +2646,7 @@ PHP_METHOD(Tensor_Vector, log)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Log base must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1004);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1020);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2550,7 +2655,7 @@ PHP_METHOD(Tensor_Vector, log)
 		ZEPHIR_INIT_VAR(&_4$$4);
 		zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 		tensor_log(&_4$$4, &_5$$4);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_4$$4);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_4$$4);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
@@ -2559,7 +2664,7 @@ PHP_METHOD(Tensor_Vector, log)
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_8, base);
 	tensor_log_base(&_6, &_7, &_8);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_6);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2589,7 +2694,7 @@ PHP_METHOD(Tensor_Vector, log1p)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_log1p(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2619,7 +2724,7 @@ PHP_METHOD(Tensor_Vector, sin)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_sin(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2649,7 +2754,7 @@ PHP_METHOD(Tensor_Vector, asin)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_asin(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2679,7 +2784,7 @@ PHP_METHOD(Tensor_Vector, cos)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_cos(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2709,7 +2814,7 @@ PHP_METHOD(Tensor_Vector, acos)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_acos(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2739,7 +2844,7 @@ PHP_METHOD(Tensor_Vector, tan)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_tan(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2769,7 +2874,7 @@ PHP_METHOD(Tensor_Vector, atan)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_atan(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2799,7 +2904,7 @@ PHP_METHOD(Tensor_Vector, rad2deg)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_rad2deg(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2829,7 +2934,7 @@ PHP_METHOD(Tensor_Vector, deg2rad)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_deg2rad(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3013,12 +3118,12 @@ PHP_METHOD(Tensor_Vector, median)
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
 		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1170);
+		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1186);
 	} else {
 		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1172);
+		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1188);
 		zephir_memory_observe(&_5$$4);
-		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1172);
+		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1188);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
 		ZEPHIR_INIT_NVAR(&median);
@@ -3085,7 +3190,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1189);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1205);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3103,15 +3208,15 @@ PHP_METHOD(Tensor_Vector, quantile)
 	if (ZEPHIR_LE_LONG(&_7, xHat)) {
 		zephir_memory_observe(&_8$$4);
 		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1201);
+		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1217);
 		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
 	}
 	remainder =  ((x -  (double) xHat));
 	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1206);
+	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1222);
 	t =  (zephir_get_doubleval(&_10));
 	zephir_memory_observe(&_11);
-	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1208);
+	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1224);
 	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
 }
 
@@ -3170,7 +3275,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 2, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1223);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1239);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3236,7 +3341,7 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1247);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1263);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3245,7 +3350,7 @@ PHP_METHOD(Tensor_Vector, round)
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_6, precision);
 	tensor_round(&_4, &_5, &_6);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_4);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3275,7 +3380,7 @@ PHP_METHOD(Tensor_Vector, floor)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_floor(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3305,7 +3410,7 @@ PHP_METHOD(Tensor_Vector, ceil)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_ceil(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3355,7 +3460,7 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1286);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1302);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3365,7 +3470,7 @@ PHP_METHOD(Tensor_Vector, clip)
 	ZVAL_DOUBLE(&_4, min);
 	ZVAL_DOUBLE(&_5, max);
 	tensor_clip(&_2, &_3, &_4, &_5);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3404,7 +3509,7 @@ PHP_METHOD(Tensor_Vector, clipLower)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, min);
 	tensor_clip_lower(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3443,7 +3548,7 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, max);
 	tensor_clip_upper(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3473,7 +3578,7 @@ PHP_METHOD(Tensor_Vector, sign)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_sign(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3503,7 +3608,7 @@ PHP_METHOD(Tensor_Vector, negate)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_negate(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3577,7 +3682,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1346);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1362);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3592,7 +3697,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1357);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1373);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3601,7 +3706,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1354);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1370);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3624,7 +3729,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1354);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1370);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3709,7 +3814,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1372);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1388);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3724,7 +3829,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1383);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1399);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3733,7 +3838,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1380);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1396);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3756,7 +3861,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1380);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1396);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3841,7 +3946,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1398);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1414);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3856,7 +3961,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1409);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1425);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3865,7 +3970,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1406);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1422);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3888,7 +3993,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1406);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1422);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3973,7 +4078,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1424);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1440);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3988,7 +4093,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1435);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1451);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3997,7 +4102,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1432);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1448);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4020,7 +4125,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1432);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1448);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4105,7 +4210,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1450);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1466);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4120,7 +4225,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1461);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1477);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4129,7 +4234,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1458);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1474);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4152,7 +4257,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1458);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1474);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4237,7 +4342,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1476);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1492);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4252,7 +4357,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1487);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1503);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4261,7 +4366,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1484);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1500);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4284,7 +4389,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1484);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1500);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4369,7 +4474,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1502);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1518);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4384,7 +4489,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1513);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1529);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4393,7 +4498,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1510);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1526);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4416,7 +4521,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1510);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1526);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4501,7 +4606,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1528);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1544);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4516,7 +4621,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1539);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1555);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4525,7 +4630,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1536);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1552);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4548,7 +4653,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1536);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1552);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4633,7 +4738,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1554);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1570);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4648,7 +4753,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1565);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1581);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4657,7 +4762,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1562);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1578);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4680,7 +4785,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1562);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1578);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4765,7 +4870,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1580);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1596);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4780,7 +4885,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1591);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1607);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4789,7 +4894,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1588);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1604);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4812,7 +4917,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1588);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1604);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4897,7 +5002,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1606);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1622);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4912,7 +5017,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1617);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1633);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4921,7 +5026,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1614);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1630);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4944,7 +5049,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1614);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1630);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5029,7 +5134,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1632);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1648);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5044,7 +5149,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1643);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1659);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5053,7 +5158,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1640);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1656);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5076,7 +5181,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1640);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1656);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5150,7 +5255,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1658);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1674);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5159,7 +5264,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_multiply(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5222,7 +5327,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1676);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1692);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5231,7 +5336,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_divide(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5294,7 +5399,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1694);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1710);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5303,7 +5408,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_add(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5366,7 +5471,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1712);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1728);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5375,7 +5480,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_subtract(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5438,7 +5543,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1730);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1746);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5447,7 +5552,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_pow(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5510,7 +5615,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1748);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1764);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5519,7 +5624,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_mod(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5583,7 +5688,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1767);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1783);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5592,7 +5697,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_equal(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5655,7 +5760,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1785);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1801);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5664,7 +5769,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_not_equal(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5727,7 +5832,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1803);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1819);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5736,7 +5841,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5799,7 +5904,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1821);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1837);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5808,7 +5913,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater_equal(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5871,7 +5976,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1839);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1855);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5880,7 +5985,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5943,7 +6048,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1857);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1873);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5952,7 +6057,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less_equal(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5991,7 +6096,7 @@ PHP_METHOD(Tensor_Vector, multiplyScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_multiply_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6030,7 +6135,7 @@ PHP_METHOD(Tensor_Vector, divideScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_divide_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6069,7 +6174,7 @@ PHP_METHOD(Tensor_Vector, addScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_add_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6108,7 +6213,7 @@ PHP_METHOD(Tensor_Vector, subtractScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_subtract_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6147,7 +6252,7 @@ PHP_METHOD(Tensor_Vector, powScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_pow_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6186,7 +6291,7 @@ PHP_METHOD(Tensor_Vector, modScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_mod_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6225,7 +6330,7 @@ PHP_METHOD(Tensor_Vector, equalScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6264,7 +6369,7 @@ PHP_METHOD(Tensor_Vector, notEqualScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_not_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6303,7 +6408,7 @@ PHP_METHOD(Tensor_Vector, greaterScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_greater_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6343,7 +6448,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_greater_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6382,7 +6487,7 @@ PHP_METHOD(Tensor_Vector, lessScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_less_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6422,7 +6527,7 @@ PHP_METHOD(Tensor_Vector, lessEqualScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_less_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 5, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6454,7 +6559,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2014);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2030);
 	return;
 }
 
@@ -6505,7 +6610,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2038);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2054);
 	return;
 }
 
@@ -6563,7 +6668,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2052);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2068);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6611,14 +6716,27 @@ PHP_METHOD(Tensor_Vector, getIterator)
  */
 PHP_METHOD(Tensor_Vector, __serialize)
 {
+	zval _0, _1;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
+	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "asArray", NULL, 0);
+	zephir_create_array(return_value, 2, 0);
+	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asArray", NULL, 0);
 	zephir_check_call_status();
+	zephir_array_update_string(return_value, SL("data"), &_0, PH_COPY | PH_SEPARATE);
+	zephir_memory_observe(&_1);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC);
+	zephir_array_update_string(return_value, SL("n"), &_1, PH_COPY | PH_SEPARATE);
 	RETURN_MM();
 }
 
@@ -6633,7 +6751,7 @@ PHP_METHOD(Tensor_Vector, __unserialize)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *data_param = NULL, rebuilt, _0, _1;
+	zval *data_param = NULL, rebuilt, _0, _1, _2;
 	zval data;
 	zval *this_ptr = getThis();
 
@@ -6641,6 +6759,7 @@ PHP_METHOD(Tensor_Vector, __unserialize)
 	ZVAL_UNDEF(&rebuilt);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -6657,14 +6776,14 @@ PHP_METHOD(Tensor_Vector, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	ZEPHIR_INIT_VAR(&rebuilt);
-	object_init_ex(&rebuilt, tensor_vector_ce);
-	ZEPHIR_CALL_METHOD(NULL, &rebuilt, "__construct", NULL, 5, &data);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_0, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, &_0);
-	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
-	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_1);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2109);
+	ZVAL_BOOL(&_1, 0);
+	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, &_1);
+	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2112);
+	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_2);
 	ZEPHIR_MM_RESTORE();
 }
 
diff --git a/ext/tensor/vector.zep.h b/ext/tensor/vector.zep.h
index d28ff91..a9c07d7 100644
--- a/ext/tensor/vector.zep.h
+++ b/ext/tensor/vector.zep.h
@@ -12,6 +12,7 @@ PHP_METHOD(Tensor_Vector, poisson);
 PHP_METHOD(Tensor_Vector, uniform);
 PHP_METHOD(Tensor_Vector, range);
 PHP_METHOD(Tensor_Vector, linspace);
+PHP_METHOD(Tensor_Vector, fromArray);
 PHP_METHOD(Tensor_Vector, __construct);
 PHP_METHOD(Tensor_Vector, shape);
 PHP_METHOD(Tensor_Vector, shapeString);
@@ -166,8 +167,13 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_linspace, 0, 3, Ten
 	ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_vector_fromarray, 0, 1, Tensor\\Vector, 0)
+	ZEND_ARG_ARRAY_INFO(0, a, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, validate, _IS_BOOL, 0, "true")
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_vector___construct, 0, 0, 1)
-	ZEND_ARG_INFO(0, a)
+	ZEND_ARG_OBJ_INFO(0, a, Tensor\\TensorBuffer, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_vector_shape, 0, 0, IS_ARRAY, 0)
@@ -586,6 +592,7 @@ ZEPHIR_INIT_FUNCS(tensor_vector_method_entry) {
 	PHP_ME(Tensor_Vector, uniform, arginfo_tensor_vector_uniform, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, range, arginfo_tensor_vector_range, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, linspace, arginfo_tensor_vector_linspace, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	PHP_ME(Tensor_Vector, fromArray, arginfo_tensor_vector_fromarray, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	PHP_ME(Tensor_Vector, __construct, arginfo_tensor_vector___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 	PHP_ME(Tensor_Vector, shape, arginfo_tensor_vector_shape, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, shapeString, arginfo_tensor_vector_shapestring, ZEND_ACC_PUBLIC)
diff --git a/phpstan.neon b/phpstan.neon
deleted file mode 100644
index dd0029b..0000000
--- a/phpstan.neon
+++ /dev/null
@@ -1,9 +0,0 @@
-parameters:
-    level: 8
-    paths:
-        - 'tests'
-        - 'benchmarks'
-    scanFiles:
-        - 'stubs/TensorBuffer.php'
-    bootstrapFiles:
-        - vendor/autoload.php
diff --git a/scripts/compare-serialization.php b/scripts/compare-serialization.php
index fbcad4e..3e7aa13 100755
--- a/scripts/compare-serialization.php
+++ b/scripts/compare-serialization.php
@@ -161,8 +161,8 @@ function bytes($payload) : int
     'array (baseline)' => fn () => $elements,
     'Buffer::fromArray()' => fn () => Tensor\Buffer::fromArray($elements),
     'new TensorBuffer()' => fn () => new Tensor\TensorBuffer(Tensor\Buffer::fromArray($elements)),
-    'new Vector()' => fn () => new Tensor\Vector($elements),
-    'new ColumnVector()' => fn () => new Tensor\ColumnVector($elements),
+    'Vector::fromArray()' => fn () => Tensor\Vector::fromArray($elements),
+    'ColumnVector::fromArray()' => fn () => Tensor\ColumnVector::fromArray($elements),
     'Matrix::fromArray() 2x2' => fn () => Tensor\Matrix::fromArray($matrixRows),
 ];
 
diff --git a/tensor/columnvector.zep b/tensor/columnvector.zep
index 68f8c67..abfea12 100644
--- a/tensor/columnvector.zep
+++ b/tensor/columnvector.zep
@@ -73,6 +73,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_multiply_col(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -96,6 +97,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_divide_col_reverse(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -119,6 +121,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_add_col(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -142,6 +145,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_subtract_col_reverse(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -165,6 +169,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_pow_col_reverse(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -188,6 +193,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_mod_col_reverse(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -211,6 +217,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_equal_col(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -234,6 +241,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_not_equal_col(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -257,6 +265,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_greater_col_reverse(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -280,6 +289,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_greater_equal_col_reverse(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -303,6 +313,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+
         let result = tensor_less_col_reverse(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
@@ -326,6 +337,7 @@ class ColumnVector extends Vector
         var bHat, result;
 
         let bHat = b->asTensorBuffer();
+        
         let result = tensor_less_equal_col_reverse(bHat, this->a, b->n());
 
         return new Matrix(result, b->m(), b->n());
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index bba7cd5..07bb56b 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -43,61 +43,6 @@ class Matrix implements Tensor
      */
     protected n;
 
-    /**
-     * Build a new matrix from a PHP array of rows, each row being a PHP array
-     * of numeric elements.
-     *
-     * @param array[] a
-     * @param bool validate
-     * @throws \Tensor\Exceptions\InvalidArgumentException
-     * @return self
-     */
-    public static function fromArray(const array a, const bool validate = true) -> <Matrix>
-    {
-        int rows = count(a);
-
-        if unlikely rows < 1 {
-            var zero = tensor_buffer_from_array([]);
-            return new self(new TensorBuffer(<Buffer> zero), 0, 0);
-        }
-
-        var rowA, valueA;
-
-        var firstRow, n;
-
-        let firstRow = current(a);
-
-        if unlikely !is_array(firstRow) {
-            throw new InvalidArgumentException("Matrix requires an"
-                . " array of arrays.");
-        }
-
-        let n = count(firstRow);
-
-        array flat = [];
-
-        for rowA in a {
-            if unlikely validate && !is_array(rowA) {
-                throw new InvalidArgumentException("Matrix requires an"
-                    . " array of arrays.");
-            }
-
-            if unlikely validate && count(rowA) !== n {
-                throw new InvalidArgumentException("The number of"
-                    . " columns must be equal for all rows, "
-                    .  strval(n) . " needed but " . count(rowA) . " given.");
-            }
-
-            for valueA in rowA {
-                let flat[] = (float) valueA;
-            }
-        }
-
-        var buffer = tensor_buffer_from_array(flat);
-
-        return new self(new TensorBuffer(<Buffer> buffer), rows, n);
-    }
-
     /**
      * Return an identity matrix with dimensionality n x n.
      *
@@ -402,6 +347,62 @@ class Matrix implements Tensor
         return self::fromArray(a, false);
     }
 
+    /**
+     * Build a new matrix from a PHP array of rows, each row being a PHP array
+     * of numeric elements.
+     *
+     * @param array[] a
+     * @param bool validate
+     * @throws \Tensor\Exceptions\InvalidArgumentException
+     * @return self
+     */
+    public static function fromArray(const array a, const bool validate = true) -> <Matrix>
+    {
+        int rows = count(a);
+
+        if unlikely rows < 1 {
+            var buffer = tensor_buffer_from_array([]);
+
+            return new self(new TensorBuffer(<Buffer> buffer), 0, 0);
+        }
+
+        var rowA, valueA;
+
+        var firstRow, n;
+
+        let firstRow = current(a);
+
+        if unlikely !is_array(firstRow) {
+            throw new InvalidArgumentException("Matrix requires an"
+                . " array of arrays.");
+        }
+
+        let n = count(firstRow);
+
+        array flat = [];
+
+        for rowA in a {
+            if unlikely validate && !is_array(rowA) {
+                throw new InvalidArgumentException("Matrix requires an"
+                    . " array of arrays.");
+            }
+
+            if unlikely validate && count(rowA) !== n {
+                throw new InvalidArgumentException("The number of"
+                    . " columns must be equal for all rows, "
+                    .  strval(n) . " needed but " . count(rowA) . " given.");
+            }
+
+            for valueA in rowA {
+                let flat[] = (float) valueA;
+            }
+        }
+
+        var buffer = tensor_buffer_from_array(flat);
+
+        return new self(new TensorBuffer(<Buffer> buffer), rows, n);
+    }
+
     /**
      * Construct a matrix from a single TensorBuffer holding the elements in
      * row-major order together with the target dimensionality.
@@ -412,6 +413,11 @@ class Matrix implements Tensor
      */
     public function __construct(<TensorBuffer> a, const int m, const int n)
     {
+        if unlikely m < 0 || n < 0 {
+            throw new InvalidArgumentException("Matrix dimensions must be"
+                . " non-negative.");
+        }
+
         let this->a = a;
         let this->m = m;
         let this->n = n;
@@ -528,33 +534,35 @@ class Matrix implements Tensor
     }
 
     /**
-     * Return the elements of the matrix as a vector taken in row-major order.
+     * Return the rows of the matrix as an array of Vector objects.
      *
-     * @return \Tensor\Vector
+     * @return \Tensor\Vector[]
      */
-    public function asVector() -> <Vector>
+    public function asVectors() -> array
     {
-        return new Vector(this->a);
-    }
+        var rowBuffer;
 
-    /**
-     * Return the underlying TensorBuffer of the matrix.
-     *
-     * @return \Tensor\TensorBuffer
-     */
-    public function asTensorBuffer() -> <TensorBuffer>
-    {
-        return this->a;
+        array b = [];
+
+        if unlikely this->n < 1 {
+            return [];
+        }
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = new Vector(rowBuffer);
+        }
+
+        return b;
     }
 
     /**
-     * Return the matrix as an array of arrays.
+     * Return the columns of the matrix as an array of ColumnVector objects.
      *
-     * @return array[]
+     * @return \Tensor\ColumnVector[]
      */
-    public function asArray() -> array
+    public function asColumnVectors() -> array
     {
-        var rowBuffer;
+        var columnBuffer;
 
         array b = [];
 
@@ -562,33 +570,30 @@ class Matrix implements Tensor
             return [];
         }
 
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = rowBuffer->toArray();
+        for columnBuffer in this->asColumnBuffers() {
+            let b[] = new ColumnVector(columnBuffer);
         }
 
         return b;
     }
 
     /**
-     * Return each row of the matrix as a TensorBuffer.
+     * Return the elements of the matrix as a vector taken in row-major order.
      *
-     * @return \Tensor\TensorBuffer[]
+     * @return \Tensor\Vector
      */
-    public function asRowBuffers() -> array
+    public function flatten() -> <Vector>
     {
-        if unlikely this->n < 1 {
-            return [];
-        }
-
-        return this->a->split(this->n);
+        return new Vector(this->a);
     }
 
+
     /**
-     * Return the rows of the matrix as an array of Vector objects.
+     * Return the matrix as an array of arrays.
      *
-     * @return \Tensor\Vector[]
+     * @return array[]
      */
-    public function asRowVectors() -> array
+    public function asArray() -> array
     {
         var rowBuffer;
 
@@ -599,42 +604,50 @@ class Matrix implements Tensor
         }
 
         for rowBuffer in this->a->split(this->n) {
-            let b[] = new Vector(rowBuffer);
+            let b[] = rowBuffer->toArray();
         }
 
         return b;
     }
 
     /**
-     * Return each column of the matrix as a TensorBuffer.
+     * Return the underlying TensorBuffer of the matrix.
      *
-     * @return \Tensor\TensorBuffer[]
+     * @internal
+     *
+     * @return \Tensor\TensorBuffer
      */
-    public function asColumnBuffers() -> array
+    public function asTensorBuffer() -> <TensorBuffer>
     {
-        var i;
-
-        array b = [];
+        return this->a;
+    }
 
+    /**
+     * Return each row of the matrix as a TensorBuffer.
+     *
+     * @internal
+     *
+     * @return \Tensor\TensorBuffer[]
+     */
+    public function asRowBuffers() -> array
+    {
         if unlikely this->n < 1 {
             return [];
         }
 
-        for i in range(0, this->n - 1) {
-            let b[] = this->a->sliceStrided(i, this->m, this->n);
-        }
-
-        return b;
+        return this->a->split(this->n);
     }
 
     /**
-     * Return the columns of the matrix as an array of ColumnVector objects.
+     * Return each column of the matrix as a TensorBuffer.
      *
-     * @return \Tensor\ColumnVector[]
+     * @internal
+     *
+     * @return \Tensor\TensorBuffer[]
      */
-    public function asColumnVectors() -> array
+    public function asColumnBuffers() -> array
     {
-        var columnBuffer;
+        var i;
 
         array b = [];
 
@@ -642,33 +655,13 @@ class Matrix implements Tensor
             return [];
         }
 
-        for columnBuffer in this->asColumnBuffers() {
-            let b[] = new ColumnVector(columnBuffer);
+        for i in range(0, this->n - 1) {
+            let b[] = this->a->sliceStrided(i, this->m, this->n);
         }
 
         return b;
     }
 
-    /**
-     * Return the rows of the matrix as an array of Vector objects.
-     *
-     * @return \Tensor\Vector[]
-     */
-    public function asVectors() -> array
-    {
-        return this->asRowVectors();
-    }
-    
-    /**
-     * Return the elements of the matrix as a vector taken in row-major order.
-     *
-     * @return \Tensor\Vector
-     */
-    public function flatten() -> <Vector>
-    {
-        return new Vector(this->a);
-    }
-
     /**
      * Run a function over all of the elements in the matrix.
      *
@@ -1411,8 +1404,7 @@ class Matrix implements Tensor
      */
     public function reciprocal() -> <Matrix>
     {
-        return self::ones(this->m, this->n)
-            ->divideMatrix(this);
+        return self::ones(this->m, this->n)->divideMatrix(this);
     }
 
     /**
@@ -1587,7 +1579,7 @@ class Matrix implements Tensor
             let b[] = rowBuffer->sum();
         }
 
-        return new ColumnVector(b);
+        return ColumnVector::fromArray(b, false);
     }
 
     /**
@@ -1605,7 +1597,7 @@ class Matrix implements Tensor
             let b[] = rowBuffer->product();
         }
 
-        return new ColumnVector(b);
+        return ColumnVector::fromArray(b, false);
     }
 
     /**
@@ -1623,7 +1615,7 @@ class Matrix implements Tensor
             let b[] = rowBuffer->min();
         }
 
-        return new ColumnVector(b);
+        return ColumnVector::fromArray(b, false);
     }
 
     /**
@@ -1641,7 +1633,7 @@ class Matrix implements Tensor
             let b[] = rowBuffer->max();
         }
 
-        return new ColumnVector(b);
+        return ColumnVector::fromArray(b, false);
     }
 
     /**
@@ -1662,6 +1654,7 @@ class Matrix implements Tensor
     public function median() -> <ColumnVector>
     {
         var rowBuffer, median;
+
         array b = [];
 
         int mid = (int) intdiv(this->n, 2);
@@ -1680,7 +1673,7 @@ class Matrix implements Tensor
             let b[] = median;
         }
 
-        return new ColumnVector(b);
+        return ColumnVector::fromArray(b, false);
     }
 
     /**
@@ -1698,6 +1691,7 @@ class Matrix implements Tensor
         }
 
         float t;
+
         var rowBuffer;
         
         array b = [];
@@ -1722,7 +1716,7 @@ class Matrix implements Tensor
             let b[] = t + remainder * (rowBuffer->get(xHat) - t);
         }
 
-        return new ColumnVector(b);
+        return ColumnVector::fromArray(b, false);
     }
 
     /**
@@ -1777,8 +1771,7 @@ class Matrix implements Tensor
 
         var b = this->subtractColumnVector(mean);
 
-        return b->matmul(b->transpose())
-            ->divideScalar(this->n);
+        return b->matmul(b->transpose())->divideScalar(this->n);
     }
 
     /**
@@ -3099,24 +3092,28 @@ class Matrix implements Tensor
      */
     public function __serialize() -> array
     {
-        return this->asArray();
+        return [
+            "data": this->asArray(),
+            "m": this->m,
+            "n": this->n
+        ];
     }
 
     /**
      * Restore the matrix from the plain array of rows produced by
      * __serialize() by rebuilding its TensorBuffer and shape.
      *
-     * @param float[][] data
+     * @param array<array<float>> data
      * @throws \Tensor\Exceptions\InvalidArgumentException
      */
     public function __unserialize(const array data)
     {
         var rebuilt;
 
-        let rebuilt = Matrix::fromArray(data);
+        let rebuilt = Matrix::fromArray(data["data"], false);
 
-        let this->a = rebuilt->a;
-        let this->m = rebuilt->m;
-        let this->n = rebuilt->n;
+        let this->a = rebuilt->asTensorBuffer();
+        let this->m = data["m"];
+        let this->n = data["n"];
     }
 }
\ No newline at end of file
diff --git a/tensor/tensorbuffer.zep b/tensor/tensorbuffer.zep
index 0ac1118..5e69e15 100644
--- a/tensor/tensorbuffer.zep
+++ b/tensor/tensorbuffer.zep
@@ -8,6 +8,8 @@ use Tensor\Exceptions\InvalidArgumentException;
  * A decorator that wraps the kernel Buffer class and provides additional
  * operations such as sorting and slicing.
  *
+ * @internal
+ *
  * @category    Scientific Computing
  * @package     Rubix/Tensor
  * @author      Andrew DalPino
@@ -21,14 +23,6 @@ class TensorBuffer
      */
     protected buffer;
 
-    /**
-     * @param \Tensor\Buffer buffer
-     */
-    public function __construct(<Buffer> buffer)
-    {
-        let this->buffer = buffer;
-    }
-
     /**
      * Build a buffer by concatenating an array of buffers into a single
      * contiguous buffer.
@@ -55,23 +49,11 @@ class TensorBuffer
     }
 
     /**
-     * Return the underlying buffer.
-     *
-     * @return \Tensor\Buffer
-     */
-    public function asBuffer() -> <Buffer>
-    {
-        return this->buffer;
-    }
-
-    /**
-     * Return the number of elements in the buffer.
-     *
-     * @return int
+     * @param \Tensor\Buffer buffer
      */
-    public function count() -> int
+    public function __construct(<Buffer> buffer)
     {
-        return this->buffer->count();
+        let this->buffer = buffer;
     }
 
     /**
@@ -84,16 +66,6 @@ class TensorBuffer
         return this->buffer->type();
     }
 
-    /**
-     * Return the buffer as a PHP array.
-     *
-     * @return list<float>
-     */
-    public function toArray() -> array
-    {
-        return this->buffer->toArray();
-    }
-
     /**
      * Return the element at the given index.
      *
@@ -324,4 +296,34 @@ class TensorBuffer
 
         return new TensorBuffer(<Buffer> b);
     }
+
+     /**
+     * Return the underlying buffer.
+     *
+     * @return \Tensor\Buffer
+     */
+    public function asBuffer() -> <Buffer>
+    {
+        return this->buffer;
+    }
+
+    /**
+     * Return the number of elements in the buffer.
+     *
+     * @return int
+     */
+    public function count() -> int
+    {
+        return this->buffer->count();
+    }
+
+    /**
+     * Return the buffer as a PHP array.
+     *
+     * @return list<float>
+     */
+    public function toArray() -> array
+    {
+        return this->buffer->toArray();
+    }
 }
\ No newline at end of file
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 814326d..bd0a55d 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -28,7 +28,7 @@ class Vector implements Tensor
      *
      * @var int
      */
-        protected n;
+    protected n;
 
     /**
      * Build a vector of zeros with n elements.
@@ -75,7 +75,7 @@ class Vector implements Tensor
                 . " greater than 0, " . strval(n) . " given.");
         }
 
-        return new static(array_fill(0, n, value));
+        return static::fromArray(array_fill(0, n, value), false);
     }
 
     /**
@@ -100,7 +100,7 @@ class Vector implements Tensor
             let a[] = rand() / max;
         }
 
-        return new static(a);
+        return static::fromArray(a, false);
     }
 
     /**
@@ -137,7 +137,7 @@ class Vector implements Tensor
             array_pop(a);
         }
 
-        return new static(a);
+        return static::fromArray(a, false);
     }
 
     /**
@@ -185,7 +185,7 @@ class Vector implements Tensor
             let a[] = k - 1.0;
         }
 
-        return new static(a);
+        return static::fromArray(a, false);
     }
 
     /**
@@ -210,7 +210,7 @@ class Vector implements Tensor
             let a[] = rand(-max, max) / max;
         }
 
-        return new static(a);
+        return static::fromArray(a, false);
     }
 
     /**
@@ -223,7 +223,7 @@ class Vector implements Tensor
      */
     public static function range(const float start, const float end, const float interval = 1.0) -> <Vector>
     {
-        return new static(range(start, end, interval));
+        return static::fromArray(range(start, end, interval), false);
     }
 
     /**
@@ -258,30 +258,46 @@ class Vector implements Tensor
 
         let a[] = max;
 
-        return new self(a);
+        return self::fromArray(a, false);
     }
 
     /**
-     * Construct a new vector from a PHP array of elements or an existing
-     * TensorBuffer.
+     * Build a new vector from a flat PHP array of numeric elements.
      *
-     * @param float[] a
+     * @param array a
+     * @param bool validate
      * @throws \Tensor\Exceptions\InvalidArgumentException
+     * @return self
      */
-    public function __construct(var a)
+    public static function fromArray(const array a, const bool validate = true) -> <Vector>
     {
-        var buffer;
+        var valueA;
+
+        array flat = [];
 
-        if typeof a == "array" {
-            let buffer = tensor_buffer_from_array(a);
+        for valueA in (array) a {
+            if unlikely validate && is_array(valueA) {
+                throw new InvalidArgumentException("Vector requires a"
+                    . " flat array of numeric elements.");
+            }
 
-            let a = new TensorBuffer(<Buffer> buffer);
-        } elseif !(a instanceof TensorBuffer) {
-            throw new InvalidArgumentException("Vector requires"
-                . " an array or TensorBuffer object.");
+            let flat[] = (float) valueA;
         }
 
-        let this->a = <TensorBuffer> a;
+        var buffer = tensor_buffer_from_array(flat);
+
+        return new static(new TensorBuffer(<Buffer> buffer));
+    }
+
+    /**
+     * Construct a new vector from a TensorBuffer holding its elements.
+     *
+     * @param \Tensor\TensorBuffer a
+     * @throws \Tensor\Exceptions\InvalidArgumentException
+     */
+    public function __construct(<TensorBuffer> a)
+    {
+        let this->a = a;
         let this->n = this->a->count();
     }
 
@@ -420,7 +436,7 @@ class Vector implements Tensor
      */
     public function map(const var callback) -> <Vector>
     {
-        return new static(array_map(callback, this->a->toArray()));
+        return static::fromArray(array_map(callback, this->a->toArray()), false);
     }
 
     /**
@@ -2015,7 +2031,7 @@ class Vector implements Tensor
     }
 
     /**
-     * Does a given column exist in the matrix.
+     * Does a given element exist in the vector.
      *
      * @param mixed index
      * @return bool
@@ -2039,7 +2055,7 @@ class Vector implements Tensor
     }
 
     /**
-     * Return a row from the matrix at the given index.
+     * Return an element from the vector at the given index.
      *
      * @param mixed index
      * @throws \Tensor\Exceptions\InvalidArgumentException
@@ -2056,7 +2072,7 @@ class Vector implements Tensor
     }
 
     /**
-     * Get an iterator for the rows in the matrix.
+     * Get an iterator for the items in the vector.
      *
      * @return \ArrayIterator
      */
@@ -2073,7 +2089,10 @@ class Vector implements Tensor
      */
     public function __serialize() -> array
     {
-        return this->asArray();
+        return [
+            "data": this->asArray(),
+            "n": this->n
+        ];
     }
 
     /**
@@ -2087,9 +2106,9 @@ class Vector implements Tensor
     {
         var rebuilt;
 
-        let rebuilt = new self(data);
+        let rebuilt = self::fromArray(data["data"], false);
 
         let this->a = rebuilt->a;
-        let this->n = rebuilt->n;
+        let this->n = data["n"];
     }
 }
\ No newline at end of file
diff --git a/tests/ColumnVectorTest.php b/tests/ColumnVectorTest.php
index 7849578..c397ae0 100644
--- a/tests/ColumnVectorTest.php
+++ b/tests/ColumnVectorTest.php
@@ -33,7 +33,7 @@ class ColumnVectorTest extends TestCase
      */
     public function build() : void
     {
-        $vector = new ColumnVector([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15, 25, 35]);
 
         $this->assertInstanceOf(ColumnVector::class, $vector);
         $this->assertInstanceOf(Tensor::class, $vector);
@@ -51,7 +51,7 @@ public function build() : void
      */
     public function shape() : void
     {
-        $vector = new ColumnVector([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15, 25, 35]);
 
         $this->assertEquals([3], $vector->shape());
     }
@@ -61,7 +61,7 @@ public function shape() : void
      */
     public function shapeString() : void
     {
-        $vector = new ColumnVector([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15, 25, 35]);
 
         $this->assertEquals('3', $vector->shapeString());
     }
@@ -71,7 +71,7 @@ public function shapeString() : void
      */
     public function size() : void
     {
-        $vector = new ColumnVector([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15, 25, 35]);
 
         $this->assertEquals(3, $vector->size());
     }
@@ -81,7 +81,7 @@ public function size() : void
      */
     public function serialization() : void
     {
-        $vector = new ColumnVector([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15, 25, 35]);
 
         $serialized = serialize($vector);
 
@@ -99,7 +99,7 @@ public function serialization() : void
      */
     public function m() : void
     {
-        $vector = new ColumnVector([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15, 25, 35]);
 
         $this->assertEquals(3, $vector->m());
     }
@@ -109,7 +109,7 @@ public function m() : void
      */
     public function n() : void
     {
-        $vector = new ColumnVector([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15, 25, 35]);
 
         $this->assertEquals(1, $vector->n());
     }
@@ -119,7 +119,7 @@ public function n() : void
      */
     public function multiply() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -143,7 +143,7 @@ public function multiply() : void
      */
     public function divide() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -167,7 +167,7 @@ public function divide() : void
      */
     public function add() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -191,7 +191,7 @@ public function add() : void
      */
     public function subtract() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -215,7 +215,7 @@ public function subtract() : void
      */
     public function equal() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -239,7 +239,7 @@ public function equal() : void
      */
     public function notEqual() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -263,7 +263,7 @@ public function notEqual() : void
      */
     public function greater() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -287,7 +287,7 @@ public function greater() : void
      */
     public function greaterEqual() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -311,7 +311,7 @@ public function greaterEqual() : void
      */
     public function less() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -335,7 +335,7 @@ public function less() : void
      */
     public function lessEqual() : void
     {
-        $a = new ColumnVector([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15, 25, 35]);
 
         $b = Matrix::fromArray([
             [6.23, -1, 0.03],
@@ -359,12 +359,12 @@ public function lessEqual() : void
      */
     public function transposeReturnsVector() : void
     {
-        $a = new ColumnVector([1.0, 2.0, 3.0]);
+        $a = ColumnVector::fromArray([1.0, 2.0, 3.0]);
 
         $b = $a->transpose();
 
         $this->assertInstanceOf(Vector::class, $b);
-        $this->assertEquals(new Vector([1.0, 2.0, 3.0]), $b);
+        $this->assertEquals(Vector::fromArray([1.0, 2.0, 3.0]), $b);
     }
 
     /**
@@ -372,7 +372,7 @@ public function transposeReturnsVector() : void
      */
     public function sizes() : void
     {
-        $a = new ColumnVector([1.0, 2.0, 3.0]);
+        $a = ColumnVector::fromArray([1.0, 2.0, 3.0]);
 
         $this->assertEquals(3, $a->m());
         $this->assertEquals(1, $a->n());
@@ -384,7 +384,7 @@ public function sizes() : void
      */
     public function matmul() : void
     {
-        $a = new ColumnVector([1.0, 2.0, 3.0]);
+        $a = ColumnVector::fromArray([1.0, 2.0, 3.0]);
 
         $b = Matrix::fromArray([
             [1.0, 2.0, 3.0],
@@ -408,7 +408,7 @@ public function matmulDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new ColumnVector([1.0, 2.0, 3.0]))->matmul(Matrix::fromArray([
+        (ColumnVector::fromArray([1.0, 2.0, 3.0]))->matmul(Matrix::fromArray([
             [1.0, 2.0, 3.0, 4.0],
             [5.0, 6.0, 7.0, 8.0],
             [9.0, 10.0, 11.0, 12.0],
@@ -420,7 +420,7 @@ public function matmulDimensionMismatchThrows() : void
      */
     public function powMatrix() : void
     {
-        $a = new ColumnVector([2.0, 3.0, 4.0]);
+        $a = ColumnVector::fromArray([2.0, 3.0, 4.0]);
 
         $b = Matrix::fromArray([
             [1.0, 2.0, 3.0],
@@ -446,7 +446,7 @@ public function powMatrixDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new ColumnVector([1.0, 2.0, 3.0]))->powMatrix(Matrix::fromArray([
+        (ColumnVector::fromArray([1.0, 2.0, 3.0]))->powMatrix(Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]));
@@ -457,7 +457,7 @@ public function powMatrixDimensionMismatchThrows() : void
      */
     public function modMatrix() : void
     {
-        $a = new ColumnVector([10.0, 12.0, 15.0]);
+        $a = ColumnVector::fromArray([10.0, 12.0, 15.0]);
 
         $b = Matrix::fromArray([
             [3.0, 4.0, 5.0],
@@ -483,7 +483,7 @@ public function modMatrixDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new ColumnVector([1.0, 2.0, 3.0]))->modMatrix(Matrix::fromArray([
+        (ColumnVector::fromArray([1.0, 2.0, 3.0]))->modMatrix(Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]));
@@ -496,7 +496,7 @@ public function multiplyMatrixDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new ColumnVector([1.0, 2.0, 3.0]))->multiplyMatrix(Matrix::fromArray([
+        (ColumnVector::fromArray([1.0, 2.0, 3.0]))->multiplyMatrix(Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]));
@@ -509,7 +509,7 @@ public function divideMatrixDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new ColumnVector([1.0, 2.0, 3.0]))->divideMatrix(Matrix::fromArray([
+        (ColumnVector::fromArray([1.0, 2.0, 3.0]))->divideMatrix(Matrix::fromArray([
             [1.0, 2.0],
             [3.0, 4.0],
         ]));
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index a3bf100..8720f66 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -352,7 +352,7 @@ public function rowAsVector() : void
 
         $b = $a->rowAsVector(1);
 
-        $expected = new Vector([4, 11, -2]);
+        $expected = Vector::fromArray([4, 11, -2]);
 
         $this->assertEquals($expected, $b);
     }
@@ -370,7 +370,7 @@ public function columnAsVector() : void
 
         $b = $a->columnAsVector(1);
 
-        $expected = new ColumnVector([-17, 11, -6]);
+        $expected = ColumnVector::fromArray([-17, 11, -6]);
 
         $this->assertEquals($expected, $b);
     }
@@ -388,7 +388,7 @@ public function diagonalAsVector() : void
 
         $b = $a->diagonalAsVector();
 
-        $expected = new Vector([22, 11, -9]);
+        $expected = Vector::fromArray([22, 11, -9]);
 
         $this->assertEquals($expected, $b);
     }
@@ -452,9 +452,9 @@ public function asVectors() : void
         $vectors = $matrix->asVectors();
 
         $expected = [
-            new Vector([22, -17, 12]),
-            new Vector([4, 11, -2]),
-            new Vector([20, -6, -9]),
+            Vector::fromArray([22, -17, 12]),
+            Vector::fromArray([4, 11, -2]),
+            Vector::fromArray([20, -6, -9]),
         ];
 
         $this->assertEquals($expected, $vectors);
@@ -474,9 +474,9 @@ public function asColumnVectors() : void
         $vectors = $matrix->asColumnVectors();
 
         $expected = [
-            new ColumnVector([22, 4, 20]),
-            new ColumnVector([-17, 11, -6]),
-            new ColumnVector([12, -2, -9]),
+            ColumnVector::fromArray([22, 4, 20]),
+            ColumnVector::fromArray([-17, 11, -6]),
+            ColumnVector::fromArray([12, -2, -9]),
         ];
 
         $this->assertEquals($expected, $vectors);
@@ -495,7 +495,7 @@ public function flatten() : void
 
         $b = $a->flatten();
 
-        $expected = new Vector([22, -17, 12, 4, 11, -2, 20, -6, -9]);
+        $expected = Vector::fromArray([22, -17, 12, 4, 11, -2, 20, -6, -9]);
 
         $this->assertEquals($expected, $b);
     }
@@ -818,7 +818,7 @@ public function reduce() : void
         $this->assertEqualsWithDelta(-8.0, $a->reduce($subtract, 2.0), self::MAX_DELTA);
 
         // Must match Vector::reduce() for the same data and callback.
-        $v = new Vector([1.0, 2.0, 3.0, 4.0]);
+        $v = Vector::fromArray([1.0, 2.0, 3.0, 4.0]);
 
         $this->assertEqualsWithDelta($v->reduce($subtract), $a->reduce($subtract), self::MAX_DELTA);
     }
@@ -1126,11 +1126,11 @@ public function dotVector() : void
             [20.0, -6.0, -9.0],
         ]);
 
-        $b = new Vector([2, 10, -1]);
+        $b = Vector::fromArray([2, 10, -1]);
 
         $c = $a->dot($b);
 
-        $expected = new ColumnVector([-138, 120, -11]);
+        $expected = ColumnVector::fromArray([-138, 120, -11]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
     }
@@ -1271,7 +1271,7 @@ public function multiplyProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [44, -170, -12],
                 [8, 110, 2],
@@ -1285,7 +1285,7 @@ public function multiplyProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [55.0, -42.5, 30.],
                 [-4, -11, 2],
@@ -1352,7 +1352,7 @@ public function divideProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [11, -1.7, -12],
                 [2, 1.1, 2],
@@ -1366,7 +1366,7 @@ public function divideProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [8.8, -6.8, 4.8],
                 [-4, -11, 2],
@@ -1433,7 +1433,7 @@ public function addProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [24, -7, 11],
                 [6, 21, -3],
@@ -1447,7 +1447,7 @@ public function addProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [24.5, -14.5, 14.5],
                 [3, 10, -3],
@@ -1514,7 +1514,7 @@ public function subtractProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [20, -27, 13],
                 [2, 1, -1],
@@ -1528,7 +1528,7 @@ public function subtractProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [19.5, -19.5, 9.5],
                 [5, 12, -1],
@@ -1595,7 +1595,7 @@ public function powProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [484, 2015993900449, 0.08333333333333333],
                 [16, 25937424601, -0.5],
@@ -1662,7 +1662,7 @@ public function modProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [0, -7, 0],
                 [0, 1, 0],
@@ -1676,7 +1676,7 @@ public function modProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [0,  -1,  0],
                 [0, 0, 0],
@@ -1743,7 +1743,7 @@ public function equalProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [0, 0, 0],
                 [0, 0, 0],
@@ -1757,7 +1757,7 @@ public function equalProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [0, 0, 0],
                 [0, 0, 0],
@@ -1824,7 +1824,7 @@ public function notEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [1, 1, 1],
                 [1, 1, 1],
@@ -1838,7 +1838,7 @@ public function notEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [1, 1, 1],
                 [1, 1, 1],
@@ -1905,7 +1905,7 @@ public function greaterProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
@@ -1919,7 +1919,7 @@ public function greaterProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
@@ -1986,7 +1986,7 @@ public function greaterEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
@@ -2000,7 +2000,7 @@ public function greaterEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [1, 0, 1],
                 [1, 1, 0],
@@ -2067,7 +2067,7 @@ public function lessProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
@@ -2081,7 +2081,7 @@ public function lessProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
@@ -2148,7 +2148,7 @@ public function lessEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new Vector([2, 10, -1]),
+            Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
@@ -2162,7 +2162,7 @@ public function lessEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            new ColumnVector([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
                 [0, 1, 0],
                 [0, 0, 1],
@@ -2528,7 +2528,7 @@ public function sum() : void
 
         $b = $a->sum();
 
-        $expected = new ColumnVector([17, 13, 5]);
+        $expected = ColumnVector::fromArray([17, 13, 5]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2546,7 +2546,7 @@ public function product() : void
 
         $b = $a->product();
 
-        $expected = new ColumnVector([-4488.0, -88.0, 1080.0]);
+        $expected = ColumnVector::fromArray([-4488.0, -88.0, 1080.0]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2564,7 +2564,7 @@ public function min() : void
 
         $b = $a->min();
 
-        $expected = new ColumnVector([-17, -2, -9]);
+        $expected = ColumnVector::fromArray([-17, -2, -9]);
 
         $this->assertEquals($expected, $b);
     }
@@ -2582,7 +2582,7 @@ public function max() : void
 
         $b = $a->max();
 
-        $expected = new ColumnVector([22, 11, 20]);
+        $expected = ColumnVector::fromArray([22, 11, 20]);
 
         $this->assertEquals($expected, $b);
     }
@@ -2600,7 +2600,7 @@ public function mean() : void
 
         $b = $a->mean();
 
-        $expected = new ColumnVector([5.666666666666667, 4.333333333333333, 1.6666666666666667]);
+        $expected = ColumnVector::fromArray([5.666666666666667, 4.333333333333333, 1.6666666666666667]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2618,7 +2618,7 @@ public function median() : void
 
         $b = $a->median();
 
-        $expected = new ColumnVector([12, 4, -6]);
+        $expected = ColumnVector::fromArray([12, 4, -6]);
 
         $this->assertEquals($expected, $b);
     }
@@ -2636,13 +2636,13 @@ public function quantile() : void
 
         $b = $a->quantile(0.4);
 
-        $expected = new ColumnVector([6.200000000000001, 2.8000000000000003, -6.6]);
+        $expected = ColumnVector::fromArray([6.200000000000001, 2.8000000000000003, -6.6]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
 
         $max = $a->quantile(1.0);
 
-        $maxExpected = new ColumnVector([22.0, 11.0, 20.0]);
+        $maxExpected = ColumnVector::fromArray([22.0, 11.0, 20.0]);
 
         $this->assertEqualsWithDelta($maxExpected, $max, self::MAX_DELTA);
 
@@ -2652,7 +2652,7 @@ public function quantile() : void
             [8.0],
         ]);
 
-        $singleExpected = new ColumnVector([5.0, 3.0, 8.0]);
+        $singleExpected = ColumnVector::fromArray([5.0, 3.0, 8.0]);
 
         $this->assertEqualsWithDelta(
             $singleExpected,
@@ -2674,7 +2674,7 @@ public function variance() : void
 
         $b = $a->variance();
 
-        $expected = new ColumnVector([273.55555555555554, 28.222222222222225, 169.55555555555554]);
+        $expected = ColumnVector::fromArray([273.55555555555554, 28.222222222222225, 169.55555555555554]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2691,7 +2691,7 @@ public function varianceRowNonSquare() : void
 
         $b = $a->variance();
 
-        $expected = new ColumnVector([0.6666666666666666, 66.66666666666667]);
+        $expected = ColumnVector::fromArray([0.6666666666666666, 66.66666666666667]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -3183,7 +3183,7 @@ public function dotDimensionMismatchThrows() : void
         Matrix::fromArray([
             [1.0, 2.0, 3.0],
             [4.0, 5.0, 6.0],
-        ])->dot(new Vector([1.0, 2.0]));
+        ])->dot(Vector::fromArray([1.0, 2.0]));
     }
 
     /**
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index 9962920..b241821 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -36,7 +36,7 @@ class VectorTest extends TestCase
      */
     public function build() : void
     {
-        $vector = new Vector([1, 2, 3, 4, 5]);
+        $vector = Vector::fromArray([1, 2, 3, 4, 5]);
 
         $this->assertInstanceOf(Vector::class, $vector);
         $this->assertInstanceOf(Tensor::class, $vector);
@@ -54,7 +54,7 @@ public function build() : void
      */
     public function buildCastsIntegersToFloats() : void
     {
-        $vector = new Vector([1, 2, 3, 4, 5]);
+        $vector = Vector::fromArray([1, 2, 3, 4, 5]);
 
         $this->assertSame(5, $vector->size());
 
@@ -76,7 +76,7 @@ public function zeros() : void
     {
         $zeros = Vector::zeros(4);
 
-        $expected = new Vector([0, 0, 0, 0]);
+        $expected = Vector::fromArray([0, 0, 0, 0]);
 
         $this->assertEquals($expected, $zeros);
     }
@@ -88,7 +88,7 @@ public function ones() : void
     {
         $ones = Vector::ones(4);
 
-        $expected = new Vector([1, 1, 1, 1]);
+        $expected = Vector::fromArray([1, 1, 1, 1]);
 
         $this->assertEquals($expected, $ones);
     }
@@ -100,7 +100,7 @@ public function fill() : void
     {
         $vector = Vector::fill(16, 4);
 
-        $expected = new Vector([16, 16, 16, 16]);
+        $expected = Vector::fromArray([16, 16, 16, 16]);
 
         $this->assertEquals($expected, $vector);
     }
@@ -280,7 +280,7 @@ public function range() : void
     {
         $vector = Vector::range(5.0, 12.0, 2.0);
 
-        $expected = new Vector([5.0, 7.0, 9.0, 11.0]);
+        $expected = Vector::fromArray([5.0, 7.0, 9.0, 11.0]);
 
         $this->assertEquals($expected, $vector);
     }
@@ -292,7 +292,7 @@ public function linspace() : void
     {
         $vector = Vector::linspace(-5.0, 5.0, 10);
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             -5.0, -3.888888888888889, -2.7777777777777777, -1.6666666666666665, -0.5555555555555554,
             0.5555555555555558, 1.666666666666667, 2.777777777777778, 3.8888888888888893, 5.0,
         ]);
@@ -317,11 +317,11 @@ public function shape(Vector $vector, array $expected) : void
      */
     public function shapeProvider() : Generator
     {
-        yield [new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]), [8]];
+        yield [Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]), [8]];
 
-        yield [new Vector([0.25]), [1]];
+        yield [Vector::fromArray([0.25]), [1]];
 
-        yield [new Vector([]), [0]];
+        yield [Vector::fromArray([]), [0]];
     }
 
     /**
@@ -329,7 +329,7 @@ public function shapeProvider() : Generator
      */
     public function shapeString() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals('8', $vector->shapeString());
     }
@@ -339,7 +339,7 @@ public function shapeString() : void
      */
     public function size() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(8, $vector->size());
     }
@@ -349,7 +349,7 @@ public function size() : void
      */
     public function m() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(1, $vector->m());
     }
@@ -359,7 +359,7 @@ public function m() : void
      */
     public function n() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(8, $vector->n());
     }
@@ -369,7 +369,7 @@ public function n() : void
      */
     public function asArray() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $expected = [-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0];
 
@@ -381,7 +381,7 @@ public function asArray() : void
      */
     public function serialization() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0]);
 
         $serialized = serialize($vector);
 
@@ -399,7 +399,7 @@ public function serialization() : void
      */
     public function asRowMatrix() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $matrix = $vector->asRowMatrix();
 
@@ -415,7 +415,7 @@ public function asRowMatrix() : void
      */
     public function asColumnMatrix() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $matrix = $vector->asColumnMatrix();
 
@@ -429,7 +429,7 @@ public function asColumnMatrix() : void
      */
     public function reshape() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $matrix = $vector->reshape(4, 2);
 
@@ -448,11 +448,11 @@ public function reshape() : void
      */
     public function transpose() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $vector = $vector->transpose();
 
-        $expected = new ColumnVector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $expected = ColumnVector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals($expected, $vector);
     }
@@ -462,7 +462,7 @@ public function transpose() : void
      */
     public function map() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $sign = function ($value) {
             return $value >= 0.0 ? 1 : 0;
@@ -470,7 +470,7 @@ public function map() : void
 
         $vector = $vector->map($sign);
 
-        $expected = new Vector([0, 1, 1, 0, 0, 1, 1, 1]);
+        $expected = Vector::fromArray([0, 1, 1, 0, 0, 1, 1, 1]);
 
         $this->assertEquals($expected, $vector);
     }
@@ -480,7 +480,7 @@ public function map() : void
      */
     public function reduce() : void
     {
-        $vector = new Vector([1.0, 2.0, 3.0]);
+        $vector = Vector::fromArray([1.0, 2.0, 3.0]);
 
         $sum = function ($carry, $value) {
             return $carry + $value;
@@ -507,11 +507,11 @@ public function reduce() : void
      */
     public function reciprocal() : void
     {
-        $vector = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $vector = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $vector = $vector->reciprocal();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             -0.06666666666666667, 0.04, 0.02857142857142857, -0.027777777777777776,
             -0.013888888888888888, 0.011235955056179775, 0.009433962264150943, 0.022222222222222223,
         ]);
@@ -524,9 +524,9 @@ public function reciprocal() : void
      */
     public function dot() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
+        $b = Vector::fromArray([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
 
         $c = $a->dot($b);
 
@@ -535,7 +535,7 @@ public function dot() : void
 
     public function matmul() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = Matrix::fromArray([
             [1.1, 0.01, 6.23],
@@ -560,9 +560,9 @@ public function matmul() : void
      */
     public function inner() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
+        $b = Vector::fromArray([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
 
         $c = $a->inner($b);
 
@@ -574,9 +574,9 @@ public function inner() : void
      */
     public function outer() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
+        $b = Vector::fromArray([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]);
 
         $c = $a->outer($b);
 
@@ -599,13 +599,13 @@ public function outer() : void
      */
     public function convolve() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $b = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $c = $a->convolve($b, 1);
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             -60.0, 2.5, 259.0, -144.0, 40.5, 370.1, 462.20000000000005,
             10.000000000000114, 1764.3000000000002, 1625.1, 2234.7, 1378.4, 535.5,
         ]);
@@ -622,13 +622,13 @@ public function convolve() : void
      */
     public function convolveFullReadsNoOutOfBounds() : void
     {
-        $a = new Vector([5.0, 2.0, 7.0, 1.0, 9.0, 3.0]);
+        $a = Vector::fromArray([5.0, 2.0, 7.0, 1.0, 9.0, 3.0]);
 
-        $b = new Vector([1.0, 2.0, 3.0]);
+        $b = Vector::fromArray([1.0, 2.0, 3.0]);
 
         $c = $a->convolve($b, 1);
 
-        $expected = new Vector([5.0, 12.0, 26.0, 21.0, 32.0, 24.0, 33.0, 9.0]);
+        $expected = Vector::fromArray([5.0, 12.0, 26.0, 21.0, 32.0, 24.0, 33.0, 9.0]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
     }
@@ -638,13 +638,13 @@ public function convolveFullReadsNoOutOfBounds() : void
      */
     public function convolveStrideTwo() : void
     {
-        $a = new Vector([5.0, 2.0, 7.0, 1.0, 9.0, 3.0]);
+        $a = Vector::fromArray([5.0, 2.0, 7.0, 1.0, 9.0, 3.0]);
 
-        $b = new Vector([1.0, 2.0, 3.0]);
+        $b = Vector::fromArray([1.0, 2.0, 3.0]);
 
         $c = $a->convolve($b, 2);
 
-        $expected = new Vector([5.0, 26.0, 32.0, 33.0]);
+        $expected = Vector::fromArray([5.0, 26.0, 32.0, 33.0]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
     }
@@ -670,7 +670,7 @@ public function multiply(Vector $a, $b, $expected) : void
     public function multiplyProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
@@ -684,15 +684,15 @@ public function multiplyProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([-3.75, 2.5, 70.0, 18.0, 72.0, -267.0, 349.79999999999995, 90.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([-3.75, 2.5, 70.0, 18.0, 72.0, -267.0, 349.79999999999995, 90.0]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             2.0,
-            new Vector([-30.0, 50.0, 70.0, -72.0, -144.0, 178.0, 212.0, 90.0]),
+            Vector::fromArray([-30.0, 50.0, 70.0, -72.0, -144.0, 178.0, 212.0, 90.0]),
         ];
     }
 
@@ -717,7 +717,7 @@ public function divide(Vector $a, $b, $expected) : void
     public function divideProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
@@ -731,15 +731,15 @@ public function divideProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([-60.0, 250.0, 17.5, 72.0, 72.0, -29.666666666666668, 32.121212121212125, 22.5]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([-60.0, 250.0, 17.5, 72.0, 72.0, -29.666666666666668, 32.121212121212125, 22.5]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             2.0,
-            new Vector([-7.5, 12.5, 17.5, -18.0, -36.0, 44.5, 53, 22.5]),
+            Vector::fromArray([-7.5, 12.5, 17.5, -18.0, -36.0, 44.5, 53, 22.5]),
         ];
     }
 
@@ -764,7 +764,7 @@ public function add(Vector $a, $b, $expected) : void
     public function addProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
@@ -778,15 +778,15 @@ public function addProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([-14.75, 25.1, 37.0, -36.5, -73.0, 86.0, 109.3, 47.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([-14.75, 25.1, 37.0, -36.5, -73.0, 86.0, 109.3, 47.0]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             10.0,
-            new Vector([-5.0, 35.0, 45.0, -26.0, -62.0, 99.0, 116.0, 55.0]),
+            Vector::fromArray([-5.0, 35.0, 45.0, -26.0, -62.0, 99.0, 116.0, 55.0]),
         ];
     }
 
@@ -811,7 +811,7 @@ public function subtract(Vector $a, $b, $expected) : void
     public function subtractProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
@@ -825,15 +825,15 @@ public function subtractProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([-15.25, 24.9, 33.0, -35.5, -71.0, 92.0, 102.7, 43.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([-15.25, 24.9, 33.0, -35.5, -71.0, 92.0, 102.7, 43.0]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             10.0,
-            new Vector([-25.0, 15.0, 25.0, -46.0, -82.0, 79.0, 96.0, 35.0]),
+            Vector::fromArray([-25.0, 15.0, 25.0, -46.0, -82.0, 79.0, 96.0, 35.0]),
         ];
     }
 
@@ -858,7 +858,7 @@ public function power(Vector $a, $b, $expected) : void
     public function powProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
@@ -872,15 +872,15 @@ public function powProvider() : Generator
         ];
 
         yield [
-            new Vector([3.0, 6.0, 9.0]),
-            new Vector([3.0, 2.0, 1.0]),
-            new Vector([27.0, 36.0, 9.0]),
+            Vector::fromArray([3.0, 6.0, 9.0]),
+            Vector::fromArray([3.0, 2.0, 1.0]),
+            Vector::fromArray([27.0, 36.0, 9.0]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             4.0,
-            new Vector([
+            Vector::fromArray([
                 50625, 390625, 1500625, 1679616, 26873856, 62742241, 126247696, 4100625
             ]),
         ];
@@ -907,7 +907,7 @@ public function equal(Vector $a, $b, $expected) : void
     public function equalProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
@@ -921,15 +921,15 @@ public function equalProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([0, 0, 0, 1, 0, 0, 0, 0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([0, 0, 0, 1, 0, 0, 0, 0]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            new Vector([0, 1, 0, 0, 0, 0, 0, 0]),
+            Vector::fromArray([0, 1, 0, 0, 0, 0, 0, 0]),
         ];
     }
 
@@ -954,7 +954,7 @@ public function notEqual(Vector $a, $b, $expected) : void
     public function notEqualProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
@@ -968,15 +968,15 @@ public function notEqualProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([1, 1, 1, 0, 1, 1, 1, 1]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([1, 1, 1, 0, 1, 1, 1, 1]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            new Vector([1, 0, 1, 1, 1, 1, 1, 1]),
+            Vector::fromArray([1, 0, 1, 1, 1, 1, 1, 1]),
         ];
     }
 
@@ -987,7 +987,7 @@ public function notEqualMatrixDimensionMismatch() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        $a = new Vector([1.0, 2.0, 3.0]);
+        $a = Vector::fromArray([1.0, 2.0, 3.0]);
 
         $b = Matrix::fromArray([
             [1.0, 2.0],
@@ -1018,7 +1018,7 @@ public function greater(Vector $a, $b, $expected) : void
     public function greaterProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
@@ -1032,15 +1032,15 @@ public function greaterProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([0, 1, 1, 0, 0, 1, 1, 1]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([0, 1, 1, 0, 0, 1, 1, 1]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             1.0,
-            new Vector([0, 1, 1, 0, 0, 1, 1, 1]),
+            Vector::fromArray([0, 1, 1, 0, 0, 1, 1, 1]),
         ];
     }
 
@@ -1065,7 +1065,7 @@ public function greaterEqual(Vector $a, $b, $expected) : void
     public function greaterEqualProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
@@ -1079,15 +1079,15 @@ public function greaterEqualProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([0, 1, 1, 1, 0, 1, 1, 1]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([0, 1, 1, 1, 0, 1, 1, 1]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            new Vector([0, 1, 1, 0, 0, 1, 1, 1]),
+            Vector::fromArray([0, 1, 1, 0, 0, 1, 1, 1]),
         ];
     }
 
@@ -1112,7 +1112,7 @@ public function less(Vector $a, $b, $expected) : void
     public function lessProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
@@ -1126,15 +1126,15 @@ public function lessProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([1, 0, 0, 0, 1, 0, 0, 0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([1, 0, 0, 0, 1, 0, 0, 0]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            new Vector([1, 0, 0, 1, 1, 0, 0, 0]),
+            Vector::fromArray([1, 0, 0, 1, 1, 0, 0, 0]),
         ];
     }
 
@@ -1159,7 +1159,7 @@ public function lessEqual(Vector $a, $b, $expected) : void
     public function lessEqualProvider() : Generator
     {
         yield [
-            new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
+            Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]),
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
@@ -1174,15 +1174,15 @@ public function lessEqualProvider() : Generator
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([1, 0, 0, 1, 1, 0, 0, 0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([1, 0, 0, 1, 1, 0, 0, 0]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            new Vector([1, 1, 0, 1, 1, 0, 0, 0]),
+            Vector::fromArray([1, 1, 0, 1, 1, 0, 0, 0]),
         ];
     }
 
@@ -1207,15 +1207,15 @@ public function mod(Vector $a, $b, $expected) : void
     public function modProvider() : Generator
     {
         yield [
-            new Vector([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            new Vector([0, 0, 2, 0, -1, -3, 3, 2]),
+            Vector::fromArray([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([0, 0, 2, 0, -1, -3, 3, 2]),
         ];
 
         yield [
-            new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
+            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             4,
-            new Vector([-3, 1, 3, 0, 0, 1, 2, 1]),
+            Vector::fromArray([-3, 1, 3, 0, 0, 1, 2, 1]),
         ];
     }
 
@@ -1224,11 +1224,11 @@ public function modProvider() : Generator
      */
     public function abs() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->abs();
 
-        $expected = new Vector([15, 25, 35, 36, 72, 89, 106, 45]);
+        $expected = Vector::fromArray([15, 25, 35, 36, 72, 89, 106, 45]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1238,11 +1238,11 @@ public function abs() : void
      */
     public function square() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->square();
 
-        $expected = new Vector([225, 625, 1225, 1296, 5184, 7921, 11236, 2025]);
+        $expected = Vector::fromArray([225, 625, 1225, 1296, 5184, 7921, 11236, 2025]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -1252,11 +1252,11 @@ public function square() : void
      */
     public function pow() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->pow(3);
 
-        $expected = new Vector([-3375, 15625, 42875, -46656, -373248, 704969, 1191016, 91125]);
+        $expected = Vector::fromArray([-3375, 15625, 42875, -46656, -373248, 704969, 1191016, 91125]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -1266,11 +1266,11 @@ public function pow() : void
      */
     public function sqrt() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->sqrt();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             2.0, 2.5495097567963922, 1.70293863659264, 4.47213595499958,
             1.61245154965971, 3.449637662132068,
         ]);
@@ -1283,11 +1283,11 @@ public function sqrt() : void
      */
     public function exp() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->exp();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             54.598150033144236, 665.1416330443618, 18.17414536944306,
             485165195.4097903, 13.463738035001692, 147266.6252405527,
         ]);
@@ -1300,11 +1300,11 @@ public function exp() : void
      */
     public function log() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->log();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             1.3862943611198906, 1.8718021769015913, 1.0647107369924282,
             2.995732273553991, 0.9555114450274363, 2.4765384001174837,
         ]);
@@ -1317,11 +1317,11 @@ public function log() : void
      */
     public function sin() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->sin();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             -0.7568024953079282, 0.21511998808781552, 0.23924932921398243,
             0.9129452507276277, 0.5155013718214642, -0.6181371122370333,
         ]);
@@ -1334,11 +1334,11 @@ public function sin() : void
      */
     public function asin() : void
     {
-        $a = new Vector([0.1, 0.3, -0.5]);
+        $a = Vector::fromArray([0.1, 0.3, -0.5]);
 
         $b = $a->asin();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             0.1001674211615598, 0.3046926540153975, -0.5235987755982989,
         ]);
 
@@ -1350,11 +1350,11 @@ public function asin() : void
      */
     public function cos() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->cos();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             -0.6536436208636119, 0.9765876257280235, -0.9709581651495905,
             0.40808206181339196, -0.8568887533689473, 0.7860702961410393,
         ]);
@@ -1367,11 +1367,11 @@ public function cos() : void
      */
     public function acos() : void
     {
-        $a = new Vector([0.1, 0.3, -0.5]);
+        $a = Vector::fromArray([0.1, 0.3, -0.5]);
 
         $b = $a->acos();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             1.4706289056333368, 1.2661036727794992, 2.0943951023931957,
         ]);
 
@@ -1383,11 +1383,11 @@ public function acos() : void
      */
     public function tan() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->tan();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             1.1578212823495777, 0.22027720034589682, -0.24640539397196634,
             2.237160944224742, -0.6015966130897586, -0.7863636563696398,
         ]);
@@ -1400,11 +1400,11 @@ public function tan() : void
      */
     public function atan() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->atan();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             1.3258176636680326, 1.4181469983996315, 1.2387368592520112,
             1.5208379310729538, 1.2036224929766774, 1.486959684726482,
         ]);
@@ -1417,11 +1417,11 @@ public function atan() : void
      */
     public function rad2deg() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->rad2deg();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             229.1831180523293, 372.42256683503507, 166.15776058793872,
             1145.9155902616465, 148.96902673401405, 681.8197762056797,
         ]);
@@ -1434,11 +1434,11 @@ public function rad2deg() : void
      */
     public function deg2rad() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->deg2rad();
 
-        $expected = new Vector([
+        $expected = Vector::fromArray([
             0.06981317007977318, 0.11344640137963141, 0.05061454830783556,
             0.3490658503988659, 0.04537856055185257, 0.2076941809873252,
         ]);
@@ -1451,7 +1451,7 @@ public function deg2rad() : void
      */
     public function sum() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(177.0, $a->sum(), self::MAX_DELTA);
     }
@@ -1461,7 +1461,7 @@ public function sum() : void
      */
     public function product() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(-14442510600000.0, $a->product(), self::MAX_DELTA);
     }
@@ -1471,7 +1471,7 @@ public function product() : void
      */
     public function min() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(-72, $a->min());
     }
@@ -1481,7 +1481,7 @@ public function min() : void
      */
     public function max() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(106, $a->max());
     }
@@ -1491,7 +1491,7 @@ public function max() : void
      */
     public function mean() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(22.125, $a->mean(), self::MAX_DELTA);
     }
@@ -1501,7 +1501,7 @@ public function mean() : void
      */
     public function median() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals(30.0, $a->median());
     }
@@ -1511,13 +1511,13 @@ public function median() : void
      */
     public function quantile() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(30.0, $a->quantile(0.5), self::MAX_DELTA);
         $this->assertEqualsWithDelta(-72.0, $a->quantile(0.0), self::MAX_DELTA);
         $this->assertEqualsWithDelta(106.0, $a->quantile(1.0), self::MAX_DELTA);
 
-        $single = new Vector([5.0]);
+        $single = Vector::fromArray([5.0]);
 
         $this->assertEqualsWithDelta(5.0, $single->quantile(0.0), self::MAX_DELTA);
         $this->assertEqualsWithDelta(5.0, $single->quantile(0.5), self::MAX_DELTA);
@@ -1529,7 +1529,7 @@ public function quantile() : void
      */
     public function variance() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(3227.609375, $a->variance(), self::MAX_DELTA);
     }
@@ -1539,11 +1539,11 @@ public function variance() : void
      */
     public function round() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->round(2);
 
-        $expected = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $expected = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -1553,11 +1553,11 @@ public function round() : void
      */
     public function floor() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->floor();
 
-        $expected = new Vector([4.0, 6.0, 2.0, 20.0, 2.0, 11.0]);
+        $expected = Vector::fromArray([4.0, 6.0, 2.0, 20.0, 2.0, 11.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1567,11 +1567,11 @@ public function floor() : void
      */
     public function ceil() : void
     {
-        $a = new Vector([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
         $b = $a->ceil();
 
-        $expected = new Vector([4.0, 7.0, 3.0, 20.0, 3.0, 12.0]);
+        $expected = Vector::fromArray([4.0, 7.0, 3.0, 20.0, 3.0, 12.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1581,7 +1581,7 @@ public function ceil() : void
      */
     public function l1Norm() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(423.0, $a->l1Norm(), self::MAX_DELTA);
     }
@@ -1591,7 +1591,7 @@ public function l1Norm() : void
      */
     public function l2Norm() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(172.4441938715247, $a->l2Norm(), self::MAX_DELTA);
     }
@@ -1601,7 +1601,7 @@ public function l2Norm() : void
      */
     public function pNorm() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(135.15554088861361, $a->pNorm(3.0), self::MAX_DELTA);
     }
@@ -1611,7 +1611,7 @@ public function pNorm() : void
      */
     public function maxNorm() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEqualsWithDelta(106.0, $a->maxNorm(), self::MAX_DELTA);
     }
@@ -1621,11 +1621,11 @@ public function maxNorm() : void
      */
     public function clip() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->clip(0.0, 100);
 
-        $expected = new Vector([0.0, 25, 35, 0.0, 0.0, 89, 100.0, 45]);
+        $expected = Vector::fromArray([0.0, 25, 35, 0.0, 0.0, 89, 100.0, 45]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1635,11 +1635,11 @@ public function clip() : void
      */
     public function clipLower() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->clipLower(60.0);
 
-        $expected = new Vector([60.0, 60.0, 60.0, 60.0, 60.0, 89, 106.0, 60.0]);
+        $expected = Vector::fromArray([60.0, 60.0, 60.0, 60.0, 60.0, 89, 106.0, 60.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1649,11 +1649,11 @@ public function clipLower() : void
      */
     public function clipUpper() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->clipUpper(50.0);
 
-        $expected = new Vector([-15.0, 25, 35, -36.0, -72.0, 50.0, 50.0, 45]);
+        $expected = Vector::fromArray([-15.0, 25, 35, -36.0, -72.0, 50.0, 50.0, 45]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1663,11 +1663,11 @@ public function clipUpper() : void
      */
     public function sign() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->sign();
 
-        $expected = new Vector([-1, 1, 1, -1, -1, 1, 1, 1]);
+        $expected = Vector::fromArray([-1, 1, 1, -1, -1, 1, 1, 1]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1677,11 +1677,11 @@ public function sign() : void
      */
     public function negate() : void
     {
-        $a = new Vector([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
         $b = $a->negate();
 
-        $expected = new Vector([15, -25, -35, 36, 72, -89, -106, -45]);
+        $expected = Vector::fromArray([15, -25, -35, 36, 72, -89, -106, -45]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1783,7 +1783,7 @@ public function reshapeSizeMismatchThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        (new Vector([1.0, 2.0, 3.0, 4.0]))->reshape(2, 3);
+        (Vector::fromArray([1.0, 2.0, 3.0, 4.0]))->reshape(2, 3);
     }
 
     /**
@@ -1793,7 +1793,7 @@ public function quantileOutOfRangeThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->quantile(-0.1);
+        (Vector::fromArray([1.0, 2.0, 3.0]))->quantile(-0.1);
     }
 
     /**
@@ -1803,7 +1803,7 @@ public function quantileAboveOneThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->quantile(1.1);
+        (Vector::fromArray([1.0, 2.0, 3.0]))->quantile(1.1);
     }
 
     /**
@@ -1813,7 +1813,7 @@ public function pNormNonPositiveThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->pNorm(0.0);
+        (Vector::fromArray([1.0, 2.0, 3.0]))->pNorm(0.0);
     }
 
     /**
@@ -1823,7 +1823,7 @@ public function dotDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->dot(new Vector([1.0, 2.0]));
+        (Vector::fromArray([1.0, 2.0, 3.0]))->dot(Vector::fromArray([1.0, 2.0]));
     }
 
     /**
@@ -1833,7 +1833,7 @@ public function multiplyDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->multiply(new Vector([1.0, 2.0]));
+        (Vector::fromArray([1.0, 2.0, 3.0]))->multiply(Vector::fromArray([1.0, 2.0]));
     }
 
     /**
@@ -1843,7 +1843,7 @@ public function divideDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->divide(new Vector([1.0, 2.0]));
+        (Vector::fromArray([1.0, 2.0, 3.0]))->divide(Vector::fromArray([1.0, 2.0]));
     }
 
     /**
@@ -1853,7 +1853,7 @@ public function addDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->add(new Vector([1.0, 2.0]));
+        (Vector::fromArray([1.0, 2.0, 3.0]))->add(Vector::fromArray([1.0, 2.0]));
     }
 
     /**
@@ -1863,7 +1863,7 @@ public function subtractDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->subtract(new Vector([1.0, 2.0]));
+        (Vector::fromArray([1.0, 2.0, 3.0]))->subtract(Vector::fromArray([1.0, 2.0]));
     }
 
     /**
@@ -1873,7 +1873,7 @@ public function powDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->pow(new Vector([1.0, 2.0]));
+        (Vector::fromArray([1.0, 2.0, 3.0]))->pow(Vector::fromArray([1.0, 2.0]));
     }
 
     /**
@@ -1883,7 +1883,7 @@ public function modDimensionMismatchThrows() : void
     {
         $this->expectException(DimensionalityMismatch::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->mod(new Vector([1.0, 2.0]));
+        (Vector::fromArray([1.0, 2.0, 3.0]))->mod(Vector::fromArray([1.0, 2.0]));
     }
 
     /**
@@ -1904,51 +1904,51 @@ public function arithmeticWithWrongOperandTypeThrows(callable $operation) : void
     public function wrongOperandTypeProvider() : Generator
     {
         yield 'multiply' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->multiply('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->multiply('not a valid operand');
         }];
 
         yield 'divide' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->divide('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->divide('not a valid operand');
         }];
 
         yield 'add' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->add('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->add('not a valid operand');
         }];
 
         yield 'subtract' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->subtract('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->subtract('not a valid operand');
         }];
 
         yield 'pow' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->pow('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->pow('not a valid operand');
         }];
 
         yield 'mod' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->mod('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->mod('not a valid operand');
         }];
 
         yield 'equal' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->equal('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->equal('not a valid operand');
         }];
 
         yield 'notEqual' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->notEqual('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->notEqual('not a valid operand');
         }];
 
         yield 'greater' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->greater('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->greater('not a valid operand');
         }];
 
         yield 'greaterEqual' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->greaterEqual('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->greaterEqual('not a valid operand');
         }];
 
         yield 'less' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->less('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->less('not a valid operand');
         }];
 
         yield 'lessEqual' => [function () {
-            (new Vector([1.0, 2.0, 3.0]))->lessEqual('not a valid operand');
+            (Vector::fromArray([1.0, 2.0, 3.0]))->lessEqual('not a valid operand');
         }];
     }
 
@@ -1959,7 +1959,7 @@ public function convolveStrideLessThanOneThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        (new Vector([1.0, 2.0, 3.0]))->convolve(new Vector([1.0, 1.0]), 0);
+        (Vector::fromArray([1.0, 2.0, 3.0]))->convolve(Vector::fromArray([1.0, 1.0]), 0);
     }
 
     /**
@@ -1969,7 +1969,7 @@ public function convolveKernelLargerThanVectorThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        (new Vector([1.0, 2.0]))->convolve(new Vector([1.0, 2.0, 3.0]));
+        (Vector::fromArray([1.0, 2.0]))->convolve(Vector::fromArray([1.0, 2.0, 3.0]));
     }
 
     /**
@@ -1979,7 +1979,7 @@ public function offsetSetThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        $a = new Vector([1.0, 2.0, 3.0]);
+        $a = Vector::fromArray([1.0, 2.0, 3.0]);
 
         $a[0] = 4.0;
     }
@@ -1991,7 +1991,7 @@ public function offsetUnsetThrows() : void
     {
         $this->expectException(RuntimeException::class);
 
-        $a = new Vector([1.0, 2.0, 3.0]);
+        $a = Vector::fromArray([1.0, 2.0, 3.0]);
 
         unset($a[0]);
     }
@@ -2003,7 +2003,7 @@ public function offsetGetOutOfBoundsThrows() : void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        $a = new Vector([1.0, 2.0, 3.0]);
+        $a = Vector::fromArray([1.0, 2.0, 3.0]);
 
         $this->assertEquals(0.0, $a[10]);
     }

From 234d9c4747ff8e69f50a65c6546fd21901077f46 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 17:27:12 -0500
Subject: [PATCH 26/51] Save game

---
 ext/include/buffer.c           |  54 ++-
 ext/kernel/operators.c         |  35 ++
 ext/kernel/operators.h         |   2 +
 ext/tensor/columnvector.zep.c  |  22 +-
 ext/tensor/tensorbuffer.zep.c  | 115 +++--
 ext/tensor/vector.zep.c        |   6 +-
 phpunit.xml                    |   2 +-
 tensor/tensorbuffer.zep        |  42 +-
 tests/MatrixTest.php           | 778 ++++++++++++++++-----------------
 tests/TensorBufferTest.php     |  61 +++
 tests/TensorComparator.php     | 132 ++++++
 tests/TensorComparatorTest.php | 158 +++++++
 tests/VectorTest.php           |   8 +-
 tests/bootstrap.php            |  10 +
 14 files changed, 971 insertions(+), 454 deletions(-)
 create mode 100644 tests/TensorComparator.php
 create mode 100644 tests/TensorComparatorTest.php
 create mode 100644 tests/bootstrap.php

diff --git a/ext/include/buffer.c b/ext/include/buffer.c
index 0cb1395..bcab5ca 100644
--- a/ext/include/buffer.c
+++ b/ext/include/buffer.c
@@ -10,6 +10,7 @@
 #include "kernel/exception.h"
 #include "kernel/operators.h"
 #include "include/buffer.h"
+#include "../tensor/exceptions/invalidargumentexception.zep.h"
 
 #ifdef ZEPHIR_BUFFER_ENABLED
 
@@ -493,13 +494,26 @@ void tensor_buffer_slice_strided(zval * return_value, zval * obj, zval * offset,
 		return;
 	}
 
-	if (UNEXPECTED(offsetHat < 0 || lengthHat < 0 || strideHat < 1
-		|| (lengthHat > 0 && offsetHat + (lengthHat - 1) * strideHat > len - 1))) {
+	if (UNEXPECTED(offsetHat < 0 || lengthHat < 0 || strideHat < 1)) {
 		zephir_throw_exception_string(spl_ce_OutOfBoundsException,
 			SL("Slice offset, length, and stride must be within the bounds of the buffer."));
 		return;
 	}
 
+	if (lengthHat > 0) {
+		zend_long last = len - 1 - offsetHat;
+
+		/* Integer division on non-negative operands is exact and immune to the
+		 * signed overflow of (lengthHat - 1) * strideHat, which wraps for huge
+		 * arguments and previously let the guard pass while the copy below read
+		 * far out of bounds. */
+		if (UNEXPECTED(last < 0 || (lengthHat - 1) > last / strideHat)) {
+			zephir_throw_exception_string(spl_ce_OutOfBoundsException,
+				SL("Slice offset, length, and stride must be within the bounds of the buffer."));
+			return;
+		}
+	}
+
 	if (UNEXPECTED(zephir_buffer_create(return_value, lengthHat, kind) == FAILURE)) {
 		return;
 	}
@@ -513,16 +527,26 @@ void tensor_buffer_slice_strided(zval * return_value, zval * obj, zval * offset,
 	if (kind == ZEPHIR_BUFFER_LONG) {
 		const zend_long * src = zephir_buffer_longs(obj);
 		zend_long * dst = zephir_buffer_longs(return_value);
+		zend_long index = offsetHat;
 
 		for (i = 0; i < lengthHat; ++i) {
-			dst[i] = src[offsetHat + i * strideHat];
+			dst[i] = src[index];
+
+			if (i + 1 < lengthHat) {
+				index += strideHat;
+			}
 		}
 	} else {
 		const double * src = zephir_buffer_doubles(obj);
 		double * dst = zephir_buffer_doubles(return_value);
+		zend_long index = offsetHat;
 
 		for (i = 0; i < lengthHat; ++i) {
-			dst[i] = src[offsetHat + i * strideHat];
+			dst[i] = src[index];
+
+			if (i + 1 < lengthHat) {
+				index += strideHat;
+			}
 		}
 	}
 }
@@ -626,7 +650,19 @@ void tensor_buffer_split(zval * return_value, zval * obj, zval * chunk_length)
 		return;
 	}
 
-	zend_long chunks = len == 0 ? 0 : (len + chunkHat - 1) / chunkHat;
+	zend_long chunks;
+
+	if (UNEXPECTED(len == 0)) {
+		chunks = 0;
+	} else if (UNEXPECTED(chunkHat > len)) {
+		/* The whole buffer fits in one chunk; avoids the overflow of
+		 * len + chunkHat - 1 for a chunk length near LONG_MAX. */
+		chunks = 1;
+	} else {
+		/* Both operands are at most 2 * len, so the sum cannot overflow. */
+		chunks = (len + chunkHat - 1) / chunkHat;
+	}
+
 	zend_long i;
 
 	array_init_size(return_value, (zend_ulong) chunks);
@@ -680,6 +716,14 @@ void tensor_buffer_repeat(zval * return_value, zval * obj, zval * times)
 		return;
 	}
 
+	/* Reject before len * timesHat wraps; the product is then guaranteed to
+	 * fit, so every i * len destination offset stays in bounds. */
+	if (UNEXPECTED(len > 0 && timesHat > ZEND_LONG_MAX / len)) {
+		zephir_throw_exception_string(tensor_exceptions_invalidargumentexception_ce,
+			SL("Repeat count must not overflow the buffer length."));
+		return;
+	}
+
 	zend_long total = len * timesHat;
 	zend_long i;
 
diff --git a/ext/kernel/operators.c b/ext/kernel/operators.c
index bb36f33..5666aaf 100644
--- a/ext/kernel/operators.c
+++ b/ext/kernel/operators.c
@@ -208,6 +208,41 @@ void zephir_concat_self_long(zval *left, const zend_long right)
 	zend_string_release(right_str);
 }
 
+/**
+ * Appends the string form of the right operator to the left operator.
+ *
+ * Mirrors what PHP does for `$s .= $d` with an `IS_DOUBLE` right operand:
+ * `concat_function()` renders it through `zval_get_string()`, which reads
+ * `EG(precision)` at run time. Rendering the value here with `printf()` would
+ * freeze that precision at build time, and `zend_double_to_str()` reaches the
+ * conversion directly but only exists on PHP 8.1 and later. Boxing the operand
+ * and letting `zephir_concat_self()` call `zephir_make_printable_zval()` is the
+ * same conversion on every supported version.
+ */
+void zephir_concat_self_double(zval *left, const double right)
+{
+	zval right_zv;
+
+	ZVAL_DOUBLE(&right_zv, right);
+	zephir_concat_self(left, &right_zv);
+}
+
+/**
+ * Appends the string form of a boolean right operator to the left operator.
+ *
+ * PHP renders `true` as "1" and `false` as the empty string. Appending nothing
+ * is not the same as doing nothing: `$v = 5; $v .= false;` leaves PHP holding
+ * the *string* "5", so `false` goes through the same conversion rather than
+ * returning early.
+ */
+void zephir_concat_self_bool(zval *left, const zend_bool right)
+{
+	zval right_zv;
+
+	ZVAL_BOOL(&right_zv, right);
+	zephir_concat_self(left, &right_zv);
+}
+
 /**
  * Natural compare with long operandus on right
  */
diff --git a/ext/kernel/operators.h b/ext/kernel/operators.h
index d2dcd15..b3648f9 100644
--- a/ext/kernel/operators.h
+++ b/ext/kernel/operators.h
@@ -85,6 +85,8 @@ void zephir_concat_self(zval *left, zval *right);
 void zephir_concat_self_str(zval *left, const char *right, int right_length);
 void zephir_concat_self_long(zval *left, const zend_long right);
 void zephir_concat_self_char(zval *left, unsigned char right);
+void zephir_concat_self_double(zval *left, const double right);
+void zephir_concat_self_bool(zval *left, const zend_bool right);
 
 /** Strict comparing */
 int zephir_compare_strict_string(zval *op1, const char *op2, int op2_length);
diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index f3e48f1..68fa8f9 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -258,7 +258,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 93);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 94);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -340,7 +340,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 116);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 118);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -422,7 +422,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 139);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 142);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -504,7 +504,7 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 162);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 166);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -586,7 +586,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 185);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 190);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -668,7 +668,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 208);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 214);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -750,7 +750,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 231);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 238);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -832,7 +832,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 254);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 262);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -914,7 +914,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 277);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 286);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -996,7 +996,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 300);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 310);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1078,7 +1078,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 323);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 334);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 6806290..21b4dc4 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -559,22 +559,22 @@ PHP_METHOD(Tensor_TensorBuffer, argmax)
  */
 PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 {
-	zval _7$$3;
-	zend_bool _0, _1, _2, _3;
+	zval _8$$10;
+	zend_bool invalid, _0, _1, _2, _5$$3, _6$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *offset_param = NULL, *length_param = NULL, *stride_param = NULL, _4, _5, b, _8, _9, _10, _11, _6$$3;
-	zend_long offset, length, stride, ZEPHIR_LAST_CALL_STATUS;
+	zval *offset_param = NULL, *length_param = NULL, *stride_param = NULL, b, _9, _10, _11, _12, _3$$3, _4$$3, _7$$10;
+	zend_long offset, length, stride, ZEPHIR_LAST_CALL_STATUS, limit, a, acc, product;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_5);
 	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_7$$3);
+	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4$$3);
+	ZVAL_UNDEF(&_7$$10);
+	ZVAL_UNDEF(&_8$$10);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
@@ -588,6 +588,10 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 3, 0, &offset_param, &length_param, &stride_param);
+	limit = 0;
+	a = 0;
+	acc = 0;
+	product = 0;
 	_0 = offset < 0;
 	if (!(_0)) {
 		_0 = length < 0;
@@ -596,34 +600,67 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 	if (!(_1)) {
 		_1 = stride < 1;
 	}
-	_2 = _1;
-	if (!(_2)) {
-		_3 = length > 0;
-		if (_3) {
-			zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-			ZEPHIR_CALL_METHOD(&_5, &_4, "count", NULL, 0);
-			zephir_check_call_status();
-			_3 = offset > ((zephir_get_numberval(&_5) - (((length - 1)) * stride)) - 1);
+	invalid = _1;
+	_2 = !invalid;
+	if (_2) {
+		_2 = length > 0;
+	}
+	if (EXPECTED(_2)) {
+		zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+		ZEPHIR_CALL_METHOD(&_4$$3, &_3$$3, "count", NULL, 0);
+		zephir_check_call_status();
+		limit = ((zephir_get_numberval(&_4$$3) - 1) - offset);
+		_5$$3 = limit < 0;
+		if (!(_5$$3)) {
+			_6$$3 = length > 1;
+			if (_6$$3) {
+				_6$$3 = stride > limit;
+			}
+			_5$$3 = _6$$3;
 		}
-		_2 = _3;
-	}
-	if (UNEXPECTED(_2)) {
-		ZEPHIR_INIT_VAR(&_6$$3);
-		object_init_ex(&_6$$3, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_INIT_VAR(&_7$$3);
-		ZEPHIR_CONCAT_SS(&_7$$3, "Offset, length, and", " stride must be within the bounds of the buffer.");
-		ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 2, &_7$$3);
+		invalid = _5$$3;
+		if (EXPECTED(!invalid)) {
+			a = (length - 1);
+			acc = stride;
+			while (1) {
+				if (!(a > 0)) {
+					break;
+				}
+				if ((a & 1)) {
+					product += acc;
+					if (product > limit) {
+						invalid = 1;
+						break;
+					}
+				}
+				a = (a >> 1);
+				if (a > 0) {
+					if (acc > ((limit >> 1))) {
+						invalid = 1;
+						break;
+					}
+					acc = (acc << 1);
+				}
+			}
+		}
+	}
+	if (UNEXPECTED(invalid)) {
+		ZEPHIR_INIT_VAR(&_7$$10);
+		object_init_ex(&_7$$10, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_8$$10);
+		ZEPHIR_CONCAT_SS(&_8$$10, "Offset, length, and", " stride must be within the bounds of the buffer.");
+		ZEPHIR_CALL_METHOD(NULL, &_7$$10, "__construct", NULL, 2, &_8$$10);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_6$$3, "tensor/tensorbuffer.zep", 222);
+		zephir_throw_exception_debug(&_7$$10, "tensor/tensorbuffer.zep", 260);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	ZEPHIR_INIT_VAR(&b);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	ZVAL_LONG(&_9, offset);
-	ZVAL_LONG(&_10, length);
-	ZVAL_LONG(&_11, stride);
-	tensor_buffer_slice_strided(&b, &_8, &_9, &_10, &_11);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_10, offset);
+	ZVAL_LONG(&_11, length);
+	ZVAL_LONG(&_12, stride);
+	tensor_buffer_slice_strided(&b, &_9, &_10, &_11, &_12);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &b);
 	zephir_check_call_status();
@@ -668,7 +705,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_get_arrval(&buffers, buffers_param);
 	ZEPHIR_INIT_VAR(&unwrapped);
 	array_init(&unwrapped);
-	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 247);
+	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 285);
 	if (Z_TYPE_P(&buffers) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&buffers), _0)
 		{
@@ -676,7 +713,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			ZVAL_COPY(&buffer, _0);
 			ZEPHIR_CALL_METHOD(&_1$$3, &buffer, "asBuffer", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 244);
+			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 282);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, &buffers, "rewind", NULL, 0);
@@ -698,7 +735,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_4$$4, &buffer, "asBuffer", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 244);
+				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 282);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -763,7 +800,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Chunk length must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 264);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 302);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -780,7 +817,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 	} else {
 		_6 = &buffers;
 	}
-	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 277);
+	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 315);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -790,7 +827,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 13, &buffer);
 			zephir_check_call_status();
-			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 274);
+			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 312);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -814,7 +851,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 13, &buffer);
 				zephir_check_call_status();
-				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 274);
+				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 312);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -864,7 +901,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Times must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 292);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 330);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 04615a0..4899e6a 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -6564,7 +6564,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 }
 
 /**
- * Does a given column exist in the matrix.
+ * Does a given element exist in the vector.
  *
  * @param mixed index
  * @return bool
@@ -6615,7 +6615,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 }
 
 /**
- * Return a row from the matrix at the given index.
+ * Return an element from the vector at the given index.
  *
  * @param mixed index
  * @throws \Tensor\Exceptions\InvalidArgumentException
@@ -6679,7 +6679,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 }
 
 /**
- * Get an iterator for the rows in the matrix.
+ * Get an iterator for the items in the vector.
  *
  * @return \ArrayIterator
  */
diff --git a/phpunit.xml b/phpunit.xml
index 55f90f6..781a583 100644
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" backupGlobals="false" backupStaticAttributes="false" bootstrap="vendor/autoload.php" colors="true" convertErrorsToExceptions="true" convertNoticesToExceptions="true" convertWarningsToExceptions="true" forceCoversAnnotation="true" processIsolation="false" stopOnFailure="false" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd">
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" backupGlobals="false" backupStaticAttributes="false" bootstrap="tests/bootstrap.php" colors="true" convertErrorsToExceptions="true" convertNoticesToExceptions="true" convertWarningsToExceptions="true" forceCoversAnnotation="true" processIsolation="false" stopOnFailure="false" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd">
   <testsuites>
     <testsuite name="Base">
       <directory>tests</directory>
diff --git a/tensor/tensorbuffer.zep b/tensor/tensorbuffer.zep
index 5e69e15..8a49230 100644
--- a/tensor/tensorbuffer.zep
+++ b/tensor/tensorbuffer.zep
@@ -216,8 +216,46 @@ class TensorBuffer
      */
     public function sliceStrided(const int offset, const int length, const int stride) -> <TensorBuffer>
     {
-        if unlikely offset < 0 || length < 0 || stride < 1
-            || (length > 0 && offset > this->buffer->count() - (length - 1) * stride - 1) {
+        int limit = 0;
+        int a = 0;
+        int acc = 0;
+        int product = 0;
+        bool invalid = offset < 0 || length < 0 || stride < 1;
+
+        if likely !invalid && length > 0 {
+            let limit = this->buffer->count() - 1 - offset;
+
+            let invalid = limit < 0 || (length > 1 && stride > limit);
+
+            if likely !invalid {
+                let a = length - 1;
+                let acc = stride;
+
+                while a > 0 {
+                    if (a & 1) {
+                        let product += acc;
+
+                        if product > limit {
+                            let invalid = true;
+                            break;
+                        }
+                    }
+
+                    let a = a >> 1;
+
+                    if a > 0 {
+                        if acc > (limit >> 1) {
+                            let invalid = true;
+                            break;
+                        }
+
+                        let acc = acc << 1;
+                    }
+                }
+            }
+        }
+
+        if unlikely invalid {
             throw new InvalidArgumentException("Offset, length, and"
                 . " stride must be within the bounds of the buffer.");
         }
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index 8720f66..be46ac0 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -43,9 +43,9 @@ class MatrixTest extends TestCase
     public function build() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $this->assertInstanceOf(Matrix::class, $matrix);
@@ -65,8 +65,8 @@ public function build() : void
     public function buildCastsIntegersToFloatsAndPreservesShape() : void
     {
         $matrix = Matrix::fromArray([
-            [1, 2, 3],
-            [4, 5, 6],
+            [1.0, 2.0, 3.0],
+            [4.0, 5.0, 6.0],
         ]);
 
         $this->assertSame([2, 3], $matrix->shape());
@@ -98,10 +98,10 @@ public function identity() : void
         $matrix = Matrix::identity(4);
 
         $expected = Matrix::fromArray([
-            [1, 0, 0, 0],
-            [0, 1, 0, 0],
-            [0, 0, 1, 0],
-            [0, 0, 0, 1],
+            [1.0, 0.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0, 0.0],
+            [0.0, 0.0, 1.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0],
         ]);
 
         $this->assertEquals($expected, $matrix);
@@ -115,8 +115,8 @@ public function zeros() : void
         $matrix = Matrix::zeros(2, 4);
 
         $expected = Matrix::fromArray([
-            [0, 0, 0, 0],
-            [0, 0, 0, 0],
+            [0.0, 0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.0],
         ]);
 
         $this->assertEquals($expected, $matrix);
@@ -130,10 +130,10 @@ public function ones() : void
         $matrix = Matrix::ones(4, 2);
 
         $expected = Matrix::fromArray([
-            [1, 1],
-            [1, 1],
-            [1, 1],
-            [1, 1],
+            [1.0, 1.0],
+            [1.0, 1.0],
+            [1.0, 1.0],
+            [1.0, 1.0],
         ]);
 
         $this->assertEquals($expected, $matrix);
@@ -144,13 +144,13 @@ public function ones() : void
      */
     public function diagonal() : void
     {
-        $matrix = Matrix::diagonal([0, 1, 4, 5]);
+        $matrix = Matrix::diagonal([0.0, 1.0, 4.0, 5.0]);
 
         $expected = Matrix::fromArray([
-            [0, 0, 0, 0],
-            [0, 1, 0, 0],
-            [0, 0, 4, 0],
-            [0, 0, 0, 5],
+            [0.0, 0.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0, 0.0],
+            [0.0, 0.0, 4.0, 0.0],
+            [0.0, 0.0, 0.0, 5.0],
         ]);
 
         $this->assertEquals($expected, $matrix);
@@ -161,13 +161,13 @@ public function diagonal() : void
      */
     public function fill() : void
     {
-        $matrix = Matrix::fill(5, 4, 4);
+        $matrix = Matrix::fill(5.0, 4, 4);
 
         $expected = Matrix::fromArray([
-            [5, 5, 5, 5],
-            [5, 5, 5, 5],
-            [5, 5, 5, 5],
-            [5, 5, 5, 5],
+            [5.0, 5.0, 5.0, 5.0],
+            [5.0, 5.0, 5.0, 5.0],
+            [5.0, 5.0, 5.0, 5.0],
+            [5.0, 5.0, 5.0, 5.0],
         ]);
 
         $this->assertEquals($expected, $matrix);
@@ -241,9 +241,9 @@ public function uniform() : void
     public function shape() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $this->assertEquals([3, 3], $matrix->shape());
@@ -255,8 +255,8 @@ public function shape() : void
     public function shapeString() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12, 16],
-            [4, 11, -2, 18],
+            [22.0, -17.0, 12.0, 16.0],
+            [4.0, 11.0, -2.0, 18.0],
         ]);
 
         $this->assertEquals('2 x 4', $matrix->shapeString());
@@ -281,17 +281,17 @@ public function isSquareProvider() : Generator
     {
         yield [
             Matrix::fromArray([
-                [22, -17, 12],
-                [4, 11, -2],
-                [20, -6, -9],
+                [22.0, -17.0, 12.0],
+                [4.0, 11.0, -2.0],
+                [20.0, -6.0, -9.0],
             ]),
             true,
         ];
 
         yield [
             Matrix::fromArray([
-                [22, -17, 12, 16],
-                [4, 11, -2, 18],
+                [22.0, -17.0, 12.0, 16.0],
+                [4.0, 11.0, -2.0, 18.0],
             ]),
             false,
         ];
@@ -303,9 +303,9 @@ public function isSquareProvider() : Generator
     public function size() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $this->assertEquals(9, $matrix->size());
@@ -317,9 +317,9 @@ public function size() : void
     public function m() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $this->assertEquals(3, $matrix->m());
@@ -331,9 +331,9 @@ public function m() : void
     public function n() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $this->assertEquals(3, $matrix->n());
@@ -345,14 +345,14 @@ public function n() : void
     public function rowAsVector() : void
     {
         $a = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $b = $a->rowAsVector(1);
 
-        $expected = Vector::fromArray([4, 11, -2]);
+        $expected = Vector::fromArray([4.0, 11.0, -2.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -363,14 +363,14 @@ public function rowAsVector() : void
     public function columnAsVector() : void
     {
         $a = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $b = $a->columnAsVector(1);
 
-        $expected = ColumnVector::fromArray([-17, 11, -6]);
+        $expected = ColumnVector::fromArray([-17.0, 11.0, -6.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -381,14 +381,14 @@ public function columnAsVector() : void
     public function diagonalAsVector() : void
     {
         $a = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $b = $a->diagonalAsVector();
 
-        $expected = Vector::fromArray([22, 11, -9]);
+        $expected = Vector::fromArray([22.0, 11.0, -9.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -399,15 +399,15 @@ public function diagonalAsVector() : void
     public function asArray() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $expected = [
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ];
 
         $this->assertEquals($expected, $matrix->asArray());
@@ -419,8 +419,8 @@ public function asArray() : void
     public function serialization() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
         ]);
 
         $serialized = serialize($matrix);
@@ -432,8 +432,8 @@ public function serialization() : void
         $this->assertInstanceOf(Matrix::class, $restored);
         $this->assertEquals([2, 3], $restored->shape());
         $this->assertEquals([
-            [22, -17, 12],
-            [4, 11, -2],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
         ], $restored->asArray());
         $this->assertSame(serialize($matrix), serialize($restored));
     }
@@ -444,17 +444,17 @@ public function serialization() : void
     public function asVectors() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $vectors = $matrix->asVectors();
 
         $expected = [
-            Vector::fromArray([22, -17, 12]),
-            Vector::fromArray([4, 11, -2]),
-            Vector::fromArray([20, -6, -9]),
+            Vector::fromArray([22.0, -17.0, 12.0]),
+            Vector::fromArray([4.0, 11.0, -2.0]),
+            Vector::fromArray([20.0, -6.0, -9.0]),
         ];
 
         $this->assertEquals($expected, $vectors);
@@ -466,17 +466,17 @@ public function asVectors() : void
     public function asColumnVectors() : void
     {
         $matrix = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $vectors = $matrix->asColumnVectors();
 
         $expected = [
-            ColumnVector::fromArray([22, 4, 20]),
-            ColumnVector::fromArray([-17, 11, -6]),
-            ColumnVector::fromArray([12, -2, -9]),
+            ColumnVector::fromArray([22.0, 4.0, 20.0]),
+            ColumnVector::fromArray([-17.0, 11.0, -6.0]),
+            ColumnVector::fromArray([12.0, -2.0, -9.0]),
         ];
 
         $this->assertEquals($expected, $vectors);
@@ -488,14 +488,14 @@ public function asColumnVectors() : void
     public function flatten() : void
     {
         $a = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $b = $a->flatten();
 
-        $expected = Vector::fromArray([22, -17, 12, 4, 11, -2, 20, -6, -9]);
+        $expected = Vector::fromArray([22.0, -17.0, 12.0, 4.0, 11.0, -2.0, 20.0, -6.0, -9.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -506,17 +506,17 @@ public function flatten() : void
     public function transpose() : void
     {
         $a = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $b = $a->transpose();
 
         $expected = Matrix::fromArray([
-            [22, 4, 20],
-            [-17, 11, -6],
-            [12, -2, -9],
+            [22.0, 4.0, 20.0],
+            [-17.0, 11.0, -6.0],
+            [12.0, -2.0, -9.0],
         ]);
 
         $this->assertEquals($expected, $b);
@@ -528,9 +528,9 @@ public function transpose() : void
     public function inverse() : void
     {
         $a = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $b = $a->inverse();
@@ -585,8 +585,8 @@ public function inverseSingularThrows() : void
     public function pseudoinverse() : void
     {
         $a = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
         ]);
 
         $b = $a->pseudoinverse();
@@ -606,9 +606,9 @@ public function pseudoinverse() : void
     public function det() : void
     {
         $a = Matrix::fromArray([
-            [4, 6, -12],
-            [1, 3, 5],
-            [-10, -1, 14],
+            [4.0, 6.0, -12.0],
+            [1.0, 3.0, 5.0],
+            [-10.0, -1.0, 14.0],
         ]);
 
         $this->assertEqualsWithDelta(-544.0, $a->det(), self::MAX_DELTA);
@@ -637,9 +637,9 @@ public function detSingularIsZero() : void
     public function trace() : void
     {
         $a = Matrix::fromArray([
-            [4, 6, -12],
-            [1, 3, 5],
-            [-10, -1, 14],
+            [4.0, 6.0, -12.0],
+            [1.0, 3.0, 5.0],
+            [-10.0, -1.0, 14.0],
         ]);
 
         $this->assertEquals(21.0, $a->trace());
@@ -664,18 +664,18 @@ public function symmetricProvider() : Generator
     {
         yield [
             Matrix::fromArray([
-                [22, -17, 12],
-                [4, 11, -2],
-                [20, -6, -9],
+                [22.0, -17.0, 12.0],
+                [4.0, 11.0, -2.0],
+                [20.0, -6.0, -9.0],
             ]),
             false,
         ];
 
         yield [
             Matrix::fromArray([
-                [1, 5, 2],
-                [5, 1, 3],
-                [2, 3, 1],
+                [1.0, 5.0, 2.0],
+                [5.0, 1.0, 3.0],
+                [2.0, 3.0, 1.0],
             ]),
             true,
         ];
@@ -837,9 +837,9 @@ public function ref() : void
         $ref = $matrix->ref();
 
         $a = Matrix::fromArray([
-            [22, -17, 12],
-            [0, 14.09090909090909, -4.181818181818182],
-            [0, 0, -17.10322580645161],
+            [22.0, -17.0, 12.0],
+            [0.0, 14.09090909090909, -4.181818181818182],
+            [0.0, 0.0, -17.10322580645161],
         ]);
 
         $expected = new REF($a, 0);
@@ -861,9 +861,9 @@ public function rref() : void
         $rref = $matrix->rref();
 
         $a = Matrix::fromArray([
-            [1, 0, 0],
-            [0, 1, 0],
-            [0, 0, 1],
+            [1.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 0.0, 1.0],
         ]);
 
         $expected = new RREF($a);
@@ -891,15 +891,15 @@ public function lu() : void
         ]);
 
         $u = Matrix::fromArray([
-            [22, -17, 12],
-            [0, 14.09090909090909, -4.181818181818182],
-            [0, 0, -17.10322580645161],
+            [22.0, -17.0, 12.0],
+            [0.0, 14.09090909090909, -4.181818181818182],
+            [0.0, 0.0, -17.10322580645161],
         ]);
 
         $p = Matrix::fromArray([
-            [1, 0, 0],
-            [0, 1, 0],
-            [0, 0, 1],
+            [1.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 0.0, 1.0],
         ]);
 
         $expected = new LU($l, $u, $p);
@@ -970,9 +970,9 @@ public function luSingular() : void
     public function cholesky() : void
     {
         $matrix = Matrix::fromArray([
-            [2, -1, 0],
-            [-1, 2, -1],
-            [0, -1, 2],
+            [2.0, -1.0, 0.0],
+            [-1.0, 2.0, -1.0],
+            [0.0, -1.0, 2.0],
         ]);
 
         $cholesky = $matrix->cholesky();
@@ -1101,15 +1101,15 @@ public function matmul() : void
         ]);
 
         $b = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $c = $a->matmul($b);
 
         $expected = Matrix::fromArray([
-            [207], [155], [113],
+            [207.0], [155.0], [113.0],
         ]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
@@ -1126,11 +1126,11 @@ public function dotVector() : void
             [20.0, -6.0, -9.0],
         ]);
 
-        $b = Vector::fromArray([2, 10, -1]);
+        $b = Vector::fromArray([2.0, 10.0, -1.0]);
 
         $c = $a->dot($b);
 
-        $expected = ColumnVector::fromArray([-138, 120, -11]);
+        $expected = ColumnVector::fromArray([-138.0, 120.0, -11.0]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
     }
@@ -1141,29 +1141,29 @@ public function dotVector() : void
     public function convolve() : void
     {
         $a = Matrix::fromArray([
-            [3, 27, 66, 29, 42, 5],
-            [5, 9, 15, 42, 45, 16],
-            [1, 5, 10, 22, 66, 5],
-            [0, 1, 4, 9, 10, 22],
-            [0, 0, 3, 19, 21, 25],
-            [0, 0, 0, 5, 2, 33],
+            [3.0, 27.0, 66.0, 29.0, 42.0, 5.0],
+            [5.0, 9.0, 15.0, 42.0, 45.0, 16.0],
+            [1.0, 5.0, 10.0, 22.0, 66.0, 5.0],
+            [0.0, 1.0, 4.0, 9.0, 10.0, 22.0],
+            [0.0, 0.0, 3.0, 19.0, 21.0, 25.0],
+            [0.0, 0.0, 0.0, 5.0, 2.0, 33.0],
         ]);
 
         $b = Matrix::fromArray([
-            [0, 0, 1],
-            [0, 1, 0],
-            [1, 0, 0],
+            [0.0, 0.0, 1.0],
+            [0.0, 1.0, 0.0],
+            [1.0, 0.0, 0.0],
         ]);
 
         $c = $a->convolve($b, 1);
 
         $expected = Matrix::fromArray([
-            [3, 32, 75, 44, 84, 50],
-            [32, 76, 49, 94, 72, 82],
-            [10, 20, 53, 71, 91, 15],
-            [5, 11, 26, 78, 34, 43],
-            [1, 4, 12, 29, 48, 27],
-            [0, 3, 19, 26, 27, 33],
+            [3.0, 32.0, 75.0, 44.0, 84.0, 50.0],
+            [32.0, 76.0, 49.0, 94.0, 72.0, 82.0],
+            [10.0, 20.0, 53.0, 71.0, 91.0, 15.0],
+            [5.0, 11.0, 26.0, 78.0, 34.0, 43.0],
+            [1.0, 4.0, 12.0, 29.0, 48.0, 27.0],
+            [0.0, 3.0, 19.0, 26.0, 27.0, 33.0],
         ]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
@@ -1178,23 +1178,23 @@ public function convolve() : void
     public function convolveStrideTwo() : void
     {
         $a = Matrix::fromArray([
-            [1, 2, 3, 4, 5, 6, 7, 8],
-            [9, 10, 11, 12, 13, 14, 15, 16],
-            [17, 18, 19, 20, 21, 22, 23, 24],
-            [25, 26, 27, 28, 29, 30, 31, 32],
-            [33, 34, 35, 36, 37, 38, 39, 40],
+            [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
+            [9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0],
+            [17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0],
+            [25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0],
+            [33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0],
         ]);
 
         $b = Matrix::fromArray([
-            [1],
+            [1.0],
         ]);
 
         $c = $a->convolve($b, 2);
 
         $expected = Matrix::fromArray([
-            [1, 3, 5, 7],
-            [17, 19, 21, 23],
-            [33, 35, 37, 39],
+            [1.0, 3.0, 5.0, 7.0],
+            [17.0, 19.0, 21.0, 23.0],
+            [33.0, 35.0, 37.0, 39.0],
         ]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
@@ -1206,22 +1206,22 @@ public function convolveStrideTwo() : void
     public function convolveStrideThree() : void
     {
         $a = Matrix::fromArray([
-            [1, 2, 3, 4, 5, 6, 7, 8],
-            [9, 10, 11, 12, 13, 14, 15, 16],
-            [17, 18, 19, 20, 21, 22, 23, 24],
-            [25, 26, 27, 28, 29, 30, 31, 32],
-            [33, 34, 35, 36, 37, 38, 39, 40],
+            [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
+            [9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0],
+            [17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0],
+            [25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0],
+            [33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0],
         ]);
 
         $b = Matrix::fromArray([
-            [1],
+            [1.0],
         ]);
 
         $c = $a->convolve($b, 3);
 
         $expected = Matrix::fromArray([
-            [1, 4, 7],
-            [25, 28, 31],
+            [1.0, 4.0, 7.0],
+            [25.0, 28.0, 31.0],
         ]);
 
         $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
@@ -1254,14 +1254,14 @@ public function multiplyProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [88, -102, -144],
-                [4, 33, -10],
-                [-200, 6, -126],
+                [88.0, -102.0, -144.0],
+                [4.0, 33.0, -10.0],
+                [-200.0, 6.0, -126.0],
             ]),
         ];
 
@@ -1271,11 +1271,11 @@ public function multiplyProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [44, -170, -12],
-                [8, 110, 2],
-                [40, -60, 9],
+                [44.0, -170.0, -12.0],
+                [8.0, 110.0, 2.0],
+                [40.0, -60.0, 9.0],
             ]),
         ];
 
@@ -1285,11 +1285,11 @@ public function multiplyProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
-                [55.0, -42.5, 30.],
-                [-4, -11, 2],
-                [96.0, -28.799999999999997, -43.199999999999996],
+                [55.0, -42.5, 30.0],
+                [-4.0, -11.0, 2.0],
+                [96.0, -28.8, -43.2],
             ]),
         ];
 
@@ -1301,9 +1301,9 @@ public function multiplyProvider() : Generator
             ]),
             2.5,
             Matrix::fromArray([
-                [55, -42.5, 30],
-                [10.0, 27.5, -5.],
-                [50, -15, -22.5],
+                [55.0, -42.5, 30.0],
+                [10.0, 27.5, -5.0],
+                [50.0, -15.0, -22.5],
             ]),
         ];
     }
@@ -1335,14 +1335,14 @@ public function divideProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [5.5, -2.8333333333333335, -1],
-                [4, 3.6666666666666665, -0.4],
-                [-2, 6, -0.6428571428571429],
+                [5.5, -2.8333333333333335, -1.0],
+                [4.0, 3.6666666666666665, -0.4],
+                [-2.0, 6.0, -0.6428571428571429],
             ]),
         ];
 
@@ -1352,11 +1352,11 @@ public function divideProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [11, -1.7, -12],
-                [2, 1.1, 2],
-                [10, -0.6, 9],
+                [11.0, -1.7, -12.0],
+                [2.0, 1.1, 2.0],
+                [10.0, -0.6, 9.0],
             ]),
         ];
 
@@ -1366,10 +1366,10 @@ public function divideProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
                 [8.8, -6.8, 4.8],
-                [-4, -11, 2],
+                [-4.0, -11.0, 2.0],
                 [4.166666666666667, -1.25, -1.875],
             ]),
         ];
@@ -1382,8 +1382,8 @@ public function divideProvider() : Generator
             ]),
             2.0,
             Matrix::fromArray([
-                [11.0, -8.5, 6.],
-                [2.0, 5.5, -1.],
+                [11.0, -8.5, 6.0],
+                [2.0, 5.5, -1.0],
                 [10.0, -3.0, -4.5],
             ]),
         ];
@@ -1416,14 +1416,14 @@ public function addProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [26, -11, 0],
-                [5, 14, 3],
-                [10, -7, 5],
+                [26.0, -11.0, 0.0],
+                [5.0, 14.0, 3.0],
+                [10.0, -7.0, 5.0],
             ]),
         ];
 
@@ -1433,11 +1433,11 @@ public function addProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [24, -7, 11],
-                [6, 21, -3],
-                [22, 4, -10],
+                [24.0, -7.0, 11.0],
+                [6.0, 21.0, -3.0],
+                [22.0, 4.0, -10.0],
             ]),
         ];
 
@@ -1447,10 +1447,10 @@ public function addProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
                 [24.5, -14.5, 14.5],
-                [3, 10, -3],
+                [3.0, 10.0, -3.0],
                 [24.8, -1.2000000000000002, -4.2],
             ]),
         ];
@@ -1463,9 +1463,9 @@ public function addProvider() : Generator
             ]),
             1.0,
             Matrix::fromArray([
-                [23, -16, 13],
-                [5, 12, -1],
-                [21, -5, -8],
+                [23.0, -16.0, 13.0],
+                [5.0, 12.0, -1.0],
+                [21.0, -5.0, -8.0],
             ]),
         ];
     }
@@ -1497,14 +1497,14 @@ public function subtractProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [18, -23, 24],
-                [3, 8, -7],
-                [30, -5, -23],
+                [18.0, -23.0, 24.0],
+                [3.0, 8.0, -7.0],
+                [30.0, -5.0, -23.0],
             ]),
         ];
 
@@ -1514,11 +1514,11 @@ public function subtractProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [20, -27, 13],
-                [2, 1, -1],
-                [18, -16, -8],
+                [20.0, -27.0, 13.0],
+                [2.0, 1.0, -1.0],
+                [18.0, -16.0, -8.0],
             ]),
         ];
 
@@ -1528,10 +1528,10 @@ public function subtractProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
                 [19.5, -19.5, 9.5],
-                [5, 12, -1],
+                [5.0, 12.0, -1.0],
                 [15.2, -10.8, -13.8],
             ]),
         ];
@@ -1544,9 +1544,9 @@ public function subtractProvider() : Generator
             ]),
             10.0,
             Matrix::fromArray([
-                [12, -27, 2],
-                [-6, 1, -12],
-                [10, -16, -19],
+                [12.0, -27.0, 2.0],
+                [-6.0, 1.0, -12.0],
+                [10.0, -16.0, -19.0],
             ]),
         ];
     }
@@ -1578,14 +1578,14 @@ public function powProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [234256, 24137569, 1.1215665478461509E-13],
-                [4, 1331, -32],
-                [9.765625E-14, -0.16666666666666666, 22876792454961],
+                [234256.0, 24137569.0, 1.1215665478461509E-13],
+                [4.0, 1331.0, -32.0],
+                [9.765625E-14, -0.16666666666666666, 22876792454961.0],
             ]),
         ];
 
@@ -1595,11 +1595,11 @@ public function powProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [484, 2015993900449, 0.08333333333333333],
-                [16, 25937424601, -0.5],
-                [400, 60466176, -0.1111111111111111],
+                [484.0, 2015993900449.0, 0.08333333333333333],
+                [16.0, 25937424601.0, -0.5],
+                [400.0, 60466176.0, -0.1111111111111111],
             ]),
         ];
 
@@ -1611,9 +1611,9 @@ public function powProvider() : Generator
             ]),
             3.0,
             Matrix::fromArray([
-                [10648, -4913, 1728],
-                [64, 1331, -8],
-                [8000, -216, -729],
+                [10648.0, -4913.0, 1728.0],
+                [64.0, 1331.0, -8.0],
+                [8000.0, -216.0, -729.0],
             ]),
         ];
     }
@@ -1645,14 +1645,14 @@ public function modProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [2, -5, 0],
-                [0, 2, -2],
-                [0, 0, -9],
+                [2.0, -5.0, 0.0],
+                [0.0, 2.0, -2.0],
+                [0.0, 0.0, -9.0],
             ]),
         ];
 
@@ -1662,11 +1662,11 @@ public function modProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [0, -7, 0],
-                [0, 1, 0],
-                [0, -6, 0],
+                [0.0, -7.0, 0.0],
+                [0.0, 1.0, 0.0],
+                [0.0, -6.0, 0.0],
             ]),
         ];
 
@@ -1676,11 +1676,11 @@ public function modProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
-                [0,  -1,  0],
-                [0, 0, 0],
-                [0,  -2,  -1]
+                [0.0,  -1.0,  0.0],
+                [0.0, 0.0, 0.0],
+                [0.0,  -2.0,  -1.0]
             ]),
         ];
 
@@ -1692,9 +1692,9 @@ public function modProvider() : Generator
             ]),
             10.0,
             Matrix::fromArray([
-                [2, -7, 2],
-                [4, 1, -2],
-                [0, -6, -9],
+                [2.0, -7.0, 2.0],
+                [4.0, 1.0, -2.0],
+                [0.0, -6.0, -9.0],
             ]),
         ];
     }
@@ -1726,14 +1726,14 @@ public function equalProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [0, 0, 0],
-                [0, 0, 0],
-                [0, 0, 0],
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0],
             ]),
         ];
 
@@ -1743,11 +1743,11 @@ public function equalProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [0, 0, 0],
-                [0, 0, 0],
-                [0, 0, 0],
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0],
             ]),
         ];
 
@@ -1757,11 +1757,11 @@ public function equalProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
-                [0, 0, 0],
-                [0, 0, 0],
-                [0, 0, 0],
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0],
             ]),
         ];
 
@@ -1773,9 +1773,9 @@ public function equalProvider() : Generator
             ]),
             4.0,
             Matrix::fromArray([
-                [0, 0, 0],
-                [1, 0, 0],
-                [0, 0, 0],
+                [0.0, 0.0, 0.0],
+                [1.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0],
             ]),
         ];
     }
@@ -1807,14 +1807,14 @@ public function notEqualProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [1, 1, 1],
-                [1, 1, 1],
-                [1, 1, 1],
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
             ]),
         ];
 
@@ -1824,11 +1824,11 @@ public function notEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [1, 1, 1],
-                [1, 1, 1],
-                [1, 1, 1],
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
             ]),
         ];
 
@@ -1838,11 +1838,11 @@ public function notEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
-                [1, 1, 1],
-                [1, 1, 1],
-                [1, 1, 1],
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
             ]),
         ];
 
@@ -1854,9 +1854,9 @@ public function notEqualProvider() : Generator
             ]),
             4.0,
             Matrix::fromArray([
-                [1, 1, 1],
-                [0, 1, 1],
-                [1, 1, 1],
+                [1.0, 1.0, 1.0],
+                [0.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
             ]),
         ];
     }
@@ -1888,14 +1888,14 @@ public function greaterProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [1, 0, 1],
-                [1, 1, 0],
-                [1, 0, 0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 0.0, 0.0],
             ]),
         ];
 
@@ -1905,11 +1905,11 @@ public function greaterProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [1, 0, 1],
-                [1, 1, 0],
-                [1, 0, 0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 0.0, 0.0],
             ]),
         ];
 
@@ -1919,11 +1919,11 @@ public function greaterProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
-                [1, 0, 1],
-                [1, 1, 0],
-                [1, 0, 0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 0.0, 0.0],
             ]),
         ];
 
@@ -1935,9 +1935,9 @@ public function greaterProvider() : Generator
             ]),
             4.0,
             Matrix::fromArray([
-                [1, 0, 1],
-                [0, 1, 0],
-                [1, 0, 0],
+                [1.0, 0.0, 1.0],
+                [0.0, 1.0, 0.0],
+                [1.0, 0.0, 0.0],
             ]),
         ];
     }
@@ -1969,14 +1969,14 @@ public function greaterEqualProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [1, 0, 1],
-                [1, 1, 0],
-                [1, 0, 0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 0.0, 0.0],
             ]),
         ];
 
@@ -1986,11 +1986,11 @@ public function greaterEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [1, 0, 1],
-                [1, 1, 0],
-                [1, 0, 0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 0.0, 0.0],
             ]),
         ];
 
@@ -2000,11 +2000,11 @@ public function greaterEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
-                [1, 0, 1],
-                [1, 1, 0],
-                [1, 0, 0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 0.0, 0.0],
             ]),
         ];
 
@@ -2016,9 +2016,9 @@ public function greaterEqualProvider() : Generator
             ]),
             4.0,
             Matrix::fromArray([
-                [1, 0, 1],
-                [1, 1, 0],
-                [1, 0, 0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 0.0, 0.0],
             ]),
         ];
     }
@@ -2050,14 +2050,14 @@ public function lessProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
-                [0, 1, 0],
-                [0, 0, 1],
-                [0, 1, 1],
+                [0.0, 1.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 1.0],
             ]),
         ];
 
@@ -2067,11 +2067,11 @@ public function lessProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
-                [0, 1, 0],
-                [0, 0, 1],
-                [0, 1, 1],
+                [0.0, 1.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 1.0],
             ]),
         ];
 
@@ -2083,9 +2083,9 @@ public function lessProvider() : Generator
             ]),
             ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
-                [0, 1, 0],
-                [0, 0, 1],
-                [0, 1, 1],
+                [0.0, 1.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 1.0],
             ]),
         ];
 
@@ -2097,9 +2097,9 @@ public function lessProvider() : Generator
             ]),
             10.0,
             Matrix::fromArray([
-                [0, 1, 0],
-                [1, 0, 1],
-                [0, 1, 1],
+                [0.0, 1.0, 0.0],
+                [1.0, 0.0, 1.0],
+                [0.0, 1.0, 1.0],
             ]),
         ];
     }
@@ -2136,9 +2136,9 @@ public function lessEqualProvider() : Generator
                 [-10, -1, 14],
             ]),
             Matrix::fromArray([
-                [0, 1, 0],
-                [0, 0, 1],
-                [0, 1, 1],
+                [0.0, 1.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 1.0],
             ]),
         ];
 
@@ -2150,9 +2150,9 @@ public function lessEqualProvider() : Generator
             ]),
             Vector::fromArray([2, 10, -1]),
             Matrix::fromArray([
-                [0, 1, 0],
-                [0, 0, 1],
-                [0, 1, 1],
+                [0.0, 1.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 1.0],
             ]),
         ];
 
@@ -2164,9 +2164,9 @@ public function lessEqualProvider() : Generator
             ]),
             ColumnVector::fromArray([2.5, -1, 4.8]),
             Matrix::fromArray([
-                [0, 1, 0],
-                [0, 0, 1],
-                [0, 1, 1],
+                [0.0, 1.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 1.0],
             ]),
         ];
 
@@ -2178,9 +2178,9 @@ public function lessEqualProvider() : Generator
             ]),
             10.0,
             Matrix::fromArray([
-                [0, 1, 0],
-                [1, 0, 1],
-                [0, 1, 1],
+                [0.0, 1.0, 0.0],
+                [1.0, 0.0, 1.0],
+                [0.0, 1.0, 1.0],
             ]),
         ];
     }
@@ -2199,9 +2199,9 @@ public function abs() : void
         $b = $a->abs();
 
         $expected = Matrix::fromArray([
-            [22, 17, 12],
-            [4, 11, 2],
-            [20, 6, 9],
+            [22.0, 17.0, 12.0],
+            [4.0, 11.0, 2.0],
+            [20.0, 6.0, 9.0],
         ]);
 
         $this->assertEquals($expected, $b);
@@ -2221,9 +2221,9 @@ public function square() : void
         $b = $a->square();
 
         $expected = Matrix::fromArray([
-            [484, 289, 144],
-            [16, 121, 4],
-            [400, 36, 81],
+            [484.0, 289.0, 144.0],
+            [16.0, 121.0, 4.0],
+            [400.0, 36.0, 81.0],
         ]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
@@ -2235,9 +2235,9 @@ public function square() : void
     public function sqrt() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->sqrt();
@@ -2245,7 +2245,7 @@ public function sqrt() : void
         $expected = Matrix::fromArray([
             [3.605551275463989],
             [3.3166247903554],
-            [3],
+            [3.0],
         ]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
@@ -2257,9 +2257,9 @@ public function sqrt() : void
     public function exp() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->exp();
@@ -2279,9 +2279,9 @@ public function exp() : void
     public function expm1() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->expm1();
@@ -2301,9 +2301,9 @@ public function expm1() : void
     public function log() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->log();
@@ -2323,9 +2323,9 @@ public function log() : void
     public function log1p() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->log1p();
@@ -2345,9 +2345,9 @@ public function log1p() : void
     public function sin() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->sin();
@@ -2389,9 +2389,9 @@ public function asin() : void
     public function cos() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->cos();
@@ -2433,9 +2433,9 @@ public function acos() : void
     public function tan() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->tan();
@@ -2455,9 +2455,9 @@ public function tan() : void
     public function atan() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->atan();
@@ -2477,9 +2477,9 @@ public function atan() : void
     public function rad2deg() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->rad2deg();
@@ -2499,9 +2499,9 @@ public function rad2deg() : void
     public function deg2rad() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->deg2rad();
@@ -2528,7 +2528,7 @@ public function sum() : void
 
         $b = $a->sum();
 
-        $expected = ColumnVector::fromArray([17, 13, 5]);
+        $expected = ColumnVector::fromArray([17.0, 13.0, 5.0]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -2564,7 +2564,7 @@ public function min() : void
 
         $b = $a->min();
 
-        $expected = ColumnVector::fromArray([-17, -2, -9]);
+        $expected = ColumnVector::fromArray([-17.0, -2.0, -9.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -2582,7 +2582,7 @@ public function max() : void
 
         $b = $a->max();
 
-        $expected = ColumnVector::fromArray([22, 11, 20]);
+        $expected = ColumnVector::fromArray([22.0, 11.0, 20.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -2618,7 +2618,7 @@ public function median() : void
 
         $b = $a->median();
 
-        $expected = ColumnVector::fromArray([12, 4, -6]);
+        $expected = ColumnVector::fromArray([12.0, 4.0, -6.0]);
 
         $this->assertEquals($expected, $b);
     }
diff --git a/tests/TensorBufferTest.php b/tests/TensorBufferTest.php
index f221661..987c5ea 100644
--- a/tests/TensorBufferTest.php
+++ b/tests/TensorBufferTest.php
@@ -489,6 +489,42 @@ public function sliceStridedInvalidStride() : void
         $decorator->sliceStrided(0, 2, 0);
     }
 
+    /**
+     * @test
+     */
+    public function sliceStridedRejectsOverflowingRange() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->sliceStrided(0, 4097, 4503599627370496);
+    }
+
+    /**
+     * @test
+     */
+    public function sliceStridedRejectsHugeStride() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->sliceStrided(0, 10, 4611686018427387904);
+    }
+
+    /**
+     * @test
+     */
+    public function sliceStridedSingleElementHugeStride() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]));
+
+        $slice = $decorator->sliceStrided(4, 1, PHP_INT_MAX);
+
+        $this->assertSame([5.0], $slice->toArray());
+    }
+
     /**
      * @test
      */
@@ -630,4 +666,29 @@ public function repeatInvalidTimes() : void
 
         $decorator->repeat(0);
     }
+
+    /**
+     * @test
+     */
+    public function repeatRejectsOverflowingTimes() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0]));
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $decorator->repeat(PHP_INT_MAX);
+    }
+
+    /**
+     * @test
+     */
+    public function splitChunkLargerThanBuffer() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
+
+        $chunks = $decorator->split(PHP_INT_MAX);
+
+        $this->assertCount(1, $chunks);
+        $this->assertEqualsWithDelta([1.0, 2.0, 3.0], $chunks[0]->toArray(), self::MAX_DELTA);
+    }
 }
diff --git a/tests/TensorComparator.php b/tests/TensorComparator.php
new file mode 100644
index 0000000..f392da5
--- /dev/null
+++ b/tests/TensorComparator.php
@@ -0,0 +1,132 @@
+<?php
+
+namespace Tensor\Tests;
+
+use Tensor\Matrix;
+use Tensor\Vector;
+use Tensor\ColumnVector;
+use Tensor\Reductions\Ref;
+use Tensor\Reductions\Rref;
+use Tensor\Decompositions\Lu;
+use Tensor\Decompositions\Eigen;
+use Tensor\Decompositions\Svd;
+use Tensor\Decompositions\Cholesky;
+use SebastianBergmann\Comparator\Comparator;
+use SebastianBergmann\Comparator\ComparisonFailure;
+
+/**
+ * @internal
+ *
+ * Compares two tensor objects for equality by their numerical content.
+ *
+ * Tensors store their elements in an opaque internal buffer that has no
+ * reflection-visible properties, so PHPUnit's default object comparator treats
+ * any two same-shape tensors as equal regardless of their contents. This
+ * comparator reduces each operand to its plain array of values before
+ * delegating back to the comparator factory, so the delta, canonicalize and
+ * ignoreCase flags keep their usual meaning.
+ */
+class TensorComparator extends Comparator
+{
+    /**
+     * The tensor classes whose content lives in an opaque internal buffer.
+     *
+     * @var list<class-string>
+     */
+    private const TENSOR_CLASSES = [
+        Matrix::class,
+        Vector::class,
+        ColumnVector::class,
+        Ref::class,
+        Rref::class,
+        Lu::class,
+        Eigen::class,
+        Svd::class,
+        Cholesky::class,
+    ];
+
+    /**
+     * @param mixed $expected
+     * @param mixed $actual
+     */
+    public function accepts($expected, $actual) : bool
+    {
+        return is_object($expected)
+            && is_object($actual)
+            && get_class($expected) === get_class($actual)
+            && in_array(get_class($expected), self::TENSOR_CLASSES, true);
+    }
+
+    /**
+     * @param mixed $expected
+     * @param mixed $actual
+     * @param float $delta
+     * @param bool $canonicalize
+     * @param bool $ignoreCase
+     */
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) : void
+    {
+        $expectedValues = $this->toArray($expected);
+        $actualValues = $this->toArray($actual);
+
+        try {
+            $this->factory->getComparatorFor($expectedValues, $actualValues)
+                ->assertEquals($expectedValues, $actualValues, $delta, $canonicalize, $ignoreCase);
+        } catch (ComparisonFailure $failure) {
+            throw new ComparisonFailure(
+                $expected,
+                $actual,
+                substr_replace($failure->getExpectedAsString(), get_class($expected) . ' Object', 0, 5),
+                substr_replace($failure->getActualAsString(), get_class($actual) . ' Object', 0, 5),
+                false,
+                'Failed asserting that two objects are equal.'
+            );
+        }
+    }
+
+    /**
+     * Reduce a tensor object to the plain values that it stores.
+     *
+     * Nested tensors are left in place so that the factory resolves them back
+     * to this comparator and applies the delta to their elements.
+     *
+     * @param object $object
+     * @return array<mixed>
+     */
+    private function toArray($object) : array
+    {
+        if ($object instanceof Matrix) {
+            return $object->asArray();
+        }
+
+        if ($object instanceof Vector) {
+            return $object->asArray();
+        }
+
+        if ($object instanceof Ref) {
+            return [$object->a(), $object->swaps()];
+        }
+
+        if ($object instanceof Rref) {
+            return [$object->a()];
+        }
+
+        if ($object instanceof Lu) {
+            return [$object->l(), $object->u(), $object->p()];
+        }
+
+        if ($object instanceof Eigen) {
+            return [$object->eigenvalues(), $object->eigenvectors()];
+        }
+
+        if ($object instanceof Svd) {
+            return [$object->u(), $object->singularValues(), $object->vT()];
+        }
+
+        if ($object instanceof Cholesky) {
+            return [$object->l()];
+        }
+
+        throw new \RuntimeException('Unsupported tensor class ' . get_class($object) . '.');
+    }
+}
diff --git a/tests/TensorComparatorTest.php b/tests/TensorComparatorTest.php
new file mode 100644
index 0000000..a30481d
--- /dev/null
+++ b/tests/TensorComparatorTest.php
@@ -0,0 +1,158 @@
+<?php
+
+namespace Tensor\Tests;
+
+use Tensor\Matrix;
+use Tensor\Vector;
+use Tensor\ColumnVector;
+use Tensor\Decompositions\Lu;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\ExpectationFailedException;
+
+/**
+ * @covers \Tensor\Tests\TensorComparator
+ */
+class TensorComparatorTest extends TestCase
+{
+    /**
+     * The maximum error tolerated due to varying numerical precision.
+     *
+     * @var float
+     */
+    protected const MAX_DELTA = 1e-8;
+
+    /**
+     * @test
+     */
+    public function comparesMatricesByValue() : void
+    {
+        $a = Matrix::fromArray([
+            [1, 2],
+            [3, 4],
+        ]);
+
+        $equal = Matrix::fromArray([
+            [1, 2],
+            [3, 4],
+        ]);
+
+        $different = Matrix::fromArray([
+            [999, 888],
+            [777, 666],
+        ]);
+
+        $this->assertEquals($a, $equal);
+        $this->assertNotEquals($a, $different);
+    }
+
+    /**
+     * @test
+     */
+    public function comparesMatricesByShape() : void
+    {
+        $a = Matrix::fromArray([
+            [1, 2],
+            [3, 4],
+        ]);
+
+        $transposed = Matrix::fromArray([
+            [1, 3],
+            [2, 4],
+        ]);
+
+        $this->assertNotEquals($a, $transposed);
+    }
+
+    /**
+     * @test
+     */
+    public function comparesMatricesWithinDelta() : void
+    {
+        $a = Matrix::fromArray([
+            [1, 2],
+            [3, 4],
+        ]);
+
+        $b = Matrix::fromArray([
+            [1.0000000001, 2],
+            [3, 4],
+        ]);
+
+        $this->assertEqualsWithDelta($a, $b, self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function matricesOutsideOfDeltaAreUnequal() : void
+    {
+        $this->expectException(ExpectationFailedException::class);
+
+        $a = Matrix::fromArray([
+            [1, 2],
+            [3, 4],
+        ]);
+
+        $b = Matrix::fromArray([
+            [1.0001, 2],
+            [3, 4],
+        ]);
+
+        $this->assertEqualsWithDelta($a, $b, self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function comparesVectorsByValue() : void
+    {
+        $a = Vector::fromArray([1, 2]);
+        $equal = Vector::fromArray([1, 2]);
+        $different = Vector::fromArray([9, 9]);
+
+        $this->assertEquals($a, $equal);
+        $this->assertNotEquals($a, $different);
+    }
+
+    /**
+     * @test
+     */
+    public function comparesColumnVectorsByValue() : void
+    {
+        $a = ColumnVector::fromArray([1, 2]);
+        $different = ColumnVector::fromArray([9, 9]);
+
+        $this->assertNotEquals($a, $different);
+    }
+
+    /**
+     * @test
+     */
+    public function distinguishesVectorFromColumnVector() : void
+    {
+        $vector = Vector::fromArray([1, 2]);
+        $column = ColumnVector::fromArray([1, 2]);
+
+        $this->assertNotEquals($vector, $column);
+    }
+
+    /**
+     * @test
+     */
+    public function comparesDecompositionsByValue() : void
+    {
+        $a = new Lu(
+            Matrix::fromArray([[1, 0], [0, 1]]),
+            Matrix::fromArray([[2, 0], [0, 2]]),
+            Matrix::fromArray([[1, 0], [0, 1]])
+        );
+
+        $b = new Lu(
+            Matrix::fromArray([[1, 0], [0, 1]]),
+            Matrix::fromArray([[999, 0], [0, 2]]),
+            Matrix::fromArray([[1, 0], [0, 1]])
+        );
+
+        $this->assertNotEquals($a, $b);
+    }
+}
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index b241821..9d41ea0 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -1215,7 +1215,7 @@ public function modProvider() : Generator
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             4,
-            Vector::fromArray([-3, 1, 3, 0, 0, 1, 2, 1]),
+            Vector::fromArray([-3.0, 1.0, 3.0, 0.0, 0.0, 1.0, 2.0, 1.0]),
         ];
     }
 
@@ -1228,7 +1228,7 @@ public function abs() : void
 
         $b = $a->abs();
 
-        $expected = Vector::fromArray([15, 25, 35, 36, 72, 89, 106, 45]);
+        $expected = Vector::fromArray([15.0, 25.0, 35.0, 36.0, 72.0, 89.0, 106.0, 45.0]);
 
         $this->assertEquals($expected, $b);
     }
@@ -1242,7 +1242,7 @@ public function square() : void
 
         $b = $a->square();
 
-        $expected = Vector::fromArray([225, 625, 1225, 1296, 5184, 7921, 11236, 2025]);
+        $expected = Vector::fromArray([225.0, 625.0, 1225.0, 1296.0, 5184.0, 7921.0, 11236.0, 2025.0]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
@@ -1256,7 +1256,7 @@ public function pow() : void
 
         $b = $a->pow(3);
 
-        $expected = Vector::fromArray([-3375, 15625, 42875, -46656, -373248, 704969, 1191016, 91125]);
+        $expected = Vector::fromArray([-3375.0, 15625.0, 42875.0, -46656.0, -373248.0, 704969.0, 1191016.0, 91125.0]);
 
         $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
     }
diff --git a/tests/bootstrap.php b/tests/bootstrap.php
new file mode 100644
index 0000000..23e0a63
--- /dev/null
+++ b/tests/bootstrap.php
@@ -0,0 +1,10 @@
+<?php
+
+use SebastianBergmann\Comparator\Factory;
+use Tensor\Tests\TensorComparator;
+
+require __DIR__ . '/../vendor/autoload.php';
+
+Factory::getInstance()->register(
+    new TensorComparator()
+);

From 20b0149c5d8ddcf393ae753946643f97f180f831 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 17:32:16 -0500
Subject: [PATCH 27/51] Fix mod tests

---
 AGENTS.md            | 5 +----
 tests/MatrixTest.php | 6 +++---
 tests/VectorTest.php | 8 ++++----
 3 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index b444bd9..7615e54 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -18,7 +18,7 @@ Guidance for AI coding agents contributing to **Tensor** — a scientific-comput
 ## Environment
 
 - PHP **8.1+** (CI matrix is 8.1 → 8.5). `composer.json` declares `>=8.1`.
-- Dev tooling is installed as Composer dev dependencies (PHPStan, php-cs-fixer, phpunit, phpbench, Zephir).
+- Dev tooling is installed as Composer dev dependencies (php-cs-fixer, phpunit, phpbench, Zephir).
 - Compiling the extension additionally needs a C compiler, GFortran, `phpize`, OpenBLAS dev headers, LAPACKE, and re2c (see README for per-OS install commands).
 
 ## Commands
@@ -29,7 +29,6 @@ All are Composer scripts (see `composer.json`):
 | --- | --- |
 | Install deps | `composer install` |
 | Validate manifest | `composer validate` |
-| Static analysis | `composer analyze` (PHPStan level 8 over `tests`, `benchmarks`) |
 | Run tests | `composer test` (PHPUnit, test suite `Base`; requires the extension to be loaded) |
 | Check style | `composer check` (php-cs-fixer, dry-run; sets `PHP_CS_FIXER_IGNORE_ENV=1`) |
 | Fix style | `composer fix` |
@@ -42,7 +41,6 @@ All are Composer scripts (see `composer.json`):
 
 ```sh
 composer install
-composer analyze
 composer test
 composer fix
 ```
@@ -52,7 +50,6 @@ composer fix
 ## Conventions to follow
 
 - **Coding style** is governed by `.php-cs-fixer.dist.php` (extends `@PSR2`). Highlights: single quotes, short array syntax, compact nullable type hints, pre-increment, ordered class elements, trimmed/multi-line phpdoc, `echo` over `print`. Rather than memorize the rule set, run `composer fix`.
-- **Static analysis is required.** New code must pass PHPStan level 8 (`composer analyze`). Keep types accurate; the codebase uses docblock generics like `list<float>` and `int<0,max>`.
 - **Testing guidance** (from `CONTRIBUTING.md`):
   - New functionality ships with a matching unit test in `tests/`.
   - Bug fixes ship with a passing test that would have reproduced the bug beforehand.
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index be46ac0..5984800 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -1676,11 +1676,11 @@ public function modProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1.0, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.0]),
             Matrix::fromArray([
-                [0.0,  -1.0,  0.0],
+                [2.0, -2.0, 2.0],
                 [0.0, 0.0, 0.0],
-                [0.0,  -2.0,  -1.0]
+                [0.0, -2.0, -1.0],
             ]),
         ];
 
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index 9d41ea0..67a41b7 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -1207,14 +1207,14 @@ public function mod(Vector $a, $b, $expected) : void
     public function modProvider() : Generator
     {
         yield [
-            Vector::fromArray([0.25, 0.1, 2.0, -0.5, -1.0, -3.0, 3.3, 2.0]),
-            Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            Vector::fromArray([0, 0, 2, 0, -1, -3, 3, 2]),
+            Vector::fromArray([3.5, -7.0, 12.75, 0.375, -1.5]),
+            Vector::fromArray([2.0, 3.0, 4.5, 0.5, 2.0]),
+            Vector::fromArray([1.5, -1.0, 3.75, 0.375, -1.5]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
-            4,
+            4.0,
             Vector::fromArray([-3.0, 1.0, 3.0, 0.0, 0.0, 1.0, 2.0, 1.0]),
         ];
     }

From a0ca87cb449b174959033ef834080fc691d99de3 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 17:46:10 -0500
Subject: [PATCH 28/51] A little nicer

---
 tests/ColumnVectorTest.php            |  28 ++--
 tests/Decompositions/CholeskyTest.php |  16 +--
 tests/Decompositions/EigenTest.php    |   4 +-
 tests/Decompositions/LUTest.php       |  22 +--
 tests/Decompositions/SVDTest.php      |  42 +++---
 tests/MatrixTest.php                  | 185 ++++++++++++++------------
 tests/Reductions/REFTest.php          |  18 +--
 tests/Reductions/RREFTest.php         |  14 +-
 tests/TensorComparator.php            | 132 ------------------
 tests/TensorComparatorTest.php        | 158 ----------------------
 tests/VectorTest.php                  | 100 +++++++-------
 tests/bootstrap.php                   |   7 -
 12 files changed, 224 insertions(+), 502 deletions(-)
 delete mode 100644 tests/TensorComparator.php
 delete mode 100644 tests/TensorComparatorTest.php

diff --git a/tests/ColumnVectorTest.php b/tests/ColumnVectorTest.php
index c397ae0..e7fb000 100644
--- a/tests/ColumnVectorTest.php
+++ b/tests/ColumnVectorTest.php
@@ -135,7 +135,7 @@ public function multiply() : void
             [38.5, 175, -175],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -159,7 +159,7 @@ public function divide() : void
             [31.818181818181817, 7, -7],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -183,7 +183,7 @@ public function add() : void
             [36.1, 40, 30],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -207,7 +207,7 @@ public function subtract() : void
             [33.9, 30, 40],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -231,7 +231,7 @@ public function equal() : void
             [0, 0, 0],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -255,7 +255,7 @@ public function notEqual() : void
             [1, 1, 1],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -279,7 +279,7 @@ public function greater() : void
             [1, 1, 1],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -303,7 +303,7 @@ public function greaterEqual() : void
             [1, 1, 1],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -327,7 +327,7 @@ public function less() : void
             [0, 0, 0],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -351,7 +351,7 @@ public function lessEqual() : void
             [0, 0, 0],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -364,7 +364,7 @@ public function transposeReturnsVector() : void
         $b = $a->transpose();
 
         $this->assertInstanceOf(Vector::class, $b);
-        $this->assertEquals(Vector::fromArray([1.0, 2.0, 3.0]), $b);
+        $this->assertEquals(Vector::fromArray([1.0, 2.0, 3.0])->asArray(), $b->asArray());
     }
 
     /**
@@ -398,7 +398,7 @@ public function matmul() : void
             [3.0, 6.0, 9.0],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -436,7 +436,7 @@ public function powMatrix() : void
             [16.0, 1.0, 4.0],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -473,7 +473,7 @@ public function modMatrix() : void
             [0.0, 3.0, 1.0],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
diff --git a/tests/Decompositions/CholeskyTest.php b/tests/Decompositions/CholeskyTest.php
index f6dc9a8..68aa590 100644
--- a/tests/Decompositions/CholeskyTest.php
+++ b/tests/Decompositions/CholeskyTest.php
@@ -39,10 +39,10 @@ public function decompose2x2() : void
 
         $expected = new Cholesky($l);
 
-        $this->assertEqualsWithDelta($expected, $ch, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->l()->asArray(), $ch->l()->asArray(), self::MAX_DELTA);
 
         // Cross-check: L * L^T reconstructs A.
-        $this->assertEqualsWithDelta($a, $ch->l()->matmul($ch->lT()), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $ch->l()->matmul($ch->lT())->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -66,7 +66,7 @@ public function decompose3x3() : void
 
         $expected = new Cholesky($l);
 
-        $this->assertEqualsWithDelta($expected, $ch, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->l()->asArray(), $ch->l()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -82,7 +82,7 @@ public function decompose1x1() : void
 
         $expected = new Cholesky($l);
 
-        $this->assertEqualsWithDelta($expected, $ch, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->l()->asArray(), $ch->l()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -106,7 +106,7 @@ public function decomposeDiagonal() : void
 
         $expected = new Cholesky($l);
 
-        $this->assertEqualsWithDelta($expected, $ch, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->l()->asArray(), $ch->l()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -173,7 +173,7 @@ public function lTIsTranspose() : void
 
         $ch = new Cholesky($l);
 
-        $this->assertEqualsWithDelta($l->transpose(), $ch->lT(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($l->transpose()->asArray(), $ch->lT()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -188,13 +188,13 @@ public function accessorsReturnMatrices() : void
 
         $ch = new Cholesky($l);
 
-        $this->assertEquals($l, $ch->l());
+        $this->assertEquals($l->asArray(), $ch->l()->asArray());
 
         $expectedT = Matrix::fromArray([
             [1.0, 0.5],
             [0.0, 1.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedT, $ch->lT(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedT->asArray(), $ch->lT()->asArray(), self::MAX_DELTA);
     }
 }
diff --git a/tests/Decompositions/EigenTest.php b/tests/Decompositions/EigenTest.php
index 6bd355c..a7f4cb0 100644
--- a/tests/Decompositions/EigenTest.php
+++ b/tests/Decompositions/EigenTest.php
@@ -120,7 +120,7 @@ public function decompose1x1() : void
 
         $this->assertEquals([9.0], $eig->eigenvalues());
 
-        $this->assertEqualsWithDelta(Matrix::fromArray([[1.0]]), $eig->eigenvectors(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::fromArray([[1.0]])->asArray(), $eig->eigenvectors()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -170,7 +170,7 @@ public function constructAndAccess() : void
         $eig = new Eigen($eigenvalues, $eigenvectors);
 
         $this->assertEquals($eigenvalues, $eig->eigenvalues());
-        $this->assertEqualsWithDelta($eigenvectors, $eig->eigenvectors(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($eigenvectors->asArray(), $eig->eigenvectors()->asArray(), self::MAX_DELTA);
     }
 
     /**
diff --git a/tests/Decompositions/LUTest.php b/tests/Decompositions/LUTest.php
index 672fb05..0388bb2 100644
--- a/tests/Decompositions/LUTest.php
+++ b/tests/Decompositions/LUTest.php
@@ -53,13 +53,15 @@ public function decompose3x3() : void
 
         $expected = new LU($l, $u, $p);
 
-        $this->assertEqualsWithDelta($expected, $lu, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($l->asArray(), $lu->l()->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($u->asArray(), $lu->u()->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($p->asArray(), $lu->p()->asArray(), self::MAX_DELTA);
 
         // And, cross-check the factors are consistent: P * A == L * U.
         $pa = $lu->p()->matmul($a);
         $luProd = $lu->l()->matmul($lu->u());
 
-        $this->assertEqualsWithDelta($pa, $luProd, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($pa->asArray(), $luProd->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -80,7 +82,7 @@ public function decomposeRequiresPivoting() : void
         $pa = $lu->p()->matmul($a);
         $luProd = $lu->l()->matmul($lu->u());
 
-        $this->assertEqualsWithDelta($pa, $luProd, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($pa->asArray(), $luProd->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -98,7 +100,9 @@ public function decompose1x1() : void
 
         $expected = new LU($l, $u, $p);
 
-        $this->assertEqualsWithDelta($expected, $lu, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($l->asArray(), $lu->l()->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($u->asArray(), $lu->u()->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($p->asArray(), $lu->p()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -130,7 +134,9 @@ public function decomposeDiagonal() : void
 
         $expected = new LU($l, $u, $p);
 
-        $this->assertEqualsWithDelta($expected, $lu, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($l->asArray(), $lu->l()->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($u->asArray(), $lu->u()->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($p->asArray(), $lu->p()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -181,8 +187,8 @@ public function accessorsReturnMatrices() : void
 
         $lu = new LU($l, $u, $p);
 
-        $this->assertEquals($l, $lu->l());
-        $this->assertEquals($u, $lu->u());
-        $this->assertEquals($p, $lu->p());
+        $this->assertEquals($l->asArray(), $lu->l()->asArray());
+        $this->assertEquals($u->asArray(), $lu->u()->asArray());
+        $this->assertEquals($p->asArray(), $lu->p()->asArray());
     }
 }
diff --git a/tests/Decompositions/SVDTest.php b/tests/Decompositions/SVDTest.php
index 5ff73d0..5c1d946 100644
--- a/tests/Decompositions/SVDTest.php
+++ b/tests/Decompositions/SVDTest.php
@@ -38,11 +38,11 @@ public function decomposeSquare3x3() : void
         $this->assertEqualsWithDelta(8.929610580306822, $svd->singularValues()[2], self::MAX_DELTA);
 
         // The decomposition must reconstruct the original matrix.
-        $this->assertEqualsWithDelta($a, $this->reconstruct($svd, 3, 3), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $this->reconstruct($svd, 3, 3)->asArray(), self::MAX_DELTA);
 
         // Both U and V must be orthogonal matrices.
-        $this->assertEqualsWithDelta(Matrix::identity(3), $svd->u()->transpose()->matmul($svd->u()), self::MAX_DELTA);
-        $this->assertEqualsWithDelta(Matrix::identity(3), $svd->vT()->matmul($svd->vT()->transpose()), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(3)->asArray(), $svd->u()->transpose()->matmul($svd->u())->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(3)->asArray(), $svd->vT()->matmul($svd->vT()->transpose())->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -59,10 +59,10 @@ public function decomposeSquare2x2() : void
 
         $this->assertCount(2, $svd->singularValues());
 
-        $this->assertEqualsWithDelta($a, $this->reconstruct($svd, 2, 2), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $this->reconstruct($svd, 2, 2)->asArray(), self::MAX_DELTA);
 
-        $this->assertEqualsWithDelta(Matrix::identity(2), $svd->u()->transpose()->matmul($svd->u()), self::MAX_DELTA);
-        $this->assertEqualsWithDelta(Matrix::identity(2), $svd->vT()->matmul($svd->vT()->transpose()), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(2)->asArray(), $svd->u()->transpose()->matmul($svd->u())->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(2)->asArray(), $svd->vT()->matmul($svd->vT()->transpose())->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -84,10 +84,10 @@ public function decomposeTall() : void
         $this->assertSame([4, 4], $svd->u()->shape());
         $this->assertSame([2, 2], $svd->vT()->shape());
 
-        $this->assertEqualsWithDelta($a, $this->reconstruct($svd, 4, 2), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $this->reconstruct($svd, 4, 2)->asArray(), self::MAX_DELTA);
 
-        $this->assertEqualsWithDelta(Matrix::identity(4), $svd->u()->transpose()->matmul($svd->u()), self::MAX_DELTA);
-        $this->assertEqualsWithDelta(Matrix::identity(2), $svd->vT()->matmul($svd->vT()->transpose()), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(4)->asArray(), $svd->u()->transpose()->matmul($svd->u())->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(2)->asArray(), $svd->vT()->matmul($svd->vT()->transpose())->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -107,10 +107,10 @@ public function decomposeWide() : void
         $this->assertSame([2, 2], $svd->u()->shape());
         $this->assertSame([3, 3], $svd->vT()->shape());
 
-        $this->assertEqualsWithDelta($a, $this->reconstruct($svd, 2, 3), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $this->reconstruct($svd, 2, 3)->asArray(), self::MAX_DELTA);
 
-        $this->assertEqualsWithDelta(Matrix::identity(2), $svd->u()->transpose()->matmul($svd->u()), self::MAX_DELTA);
-        $this->assertEqualsWithDelta(Matrix::identity(3), $svd->vT()->matmul($svd->vT()->transpose()), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(2)->asArray(), $svd->u()->transpose()->matmul($svd->u())->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(3)->asArray(), $svd->vT()->matmul($svd->vT()->transpose())->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -124,7 +124,7 @@ public function decompose1x1() : void
 
         $this->assertEqualsWithDelta([9.0], $svd->singularValues(), self::MAX_DELTA);
 
-        $this->assertEqualsWithDelta($a, $this->reconstruct($svd, 1, 1), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $this->reconstruct($svd, 1, 1)->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -144,10 +144,10 @@ public function decomposeRankDeficient() : void
         $this->assertEqualsWithDelta(sqrt(10.0), $svd->singularValues()[0], self::MAX_DELTA);
         $this->assertEqualsWithDelta(0.0, $svd->singularValues()[1], self::MAX_DELTA);
 
-        $this->assertEqualsWithDelta($a, $this->reconstruct($svd, 2, 2), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $this->reconstruct($svd, 2, 2)->asArray(), self::MAX_DELTA);
 
-        $this->assertEqualsWithDelta(Matrix::identity(2), $svd->u()->transpose()->matmul($svd->u()), self::MAX_DELTA);
-        $this->assertEqualsWithDelta(Matrix::identity(2), $svd->vT()->matmul($svd->vT()->transpose()), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(2)->asArray(), $svd->u()->transpose()->matmul($svd->u())->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::identity(2)->asArray(), $svd->vT()->matmul($svd->vT()->transpose())->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -169,7 +169,7 @@ public function decomposePreservesTinySingularValues() : void
         $this->assertEqualsWithDelta(1e-9, $svd->singularValues()[1], self::MAX_DELTA);
         $this->assertEqualsWithDelta(0.0, $svd->singularValues()[2], self::MAX_DELTA);
 
-        $this->assertEqualsWithDelta($a, $this->reconstruct($svd, 3, 3), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $this->reconstruct($svd, 3, 3)->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -191,12 +191,12 @@ public function constructAndAccess() : void
 
         $svd = new SVD($u, $singularValues, $vT);
 
-        $this->assertEqualsWithDelta($u, $svd->u(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($u->asArray(), $svd->u()->asArray(), self::MAX_DELTA);
         $this->assertEquals($singularValues, $svd->singularValues());
-        $this->assertEqualsWithDelta($vT, $svd->vT(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($vT->asArray(), $svd->vT()->asArray(), self::MAX_DELTA);
 
         // v is the transpose of vT.
-        $this->assertEqualsWithDelta($vT->transpose(), $svd->v(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($vT->transpose()->asArray(), $svd->v()->asArray(), self::MAX_DELTA);
 
         // The singular value matrix is an m by n matrix with the singular values on the diagonal.
         $this->assertSame([2, 2], $svd->s()->shape());
@@ -206,7 +206,7 @@ public function constructAndAccess() : void
             [0.0, 3.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedS, $svd->s(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedS->asArray(), $svd->s()->asArray(), self::MAX_DELTA);
     }
 
     /**
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index 5984800..29c8bdf 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -104,7 +104,7 @@ public function identity() : void
             [0.0, 0.0, 0.0, 1.0],
         ]);
 
-        $this->assertEquals($expected, $matrix);
+        $this->assertEquals($expected->asArray(), $matrix->asArray());
     }
 
     /**
@@ -119,7 +119,7 @@ public function zeros() : void
             [0.0, 0.0, 0.0, 0.0],
         ]);
 
-        $this->assertEquals($expected, $matrix);
+        $this->assertEquals($expected->asArray(), $matrix->asArray());
     }
 
     /**
@@ -136,7 +136,7 @@ public function ones() : void
             [1.0, 1.0],
         ]);
 
-        $this->assertEquals($expected, $matrix);
+        $this->assertEquals($expected->asArray(), $matrix->asArray());
     }
 
     /**
@@ -153,7 +153,7 @@ public function diagonal() : void
             [0.0, 0.0, 0.0, 5.0],
         ]);
 
-        $this->assertEquals($expected, $matrix);
+        $this->assertEquals($expected->asArray(), $matrix->asArray());
     }
 
     /**
@@ -170,7 +170,7 @@ public function fill() : void
             [5.0, 5.0, 5.0, 5.0],
         ]);
 
-        $this->assertEquals($expected, $matrix);
+        $this->assertEquals($expected->asArray(), $matrix->asArray());
     }
 
     /**
@@ -212,7 +212,7 @@ public function poissonZeroLambdaIsZero() : void
 
         $expected = Matrix::fill(0.0, 3, 3);
 
-        $this->assertEquals($expected, $matrix);
+        $this->assertEquals($expected->asArray(), $matrix->asArray());
     }
 
     /**
@@ -354,7 +354,7 @@ public function rowAsVector() : void
 
         $expected = Vector::fromArray([4.0, 11.0, -2.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -372,7 +372,7 @@ public function columnAsVector() : void
 
         $expected = ColumnVector::fromArray([-17.0, 11.0, -6.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -390,7 +390,7 @@ public function diagonalAsVector() : void
 
         $expected = Vector::fromArray([22.0, 11.0, -9.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -457,7 +457,10 @@ public function asVectors() : void
             Vector::fromArray([20.0, -6.0, -9.0]),
         ];
 
-        $this->assertEquals($expected, $vectors);
+        $this->assertEquals(
+            array_map(static fn (Vector $vector) => $vector->asArray(), $expected),
+            array_map(static fn (Vector $vector) => $vector->asArray(), $vectors)
+        );
     }
 
     /**
@@ -479,7 +482,10 @@ public function asColumnVectors() : void
             ColumnVector::fromArray([12.0, -2.0, -9.0]),
         ];
 
-        $this->assertEquals($expected, $vectors);
+        $this->assertEquals(
+            array_map(static fn (ColumnVector $vector) => $vector->asArray(), $expected),
+            array_map(static fn (ColumnVector $vector) => $vector->asArray(), $vectors)
+        );
     }
 
     /**
@@ -497,7 +503,7 @@ public function flatten() : void
 
         $expected = Vector::fromArray([22.0, -17.0, 12.0, 4.0, 11.0, -2.0, 20.0, -6.0, -9.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -519,7 +525,7 @@ public function transpose() : void
             [12.0, -2.0, -9.0],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -541,7 +547,7 @@ public function inverse() : void
             [0.04602036967182196, 0.03923047906450396, -0.05846850245190495],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -597,7 +603,7 @@ public function pseudoinverse() : void
             [0.01266554551187723, -0.0031357298016957483],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -764,7 +770,7 @@ public function reciprocal() : void
             [0.05, -0.16666666666666666, -0.1111111111111111],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -790,7 +796,7 @@ public function map() : void
             [1, -1, -1],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -844,7 +850,8 @@ public function ref() : void
 
         $expected = new REF($a, 0);
 
-        $this->assertEqualsWithDelta($expected, $ref, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
+        $this->assertEquals(0, $ref->swaps());
     }
 
     /**
@@ -868,7 +875,7 @@ public function rref() : void
 
         $expected = new RREF($a);
 
-        $this->assertEqualsWithDelta($expected, $rref, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $rref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -904,7 +911,9 @@ public function lu() : void
 
         $expected = new LU($l, $u, $p);
 
-        $this->assertEqualsWithDelta($expected, $lu, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($l->asArray(), $lu->l()->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($u->asArray(), $lu->u()->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($p->asArray(), $lu->p()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -924,7 +933,7 @@ public function luMultiPivot() : void
         $pa = $lu->p()->matmul($matrix);
         $luProd = $lu->l()->matmul($lu->u());
 
-        $this->assertEqualsWithDelta($pa, $luProd, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($pa->asArray(), $luProd->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -944,7 +953,7 @@ public function luNegativePivot() : void
         $pa = $lu->p()->matmul($matrix);
         $luProd = $lu->l()->matmul($lu->u());
 
-        $this->assertEqualsWithDelta($pa, $luProd, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($pa->asArray(), $luProd->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -985,7 +994,7 @@ public function cholesky() : void
 
         $expected = new Cholesky($l);
 
-        $this->assertEqualsWithDelta($expected, $cholesky, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($l->asArray(), $cholesky->l()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1000,7 +1009,8 @@ public function eig(Matrix $matrix, Eigen $expected) : void
     {
         $eig = $matrix->eig(false);
 
-        $this->assertEqualsWithDelta($expected, $eig, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->eigenvalues(), $eig->eigenvalues(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->eigenvectors()->asArray(), $eig->eigenvectors()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1051,7 +1061,8 @@ public function eigSymmetric() : void
 
         $expected = new Eigen($values, $vectors);
 
-        $this->assertEqualsWithDelta($expected, $eig, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->eigenvalues(), $eig->eigenvalues(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->eigenvectors()->asArray(), $eig->eigenvectors()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1086,7 +1097,9 @@ public function svd() : void
 
         $expected = new SVD($u, $singularValues, $vT);
 
-        $this->assertEqualsWithDelta($expected, $svd, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($u->asArray(), $svd->u()->asArray(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($singularValues, $svd->singularValues(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($vT->asArray(), $svd->vT()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1112,7 +1125,7 @@ public function matmul() : void
             [207.0], [155.0], [113.0],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1132,7 +1145,7 @@ public function dotVector() : void
 
         $expected = ColumnVector::fromArray([-138.0, 120.0, -11.0]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1166,7 +1179,7 @@ public function convolve() : void
             [0.0, 3.0, 19.0, 26.0, 27.0, 33.0],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1197,7 +1210,7 @@ public function convolveStrideTwo() : void
             [33.0, 35.0, 37.0, 39.0],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1224,7 +1237,7 @@ public function convolveStrideThree() : void
             [25.0, 28.0, 31.0],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1239,7 +1252,7 @@ public function multiply(Matrix $a, $b, $expected) : void
     {
         $c = $a->multiply($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1320,7 +1333,7 @@ public function divide(Matrix $a, $b, $expected) : void
     {
         $c = $a->divide($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1401,7 +1414,7 @@ public function add(Matrix $a, $b, $expected) : void
     {
         $c = $a->add($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1482,7 +1495,7 @@ public function subtract(Matrix $a, $b, $expected) : void
     {
         $c = $a->subtract($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1563,7 +1576,7 @@ public function pow(Matrix $a, $b, $expected) : void
     {
         $c = $a->pow($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1630,7 +1643,7 @@ public function mod(Matrix $a, $b, $expected) : void
     {
         $c = $a->mod($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1711,7 +1724,7 @@ public function equal(Matrix $a, $b, $expected) : void
     {
         $c = $a->equal($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1792,7 +1805,7 @@ public function notEqual(Matrix $a, $b, $expected) : void
     {
         $c = $a->notEqual($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1873,7 +1886,7 @@ public function greater(Matrix $a, $b, $expected) : void
     {
         $c = $a->greater($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1954,7 +1967,7 @@ public function greaterEqual(Matrix $a, $b, $expected) : void
     {
         $c = $a->greaterEqual($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -2035,7 +2048,7 @@ public function less(Matrix $a, $b, $expected) : void
     {
         $c = $a->less($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -2116,7 +2129,7 @@ public function lessEqual(Matrix $a, $b, $expected) : void
     {
         $c = $a->lessEqual($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -2204,7 +2217,7 @@ public function abs() : void
             [20.0, 6.0, 9.0],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2226,7 +2239,7 @@ public function square() : void
             [400.0, 36.0, 81.0],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2248,7 +2261,7 @@ public function sqrt() : void
             [3.0],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2270,7 +2283,7 @@ public function exp() : void
             [8103.08392757538],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2292,7 +2305,7 @@ public function expm1() : void
             [8102.083927575384],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2314,7 +2327,7 @@ public function log() : void
             [2.1972245773362196],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2336,7 +2349,7 @@ public function log1p() : void
             [2.302585092994046],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2358,7 +2371,7 @@ public function sin() : void
             [0.4121184852417566],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2380,7 +2393,7 @@ public function asin() : void
             [0.010000166674167114],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2402,7 +2415,7 @@ public function cos() : void
             [-0.9111302618846769],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2424,7 +2437,7 @@ public function acos() : void
             [1.5607961601207294],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2446,7 +2459,7 @@ public function tan() : void
             [-0.45231565944180985],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2468,7 +2481,7 @@ public function atan() : void
             [1.460139105621001],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2490,7 +2503,7 @@ public function rad2deg() : void
             [515.6620156177408],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2512,7 +2525,7 @@ public function deg2rad() : void
             [0.15707963267948966],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2530,7 +2543,7 @@ public function sum() : void
 
         $expected = ColumnVector::fromArray([17.0, 13.0, 5.0]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2548,7 +2561,7 @@ public function product() : void
 
         $expected = ColumnVector::fromArray([-4488.0, -88.0, 1080.0]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2566,7 +2579,7 @@ public function min() : void
 
         $expected = ColumnVector::fromArray([-17.0, -2.0, -9.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2584,7 +2597,7 @@ public function max() : void
 
         $expected = ColumnVector::fromArray([22.0, 11.0, 20.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2602,7 +2615,7 @@ public function mean() : void
 
         $expected = ColumnVector::fromArray([5.666666666666667, 4.333333333333333, 1.6666666666666667]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2620,7 +2633,7 @@ public function median() : void
 
         $expected = ColumnVector::fromArray([12.0, 4.0, -6.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2638,13 +2651,13 @@ public function quantile() : void
 
         $expected = ColumnVector::fromArray([6.200000000000001, 2.8000000000000003, -6.6]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
 
         $max = $a->quantile(1.0);
 
         $maxExpected = ColumnVector::fromArray([22.0, 11.0, 20.0]);
 
-        $this->assertEqualsWithDelta($maxExpected, $max, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($maxExpected->asArray(), $max->asArray(), self::MAX_DELTA);
 
         $single = Matrix::fromArray([
             [5.0],
@@ -2655,8 +2668,8 @@ public function quantile() : void
         $singleExpected = ColumnVector::fromArray([5.0, 3.0, 8.0]);
 
         $this->assertEqualsWithDelta(
-            $singleExpected,
-            $single->quantile(0.5),
+            $singleExpected->asArray(),
+            $single->quantile(0.5)->asArray(),
             self::MAX_DELTA
         );
     }
@@ -2676,7 +2689,7 @@ public function variance() : void
 
         $expected = ColumnVector::fromArray([273.55555555555554, 28.222222222222225, 169.55555555555554]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2693,7 +2706,7 @@ public function varianceRowNonSquare() : void
 
         $expected = ColumnVector::fromArray([0.6666666666666666, 66.66666666666667]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2715,7 +2728,7 @@ public function covariance() : void
             [135.2222222222222, 3.4444444444444406, 169.55555555555554],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
 
         $c = Matrix::fromArray([
             [1.0, 2.0, 3.0],
@@ -2729,7 +2742,7 @@ public function covariance() : void
             [2.0 / 3.0, 2.0 / 3.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedC, $d, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedC->asArray(), $d->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2751,7 +2764,7 @@ public function round() : void
             [20, -6, -9],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -2773,7 +2786,7 @@ public function floor() : void
             [20, -6, -9],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2795,7 +2808,7 @@ public function ceil() : void
             [20, -6, -9],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2879,7 +2892,7 @@ public function clip() : void
             [20, 0.0, 0.],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2901,7 +2914,7 @@ public function clipLower() : void
             [20, 5.0, 5.],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2923,7 +2936,7 @@ public function clipUpper() : void
             [16, -6.0, -9.0],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2945,7 +2958,7 @@ public function sign() : void
             [1, -1, -1],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2967,7 +2980,7 @@ public function negate() : void
             [-20, 6, 9],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -2998,7 +3011,7 @@ public function augmentAbove() : void
             [20, -6, -9],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -3029,7 +3042,7 @@ public function augmentBelow() : void
             [-10, -1, 14],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -3057,7 +3070,7 @@ public function augmentLeft() : void
             [9, 20, -6, -9],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -3085,7 +3098,7 @@ public function augmentRight() : void
             [20, -6, -9, 9],
         ]);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -3110,7 +3123,7 @@ public function repeat() : void
             [9, 9, 9, 9],
         ]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -3378,6 +3391,6 @@ public function pseudoinversePreservesTinySingularValues() : void
             [0.0, 1.0 / 1e-9],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $a->pseudoinverse(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $a->pseudoinverse()->asArray(), self::MAX_DELTA);
     }
 }
diff --git a/tests/Reductions/REFTest.php b/tests/Reductions/REFTest.php
index fe46cd6..1585ec5 100644
--- a/tests/Reductions/REFTest.php
+++ b/tests/Reductions/REFTest.php
@@ -39,7 +39,7 @@ public function reduce2x2() : void
         ]);
 
         $this->assertEquals(1, $ref->swaps());
-        $this->assertEqualsWithDelta($expectedA, $ref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -61,7 +61,7 @@ public function reduce3x3() : void
             [0.0, 0.0, -17.10322580645161],
         ]);
 
-        $this->assertEqualsWithDelta($expectedA, $ref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -83,7 +83,7 @@ public function reduce2x3Rectangular() : void
         ]);
 
         $this->assertEquals(1, $ref->swaps());
-        $this->assertEqualsWithDelta($expectedA, $ref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -108,7 +108,7 @@ public function reduceRequiresPivoting() : void
             [0.0, 1.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedA, $ref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -123,7 +123,7 @@ public function reduce1x1() : void
         $expectedA = Matrix::fromArray([[7.0]]);
 
         $this->assertEquals(0, $ref->swaps());
-        $this->assertEqualsWithDelta($expectedA, $ref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -145,7 +145,7 @@ public function reduceDiagonal() : void
         ]);
 
         $this->assertEquals(0, $ref->swaps());
-        $this->assertEqualsWithDelta($expectedA, $ref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -189,7 +189,7 @@ public function reduceSingularKeepsPivotScale() : void
             [0.0, 0.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedA, $ref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -211,7 +211,7 @@ public function constructorWithZeroSwaps() : void
 
         $ref = new REF($a, 0);
 
-        $this->assertEqualsWithDelta($a, $ref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
         $this->assertEquals(0, $ref->swaps());
     }
 
@@ -227,7 +227,7 @@ public function constructorWithPositiveSwaps() : void
 
         $ref = new REF($a, 2);
 
-        $this->assertEqualsWithDelta($a, $ref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $ref->a()->asArray(), self::MAX_DELTA);
 
         $this->assertEquals(2, $ref->swaps());
     }
diff --git a/tests/Reductions/RREFTest.php b/tests/Reductions/RREFTest.php
index 1c98028..1fa265d 100644
--- a/tests/Reductions/RREFTest.php
+++ b/tests/Reductions/RREFTest.php
@@ -38,7 +38,7 @@ public function reduceDiagonalIsIdentity() : void
             [0.0, 0.0, 1.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedA, $rref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $rref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -58,7 +58,7 @@ public function reduce2x2() : void
             [0.0, 1.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedA, $rref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $rref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -78,7 +78,7 @@ public function reduceDiagonal2x2() : void
             [0.0, 1.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedA, $rref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $rref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -90,7 +90,7 @@ public function reduce1x1() : void
 
         $rref = RREF::reduce($a);
 
-        $this->assertEqualsWithDelta(Matrix::fromArray([[1.0]]), $rref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta(Matrix::fromArray([[1.0]])->asArray(), $rref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -111,7 +111,7 @@ public function reduceSingular2x2() : void
             [0.0, 0.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedA, $rref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $rref->a()->asArray(), self::MAX_DELTA);
 
         $aOut = $rref->a()->asArray();
 
@@ -136,7 +136,7 @@ public function reduceZeroRow() : void
             [0.0, 0.0],
         ]);
 
-        $this->assertEqualsWithDelta($expectedA, $rref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expectedA->asArray(), $rref->a()->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -230,6 +230,6 @@ public function accessorsReturnMatrices() : void
 
         $rref = new RREF($a);
 
-        $this->assertEqualsWithDelta($a, $rref->a(), self::MAX_DELTA);
+        $this->assertEqualsWithDelta($a->asArray(), $rref->a()->asArray(), self::MAX_DELTA);
     }
 }
diff --git a/tests/TensorComparator.php b/tests/TensorComparator.php
deleted file mode 100644
index f392da5..0000000
--- a/tests/TensorComparator.php
+++ /dev/null
@@ -1,132 +0,0 @@
-<?php
-
-namespace Tensor\Tests;
-
-use Tensor\Matrix;
-use Tensor\Vector;
-use Tensor\ColumnVector;
-use Tensor\Reductions\Ref;
-use Tensor\Reductions\Rref;
-use Tensor\Decompositions\Lu;
-use Tensor\Decompositions\Eigen;
-use Tensor\Decompositions\Svd;
-use Tensor\Decompositions\Cholesky;
-use SebastianBergmann\Comparator\Comparator;
-use SebastianBergmann\Comparator\ComparisonFailure;
-
-/**
- * @internal
- *
- * Compares two tensor objects for equality by their numerical content.
- *
- * Tensors store their elements in an opaque internal buffer that has no
- * reflection-visible properties, so PHPUnit's default object comparator treats
- * any two same-shape tensors as equal regardless of their contents. This
- * comparator reduces each operand to its plain array of values before
- * delegating back to the comparator factory, so the delta, canonicalize and
- * ignoreCase flags keep their usual meaning.
- */
-class TensorComparator extends Comparator
-{
-    /**
-     * The tensor classes whose content lives in an opaque internal buffer.
-     *
-     * @var list<class-string>
-     */
-    private const TENSOR_CLASSES = [
-        Matrix::class,
-        Vector::class,
-        ColumnVector::class,
-        Ref::class,
-        Rref::class,
-        Lu::class,
-        Eigen::class,
-        Svd::class,
-        Cholesky::class,
-    ];
-
-    /**
-     * @param mixed $expected
-     * @param mixed $actual
-     */
-    public function accepts($expected, $actual) : bool
-    {
-        return is_object($expected)
-            && is_object($actual)
-            && get_class($expected) === get_class($actual)
-            && in_array(get_class($expected), self::TENSOR_CLASSES, true);
-    }
-
-    /**
-     * @param mixed $expected
-     * @param mixed $actual
-     * @param float $delta
-     * @param bool $canonicalize
-     * @param bool $ignoreCase
-     */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false) : void
-    {
-        $expectedValues = $this->toArray($expected);
-        $actualValues = $this->toArray($actual);
-
-        try {
-            $this->factory->getComparatorFor($expectedValues, $actualValues)
-                ->assertEquals($expectedValues, $actualValues, $delta, $canonicalize, $ignoreCase);
-        } catch (ComparisonFailure $failure) {
-            throw new ComparisonFailure(
-                $expected,
-                $actual,
-                substr_replace($failure->getExpectedAsString(), get_class($expected) . ' Object', 0, 5),
-                substr_replace($failure->getActualAsString(), get_class($actual) . ' Object', 0, 5),
-                false,
-                'Failed asserting that two objects are equal.'
-            );
-        }
-    }
-
-    /**
-     * Reduce a tensor object to the plain values that it stores.
-     *
-     * Nested tensors are left in place so that the factory resolves them back
-     * to this comparator and applies the delta to their elements.
-     *
-     * @param object $object
-     * @return array<mixed>
-     */
-    private function toArray($object) : array
-    {
-        if ($object instanceof Matrix) {
-            return $object->asArray();
-        }
-
-        if ($object instanceof Vector) {
-            return $object->asArray();
-        }
-
-        if ($object instanceof Ref) {
-            return [$object->a(), $object->swaps()];
-        }
-
-        if ($object instanceof Rref) {
-            return [$object->a()];
-        }
-
-        if ($object instanceof Lu) {
-            return [$object->l(), $object->u(), $object->p()];
-        }
-
-        if ($object instanceof Eigen) {
-            return [$object->eigenvalues(), $object->eigenvectors()];
-        }
-
-        if ($object instanceof Svd) {
-            return [$object->u(), $object->singularValues(), $object->vT()];
-        }
-
-        if ($object instanceof Cholesky) {
-            return [$object->l()];
-        }
-
-        throw new \RuntimeException('Unsupported tensor class ' . get_class($object) . '.');
-    }
-}
diff --git a/tests/TensorComparatorTest.php b/tests/TensorComparatorTest.php
deleted file mode 100644
index a30481d..0000000
--- a/tests/TensorComparatorTest.php
+++ /dev/null
@@ -1,158 +0,0 @@
-<?php
-
-namespace Tensor\Tests;
-
-use Tensor\Matrix;
-use Tensor\Vector;
-use Tensor\ColumnVector;
-use Tensor\Decompositions\Lu;
-use PHPUnit\Framework\TestCase;
-use PHPUnit\Framework\ExpectationFailedException;
-
-/**
- * @covers \Tensor\Tests\TensorComparator
- */
-class TensorComparatorTest extends TestCase
-{
-    /**
-     * The maximum error tolerated due to varying numerical precision.
-     *
-     * @var float
-     */
-    protected const MAX_DELTA = 1e-8;
-
-    /**
-     * @test
-     */
-    public function comparesMatricesByValue() : void
-    {
-        $a = Matrix::fromArray([
-            [1, 2],
-            [3, 4],
-        ]);
-
-        $equal = Matrix::fromArray([
-            [1, 2],
-            [3, 4],
-        ]);
-
-        $different = Matrix::fromArray([
-            [999, 888],
-            [777, 666],
-        ]);
-
-        $this->assertEquals($a, $equal);
-        $this->assertNotEquals($a, $different);
-    }
-
-    /**
-     * @test
-     */
-    public function comparesMatricesByShape() : void
-    {
-        $a = Matrix::fromArray([
-            [1, 2],
-            [3, 4],
-        ]);
-
-        $transposed = Matrix::fromArray([
-            [1, 3],
-            [2, 4],
-        ]);
-
-        $this->assertNotEquals($a, $transposed);
-    }
-
-    /**
-     * @test
-     */
-    public function comparesMatricesWithinDelta() : void
-    {
-        $a = Matrix::fromArray([
-            [1, 2],
-            [3, 4],
-        ]);
-
-        $b = Matrix::fromArray([
-            [1.0000000001, 2],
-            [3, 4],
-        ]);
-
-        $this->assertEqualsWithDelta($a, $b, self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function matricesOutsideOfDeltaAreUnequal() : void
-    {
-        $this->expectException(ExpectationFailedException::class);
-
-        $a = Matrix::fromArray([
-            [1, 2],
-            [3, 4],
-        ]);
-
-        $b = Matrix::fromArray([
-            [1.0001, 2],
-            [3, 4],
-        ]);
-
-        $this->assertEqualsWithDelta($a, $b, self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function comparesVectorsByValue() : void
-    {
-        $a = Vector::fromArray([1, 2]);
-        $equal = Vector::fromArray([1, 2]);
-        $different = Vector::fromArray([9, 9]);
-
-        $this->assertEquals($a, $equal);
-        $this->assertNotEquals($a, $different);
-    }
-
-    /**
-     * @test
-     */
-    public function comparesColumnVectorsByValue() : void
-    {
-        $a = ColumnVector::fromArray([1, 2]);
-        $different = ColumnVector::fromArray([9, 9]);
-
-        $this->assertNotEquals($a, $different);
-    }
-
-    /**
-     * @test
-     */
-    public function distinguishesVectorFromColumnVector() : void
-    {
-        $vector = Vector::fromArray([1, 2]);
-        $column = ColumnVector::fromArray([1, 2]);
-
-        $this->assertNotEquals($vector, $column);
-    }
-
-    /**
-     * @test
-     */
-    public function comparesDecompositionsByValue() : void
-    {
-        $a = new Lu(
-            Matrix::fromArray([[1, 0], [0, 1]]),
-            Matrix::fromArray([[2, 0], [0, 2]]),
-            Matrix::fromArray([[1, 0], [0, 1]])
-        );
-
-        $b = new Lu(
-            Matrix::fromArray([[1, 0], [0, 1]]),
-            Matrix::fromArray([[999, 0], [0, 2]]),
-            Matrix::fromArray([[1, 0], [0, 1]])
-        );
-
-        $this->assertNotEquals($a, $b);
-    }
-}
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index 67a41b7..4f87f7f 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -78,7 +78,7 @@ public function zeros() : void
 
         $expected = Vector::fromArray([0, 0, 0, 0]);
 
-        $this->assertEquals($expected, $zeros);
+        $this->assertEquals($expected->asArray(), $zeros->asArray());
     }
 
     /**
@@ -90,7 +90,7 @@ public function ones() : void
 
         $expected = Vector::fromArray([1, 1, 1, 1]);
 
-        $this->assertEquals($expected, $ones);
+        $this->assertEquals($expected->asArray(), $ones->asArray());
     }
 
     /**
@@ -102,7 +102,7 @@ public function fill() : void
 
         $expected = Vector::fromArray([16, 16, 16, 16]);
 
-        $this->assertEquals($expected, $vector);
+        $this->assertEquals($expected->asArray(), $vector->asArray());
     }
 
     /**
@@ -282,7 +282,7 @@ public function range() : void
 
         $expected = Vector::fromArray([5.0, 7.0, 9.0, 11.0]);
 
-        $this->assertEquals($expected, $vector);
+        $this->assertEquals($expected->asArray(), $vector->asArray());
     }
 
     /**
@@ -297,7 +297,7 @@ public function linspace() : void
             0.5555555555555558, 1.666666666666667, 2.777777777777778, 3.8888888888888893, 5.0,
         ]);
 
-        $this->assertEquals($expected, $vector);
+        $this->assertEquals($expected->asArray(), $vector->asArray());
     }
 
     /**
@@ -407,7 +407,7 @@ public function asRowMatrix() : void
             [-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0],
         ]);
 
-        $this->assertEquals($expected, $matrix);
+        $this->assertEquals($expected->asArray(), $matrix->asArray());
     }
 
     /**
@@ -421,7 +421,7 @@ public function asColumnMatrix() : void
 
         $expected = Matrix::fromArray([[-15.0], [25.0], [35.0], [-36.0], [-72.0], [89.0], [106.0], [45.0]]);
 
-        $this->assertEquals($expected, $matrix);
+        $this->assertEquals($expected->asArray(), $matrix->asArray());
     }
 
     /**
@@ -440,7 +440,7 @@ public function reshape() : void
             [106.0, 45.0],
         ]);
 
-        $this->assertEquals($expected, $matrix);
+        $this->assertEquals($expected->asArray(), $matrix->asArray());
     }
 
     /**
@@ -454,7 +454,7 @@ public function transpose() : void
 
         $expected = ColumnVector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $this->assertEquals($expected, $vector);
+        $this->assertEquals($expected->asArray(), $vector->asArray());
     }
 
     /**
@@ -472,7 +472,7 @@ public function map() : void
 
         $expected = Vector::fromArray([0, 1, 1, 0, 0, 1, 1, 1]);
 
-        $this->assertEquals($expected, $vector);
+        $this->assertEquals($expected->asArray(), $vector->asArray());
     }
 
     /**
@@ -516,7 +516,7 @@ public function reciprocal() : void
             -0.013888888888888888, 0.011235955056179775, 0.009433962264150943, 0.022222222222222223,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $vector, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $vector->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -552,7 +552,7 @@ public function matmul() : void
             [622.3751, 4.634999999999993, 40.807],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -591,7 +591,7 @@ public function outer() : void
             [11.25, 4.5, 90.0, -22.5, -45.0, -135.0, 148.5, 90.],
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -610,7 +610,7 @@ public function convolve() : void
             10.000000000000114, 1764.3000000000002, 1625.1, 2234.7, 1378.4, 535.5,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -630,7 +630,7 @@ public function convolveFullReadsNoOutOfBounds() : void
 
         $expected = Vector::fromArray([5.0, 12.0, 26.0, 21.0, 32.0, 24.0, 33.0, 9.0]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -646,7 +646,7 @@ public function convolveStrideTwo() : void
 
         $expected = Vector::fromArray([5.0, 26.0, 32.0, 33.0]);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -661,7 +661,7 @@ public function multiply(Vector $a, $b, $expected) : void
     {
         $c = $a->multiply($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -708,7 +708,7 @@ public function divide(Vector $a, $b, $expected) : void
     {
         $c = $a->divide($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -755,7 +755,7 @@ public function add(Vector $a, $b, $expected) : void
     {
         $c = $a->add($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -802,7 +802,7 @@ public function subtract(Vector $a, $b, $expected) : void
     {
         $c = $a->subtract($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -849,7 +849,7 @@ public function power(Vector $a, $b, $expected) : void
     {
         $c = $a->pow($b);
 
-        $this->assertEqualsWithDelta($expected, $c, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -898,7 +898,7 @@ public function equal(Vector $a, $b, $expected) : void
     {
         $c = $a->equal($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -945,7 +945,7 @@ public function notEqual(Vector $a, $b, $expected) : void
     {
         $c = $a->notEqual($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1009,7 +1009,7 @@ public function greater(Vector $a, $b, $expected) : void
     {
         $c = $a->greater($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1056,7 +1056,7 @@ public function greaterEqual(Vector $a, $b, $expected) : void
     {
         $c = $a->greaterEqual($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1103,7 +1103,7 @@ public function less(Vector $a, $b, $expected) : void
     {
         $c = $a->less($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1150,7 +1150,7 @@ public function lessEqual(Vector $a, $b, $expected) : void
     {
         $c = $a->lessEqual($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1198,7 +1198,7 @@ public function mod(Vector $a, $b, $expected) : void
     {
         $c = $a->mod($b);
 
-        $this->assertEquals($expected, $c);
+        $this->assertEquals($expected->asArray(), $c->asArray());
     }
 
     /**
@@ -1230,7 +1230,7 @@ public function abs() : void
 
         $expected = Vector::fromArray([15.0, 25.0, 35.0, 36.0, 72.0, 89.0, 106.0, 45.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -1244,7 +1244,7 @@ public function square() : void
 
         $expected = Vector::fromArray([225.0, 625.0, 1225.0, 1296.0, 5184.0, 7921.0, 11236.0, 2025.0]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1258,7 +1258,7 @@ public function pow() : void
 
         $expected = Vector::fromArray([-3375.0, 15625.0, 42875.0, -46656.0, -373248.0, 704969.0, 1191016.0, 91125.0]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1275,7 +1275,7 @@ public function sqrt() : void
             1.61245154965971, 3.449637662132068,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1292,7 +1292,7 @@ public function exp() : void
             485165195.4097903, 13.463738035001692, 147266.6252405527,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1309,7 +1309,7 @@ public function log() : void
             2.995732273553991, 0.9555114450274363, 2.4765384001174837,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1326,7 +1326,7 @@ public function sin() : void
             0.9129452507276277, 0.5155013718214642, -0.6181371122370333,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1342,7 +1342,7 @@ public function asin() : void
             0.1001674211615598, 0.3046926540153975, -0.5235987755982989,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1359,7 +1359,7 @@ public function cos() : void
             0.40808206181339196, -0.8568887533689473, 0.7860702961410393,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1375,7 +1375,7 @@ public function acos() : void
             1.4706289056333368, 1.2661036727794992, 2.0943951023931957,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1392,7 +1392,7 @@ public function tan() : void
             2.237160944224742, -0.6015966130897586, -0.7863636563696398,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1409,7 +1409,7 @@ public function atan() : void
             1.5208379310729538, 1.2036224929766774, 1.486959684726482,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1426,7 +1426,7 @@ public function rad2deg() : void
             1145.9155902616465, 148.96902673401405, 681.8197762056797,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1443,7 +1443,7 @@ public function deg2rad() : void
             0.3490658503988659, 0.04537856055185257, 0.2076941809873252,
         ]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1545,7 +1545,7 @@ public function round() : void
 
         $expected = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
 
-        $this->assertEqualsWithDelta($expected, $b, self::MAX_DELTA);
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
     /**
@@ -1559,7 +1559,7 @@ public function floor() : void
 
         $expected = Vector::fromArray([4.0, 6.0, 2.0, 20.0, 2.0, 11.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -1573,7 +1573,7 @@ public function ceil() : void
 
         $expected = Vector::fromArray([4.0, 7.0, 3.0, 20.0, 3.0, 12.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -1627,7 +1627,7 @@ public function clip() : void
 
         $expected = Vector::fromArray([0.0, 25, 35, 0.0, 0.0, 89, 100.0, 45]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -1641,7 +1641,7 @@ public function clipLower() : void
 
         $expected = Vector::fromArray([60.0, 60.0, 60.0, 60.0, 60.0, 89, 106.0, 60.0]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -1655,7 +1655,7 @@ public function clipUpper() : void
 
         $expected = Vector::fromArray([-15.0, 25, 35, -36.0, -72.0, 50.0, 50.0, 45]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -1669,7 +1669,7 @@ public function sign() : void
 
         $expected = Vector::fromArray([-1, 1, 1, -1, -1, 1, 1, 1]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
@@ -1683,7 +1683,7 @@ public function negate() : void
 
         $expected = Vector::fromArray([15, -25, -35, 36, 72, -89, -106, -45]);
 
-        $this->assertEquals($expected, $b);
+        $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
     /**
diff --git a/tests/bootstrap.php b/tests/bootstrap.php
index 23e0a63..d21c14d 100644
--- a/tests/bootstrap.php
+++ b/tests/bootstrap.php
@@ -1,10 +1,3 @@
 <?php
 
-use SebastianBergmann\Comparator\Factory;
-use Tensor\Tests\TensorComparator;
-
 require __DIR__ . '/../vendor/autoload.php';
-
-Factory::getInstance()->register(
-    new TensorComparator()
-);

From 792b33e4468915fb70e55b41436a811fb7231c26 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 17:53:28 -0500
Subject: [PATCH 29/51] Convert to floats

---
 tests/ColumnVectorTest.php            | 154 +++++++++++++-------------
 tests/Decompositions/CholeskyTest.php |   6 +-
 tests/Decompositions/LUTest.php       |   8 +-
 tests/MatrixTest.php                  | 154 +++++++++++++-------------
 tests/VectorTest.php                  | 118 ++++++++++----------
 5 files changed, 220 insertions(+), 220 deletions(-)

diff --git a/tests/ColumnVectorTest.php b/tests/ColumnVectorTest.php
index e7fb000..f57dad8 100644
--- a/tests/ColumnVectorTest.php
+++ b/tests/ColumnVectorTest.php
@@ -33,7 +33,7 @@ class ColumnVectorTest extends TestCase
      */
     public function build() : void
     {
-        $vector = ColumnVector::fromArray([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $this->assertInstanceOf(ColumnVector::class, $vector);
         $this->assertInstanceOf(Tensor::class, $vector);
@@ -51,7 +51,7 @@ public function build() : void
      */
     public function shape() : void
     {
-        $vector = ColumnVector::fromArray([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $this->assertEquals([3], $vector->shape());
     }
@@ -61,7 +61,7 @@ public function shape() : void
      */
     public function shapeString() : void
     {
-        $vector = ColumnVector::fromArray([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $this->assertEquals('3', $vector->shapeString());
     }
@@ -71,7 +71,7 @@ public function shapeString() : void
      */
     public function size() : void
     {
-        $vector = ColumnVector::fromArray([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $this->assertEquals(3, $vector->size());
     }
@@ -81,7 +81,7 @@ public function size() : void
      */
     public function serialization() : void
     {
-        $vector = ColumnVector::fromArray([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $serialized = serialize($vector);
 
@@ -99,7 +99,7 @@ public function serialization() : void
      */
     public function m() : void
     {
-        $vector = ColumnVector::fromArray([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $this->assertEquals(3, $vector->m());
     }
@@ -109,7 +109,7 @@ public function m() : void
      */
     public function n() : void
     {
-        $vector = ColumnVector::fromArray([-15, 25, 35]);
+        $vector = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $this->assertEquals(1, $vector->n());
     }
@@ -119,20 +119,20 @@ public function n() : void
      */
     public function multiply() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->multiply($b);
 
         $expected = Matrix::fromArray([
-            [-93.45, 15, -0.44999999999999996],
-            [0.25, 50.24999999999999, 25],
-            [38.5, 175, -175],
+            [-93.45, 15.0, -0.44999999999999996],
+            [0.25, 50.24999999999999, 25.0],
+            [38.5, 175.0, -175.0],
         ]);
 
         $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
@@ -143,20 +143,20 @@ public function multiply() : void
      */
     public function divide() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->divide($b);
 
         $expected = Matrix::fromArray([
-            [-2.407704654895666, 15, -500.],
-            [2500.0, 12.437810945273633, 25],
-            [31.818181818181817, 7, -7],
+            [-2.407704654895666, 15.0, -500.],
+            [2500.0, 12.437810945273633, 25.0],
+            [31.818181818181817, 7.0, -7.0],
         ]);
 
         $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
@@ -167,20 +167,20 @@ public function divide() : void
      */
     public function add() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->add($b);
 
         $expected = Matrix::fromArray([
-            [-8.77, -16, -14.97],
-            [25.01, 27.009999999999998, 26],
-            [36.1, 40, 30],
+            [-8.77, -16.0, -14.97],
+            [25.01, 27.009999999999998, 26.0],
+            [36.1, 40.0, 30.0],
         ]);
 
         $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
@@ -191,20 +191,20 @@ public function add() : void
      */
     public function subtract() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->subtract($b);
 
         $expected = Matrix::fromArray([
-            [-21.23, -14, -15.03],
-            [24.99, 22.990000000000002, 24],
-            [33.9, 30, 40],
+            [-21.23, -14.0, -15.03],
+            [24.99, 22.990000000000002, 24.0],
+            [33.9, 30.0, 40.0],
         ]);
 
         $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
@@ -215,20 +215,20 @@ public function subtract() : void
      */
     public function equal() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->equal($b);
 
         $expected = Matrix::fromArray([
-            [0, 0, 0],
-            [0, 0, 0],
-            [0, 0, 0],
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
@@ -239,20 +239,20 @@ public function equal() : void
      */
     public function notEqual() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->notEqual($b);
 
         $expected = Matrix::fromArray([
-            [1, 1, 1],
-            [1, 1, 1],
-            [1, 1, 1],
+            [1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
@@ -263,20 +263,20 @@ public function notEqual() : void
      */
     public function greater() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->greater($b);
 
         $expected = Matrix::fromArray([
-            [0, 0, 0],
-            [1, 1, 1],
-            [1, 1, 1],
+            [0.0, 0.0, 0.0],
+            [1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
@@ -287,20 +287,20 @@ public function greater() : void
      */
     public function greaterEqual() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->greaterEqual($b);
 
         $expected = Matrix::fromArray([
-            [0, 0, 0],
-            [1, 1, 1],
-            [1, 1, 1],
+            [0.0, 0.0, 0.0],
+            [1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
@@ -311,20 +311,20 @@ public function greaterEqual() : void
      */
     public function less() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->less($b);
 
         $expected = Matrix::fromArray([
-            [1, 1, 1],
-            [0, 0, 0],
-            [0, 0, 0],
+            [1.0, 1.0, 1.0],
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
@@ -335,20 +335,20 @@ public function less() : void
      */
     public function lessEqual() : void
     {
-        $a = ColumnVector::fromArray([-15, 25, 35]);
+        $a = ColumnVector::fromArray([-15.0, 25.0, 35.0]);
 
         $b = Matrix::fromArray([
-            [6.23, -1, 0.03],
-            [0.01, 2.01, 1],
-            [1.1, 5, -5],
+            [6.23, -1.0, 0.03],
+            [0.01, 2.01, 1.0],
+            [1.1, 5.0, -5.0],
         ]);
 
         $c = $a->lessEqual($b);
 
         $expected = Matrix::fromArray([
-            [1, 1, 1],
-            [0, 0, 0],
-            [0, 0, 0],
+            [1.0, 1.0, 1.0],
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
diff --git a/tests/Decompositions/CholeskyTest.php b/tests/Decompositions/CholeskyTest.php
index 68aa590..e3998b7 100644
--- a/tests/Decompositions/CholeskyTest.php
+++ b/tests/Decompositions/CholeskyTest.php
@@ -59,9 +59,9 @@ public function decompose3x3() : void
         $ch = Cholesky::decompose($a);
 
         $l = Matrix::fromArray([
-            [1.4142135623730951, 0, 0],
-            [-0.7071067811865475, 1.224744871391589, 0],
-            [0, -0.8164965809277261, 1.1547005383792515],
+            [1.4142135623730951, 0.0, 0.0],
+            [-0.7071067811865475, 1.224744871391589, 0.0],
+            [0.0, -0.8164965809277261, 1.1547005383792515],
         ]);
 
         $expected = new Cholesky($l);
diff --git a/tests/Decompositions/LUTest.php b/tests/Decompositions/LUTest.php
index 0388bb2..066027d 100644
--- a/tests/Decompositions/LUTest.php
+++ b/tests/Decompositions/LUTest.php
@@ -34,8 +34,8 @@ public function decompose3x3() : void
         $lu = LU::decompose($a);
 
         $l = Matrix::fromArray([
-            [1.0, 0, 0],
-            [0.18181818181818182, 1.0, 0],
+            [1.0, 0.0, 0.0],
+            [0.18181818181818182, 1.0, 0.0],
             [0.9090909090909091, 0.6709677419354838, 1.0],
         ]);
 
@@ -46,8 +46,8 @@ public function decompose3x3() : void
         ]);
 
         $p = Matrix::fromArray([
-            [1.0, 0, 0],
-            [0.0, 1.0, 0],
+            [1.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0],
             [0.0, 0.0, 1.0],
         ]);
 
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index 29c8bdf..b69a073 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -791,9 +791,9 @@ public function map() : void
         $b = $a->map($sign);
 
         $expected = Matrix::fromArray([
-            [1, -1, 1],
-            [1, 1, -1],
-            [1, -1, -1],
+            [1.0, -1.0, 1.0],
+            [1.0, 1.0, -1.0],
+            [1.0, -1.0, -1.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
@@ -892,8 +892,8 @@ public function lu() : void
         $lu = $matrix->lu();
 
         $l = Matrix::fromArray([
-            [1.0, 0, 0],
-            [0.18181818181818182, 1.0, 0],
+            [1.0, 0.0, 0.0],
+            [0.18181818181818182, 1.0, 0.0],
             [0.9090909090909091, 0.6709677419354838, 1.0],
         ]);
 
@@ -987,9 +987,9 @@ public function cholesky() : void
         $cholesky = $matrix->cholesky();
 
         $l = Matrix::fromArray([
-            [1.4142135623730951, 0, 0],
-            [-0.7071067811865475, 1.224744871391589, 0],
-            [0, -0.8164965809277261, 1.1547005383792515],
+            [1.4142135623730951, 0.0, 0.0],
+            [-0.7071067811865475, 1.224744871391589, 0.0],
+            [0.0, -0.8164965809277261, 1.1547005383792515],
         ]);
 
         $expected = new Cholesky($l);
@@ -2094,7 +2094,7 @@ public function lessProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
                 [0.0, 1.0, 0.0],
                 [0.0, 0.0, 1.0],
@@ -2144,9 +2144,9 @@ public function lessEqualProvider() : Generator
                 [20.0, -6.0, -9.0],
             ]),
             Matrix::fromArray([
-                [4, 6, -12],
-                [1, 3, 5],
-                [-10, -1, 14],
+                [4.0, 6.0, -12.0],
+                [1.0, 3.0, 5.0],
+                [-10.0, -1.0, 14.0],
             ]),
             Matrix::fromArray([
                 [0.0, 1.0, 0.0],
@@ -2161,7 +2161,7 @@ public function lessEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            Vector::fromArray([2, 10, -1]),
+            Vector::fromArray([2.0, 10.0, -1.0]),
             Matrix::fromArray([
                 [0.0, 1.0, 0.0],
                 [0.0, 0.0, 1.0],
@@ -2175,7 +2175,7 @@ public function lessEqualProvider() : Generator
                 [4.0, 11.0, -2.0],
                 [20.0, -6.0, -9.0],
             ]),
-            ColumnVector::fromArray([2.5, -1, 4.8]),
+            ColumnVector::fromArray([2.5, -1.0, 4.8]),
             Matrix::fromArray([
                 [0.0, 1.0, 0.0],
                 [0.0, 0.0, 1.0],
@@ -2759,9 +2759,9 @@ public function round() : void
         $b = $a->round(2);
 
         $expected = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
@@ -2781,9 +2781,9 @@ public function floor() : void
         $b = $a->floor();
 
         $expected = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
@@ -2803,9 +2803,9 @@ public function ceil() : void
         $b = $a->ceil();
 
         $expected = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
@@ -2887,9 +2887,9 @@ public function clip() : void
         $b = $a->clip(0.0, INF);
 
         $expected = Matrix::fromArray([
-            [22, 0.0, 12],
-            [4, 11, 0.],
-            [20, 0.0, 0.],
+            [22.0, 0.0, 12.0],
+            [4.0, 11.0, 0.],
+            [20.0, 0.0, 0.],
         ]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
@@ -2909,9 +2909,9 @@ public function clipLower() : void
         $b = $a->clipLower(5.);
 
         $expected = Matrix::fromArray([
-            [22, 5.0, 12],
-            [5.0, 11, 5.],
-            [20, 5.0, 5.],
+            [22.0, 5.0, 12.0],
+            [5.0, 11.0, 5.],
+            [20.0, 5.0, 5.],
         ]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
@@ -2931,9 +2931,9 @@ public function clipUpper() : void
         $b = $a->clipUpper(16.0);
 
         $expected = Matrix::fromArray([
-            [16.0, -17.0, 12],
-            [4, 11, -2.0],
-            [16, -6.0, -9.0],
+            [16.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [16.0, -6.0, -9.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
@@ -2953,9 +2953,9 @@ public function sign() : void
         $b = $a->sign();
 
         $expected = Matrix::fromArray([
-            [1, -1, 1],
-            [1, 1, -1],
-            [1, -1, -1],
+            [1.0, -1.0, 1.0],
+            [1.0, 1.0, -1.0],
+            [1.0, -1.0, -1.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
@@ -2975,9 +2975,9 @@ public function negate() : void
         $b = $a->negate();
 
         $expected = Matrix::fromArray([
-            [-22, 17, -12],
-            [-4, -11, 2],
-            [-20, 6, 9],
+            [-22.0, 17.0, -12.0],
+            [-4.0, -11.0, 2.0],
+            [-20.0, 6.0, 9.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
@@ -2995,20 +2995,20 @@ public function augmentAbove() : void
         ]);
 
         $b = Matrix::fromArray([
-            [4, 6, -12],
-            [1, 3, 5],
-            [-10, -1, 14],
+            [4.0, 6.0, -12.0],
+            [1.0, 3.0, 5.0],
+            [-10.0, -1.0, 14.0],
         ]);
 
         $c = $a->augmentAbove($b);
 
         $expected = Matrix::fromArray([
-            [4, 6, -12],
-            [1, 3, 5],
-            [-10, -1, 14],
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
+            [4.0, 6.0, -12.0],
+            [1.0, 3.0, 5.0],
+            [-10.0, -1.0, 14.0],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
@@ -3026,20 +3026,20 @@ public function augmentBelow() : void
         ]);
 
         $b = Matrix::fromArray([
-            [4, 6, -12],
-            [1, 3, 5],
-            [-10, -1, 14],
+            [4.0, 6.0, -12.0],
+            [1.0, 3.0, 5.0],
+            [-10.0, -1.0, 14.0],
         ]);
 
         $c = $a->augmentBelow($b);
 
         $expected = Matrix::fromArray([
-            [22, -17, 12],
-            [4, 11, -2],
-            [20, -6, -9],
-            [4, 6, -12],
-            [1, 3, 5],
-            [-10, -1, 14],
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
+            [4.0, 6.0, -12.0],
+            [1.0, 3.0, 5.0],
+            [-10.0, -1.0, 14.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
@@ -3057,17 +3057,17 @@ public function augmentLeft() : void
         ]);
 
         $b = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $c = $a->augmentLeft($b);
 
         $expected = Matrix::fromArray([
-            [13, 22, -17, 12],
-            [11, 4, 11, -2],
-            [9, 20, -6, -9],
+            [13.0, 22.0, -17.0, 12.0],
+            [11.0, 4.0, 11.0, -2.0],
+            [9.0, 20.0, -6.0, -9.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
@@ -3085,17 +3085,17 @@ public function augmentRight() : void
         ]);
 
         $b = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $c = $a->augmentRight($b);
 
         $expected = Matrix::fromArray([
-            [22, -17, 12, 13],
-            [4, 11, -2, 11],
-            [20, -6, -9, 9],
+            [22.0, -17.0, 12.0, 13.0],
+            [4.0, 11.0, -2.0, 11.0],
+            [20.0, -6.0, -9.0, 9.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $c->asArray());
@@ -3107,20 +3107,20 @@ public function augmentRight() : void
     public function repeat() : void
     {
         $a = Matrix::fromArray([
-            [13],
-            [11],
-            [9],
+            [13.0],
+            [11.0],
+            [9.0],
         ]);
 
         $b = $a->repeat(1, 3);
 
         $expected = Matrix::fromArray([
-            [13, 13, 13, 13],
-            [11, 11, 11, 11],
-            [9, 9, 9, 9],
-            [13, 13, 13, 13],
-            [11, 11, 11, 11],
-            [9, 9, 9, 9],
+            [13.0, 13.0, 13.0, 13.0],
+            [11.0, 11.0, 11.0, 11.0],
+            [9.0, 9.0, 9.0, 9.0],
+            [13.0, 13.0, 13.0, 13.0],
+            [11.0, 11.0, 11.0, 11.0],
+            [9.0, 9.0, 9.0, 9.0],
         ]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index 4f87f7f..1357514 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -36,7 +36,7 @@ class VectorTest extends TestCase
      */
     public function build() : void
     {
-        $vector = Vector::fromArray([1, 2, 3, 4, 5]);
+        $vector = Vector::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]);
 
         $this->assertInstanceOf(Vector::class, $vector);
         $this->assertInstanceOf(Tensor::class, $vector);
@@ -54,7 +54,7 @@ public function build() : void
      */
     public function buildCastsIntegersToFloats() : void
     {
-        $vector = Vector::fromArray([1, 2, 3, 4, 5]);
+        $vector = Vector::fromArray([1.0, 2.0, 3.0, 4.0, 5.0]);
 
         $this->assertSame(5, $vector->size());
 
@@ -76,7 +76,7 @@ public function zeros() : void
     {
         $zeros = Vector::zeros(4);
 
-        $expected = Vector::fromArray([0, 0, 0, 0]);
+        $expected = Vector::fromArray([0.0, 0.0, 0.0, 0.0]);
 
         $this->assertEquals($expected->asArray(), $zeros->asArray());
     }
@@ -88,7 +88,7 @@ public function ones() : void
     {
         $ones = Vector::ones(4);
 
-        $expected = Vector::fromArray([1, 1, 1, 1]);
+        $expected = Vector::fromArray([1.0, 1.0, 1.0, 1.0]);
 
         $this->assertEquals($expected->asArray(), $ones->asArray());
     }
@@ -98,9 +98,9 @@ public function ones() : void
      */
     public function fill() : void
     {
-        $vector = Vector::fill(16, 4);
+        $vector = Vector::fill(16.0, 4);
 
-        $expected = Vector::fromArray([16, 16, 16, 16]);
+        $expected = Vector::fromArray([16.0, 16.0, 16.0, 16.0]);
 
         $this->assertEquals($expected->asArray(), $vector->asArray());
     }
@@ -470,7 +470,7 @@ public function map() : void
 
         $vector = $vector->map($sign);
 
-        $expected = Vector::fromArray([0, 1, 1, 0, 0, 1, 1, 1]);
+        $expected = Vector::fromArray([0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0]);
 
         $this->assertEquals($expected->asArray(), $vector->asArray());
     }
@@ -674,7 +674,7 @@ public function multiplyProvider() : Generator
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, -0.001],
+                [1.1, 5.0, -5.0, 30.0, -0.005, -0.001],
             ]),
             Matrix::fromArray([
                 [24.92, -6.5, 0.087, -0.2, -1.3, 23.8],
@@ -721,7 +721,7 @@ public function divideProvider() : Generator
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, -0.001],
+                [1.1, 5.0, -5.0, 30.0, -0.005, -0.001],
             ]),
             Matrix::fromArray([
                 [0.6420545746388443, -6.5, 96.66666666666667, -2000.0, -5.2, 5.95],
@@ -739,7 +739,7 @@ public function divideProvider() : Generator
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             2.0,
-            Vector::fromArray([-7.5, 12.5, 17.5, -18.0, -36.0, 44.5, 53, 22.5]),
+            Vector::fromArray([-7.5, 12.5, 17.5, -18.0, -36.0, 44.5, 53.0, 22.5]),
         ];
     }
 
@@ -768,7 +768,7 @@ public function addProvider() : Generator
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, -0.001],
+                [1.1, 5.0, -5.0, 30.0, -0.005, -0.001],
             ]),
             Matrix::fromArray([
                 [10.23, 5.5, 2.9299999999999997, 19.99, 2.1, 13.9],
@@ -815,7 +815,7 @@ public function subtractProvider() : Generator
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, -0.001],
+                [1.1, 5.0, -5.0, 30.0, -0.005, -0.001],
             ]),
             Matrix::fromArray([
                 [-2.2300000000000004, 7.5, 2.87, 20.01, 3.1, 9.9],
@@ -862,7 +862,7 @@ public function powProvider() : Generator
             Matrix::fromArray([
                 [6.23, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 0.02, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, -0.001],
+                [1.1, 5.0, -5.0, 30.0, -0.005, -0.001],
             ]),
             Matrix::fromArray([
                 [5634.219287100394, 0.15384615384615385, 1.0324569211337775, 0.9704869503929601, 0.6201736729460423, 141.61],
@@ -881,7 +881,7 @@ public function powProvider() : Generator
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             4.0,
             Vector::fromArray([
-                50625, 390625, 1500625, 1679616, 26873856, 62742241, 126247696, 4100625
+                50625.0, 390625.0, 1500625.0, 1679616.0, 26873856.0, 62742241.0, 126247696.0, 4100625.0
             ]),
         ];
     }
@@ -911,25 +911,25 @@ public function equalProvider() : Generator
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, 11.9],
+                [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
             ]),
             Matrix::fromArray([
-                [1, 0, 0, 0, 0, 0],
-                [0, 0, 0, 1, 0, 0],
-                [0, 0, 0, 0, 0, 1],
+                [1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
             ]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::fromArray([0, 0, 0, 1, 0, 0, 0, 0]),
+            Vector::fromArray([0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::fromArray([0, 1, 0, 0, 0, 0, 0, 0]),
+            Vector::fromArray([0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
         ];
     }
 
@@ -958,25 +958,25 @@ public function notEqualProvider() : Generator
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, 11.9],
+                [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
             ]),
             Matrix::fromArray([
-                [0, 1, 1, 1, 1, 1],
-                [1, 1, 1, 0, 1, 1],
-                [1, 1, 1, 1, 1, 0],
+                [0.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0, 0.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0, 1.0, 1.0, 0.0],
             ]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::fromArray([1, 1, 1, 0, 1, 1, 1, 1]),
+            Vector::fromArray([1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::fromArray([1, 0, 1, 1, 1, 1, 1, 1]),
+            Vector::fromArray([1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]),
         ];
     }
 
@@ -1022,25 +1022,25 @@ public function greaterProvider() : Generator
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, 11.9],
+                [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
             ]),
             Matrix::fromArray([
-                [0, 1, 1, 1, 1, 1],
-                [1, 1, 1, 0, 1, 1],
-                [1, 1, 1, 0, 1, 0],
+                [0.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0, 0.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0, 0.0, 1.0, 0.0],
             ]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::fromArray([0, 1, 1, 0, 0, 1, 1, 1]),
+            Vector::fromArray([0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             1.0,
-            Vector::fromArray([0, 1, 1, 0, 0, 1, 1, 1]),
+            Vector::fromArray([0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0]),
         ];
     }
 
@@ -1069,25 +1069,25 @@ public function greaterEqualProvider() : Generator
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, 11.9],
+                [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
             ]),
             Matrix::fromArray([
-                [1, 1, 1, 1, 1, 1],
-                [1, 1, 1, 1, 1, 1],
-                [1, 1, 1, 0, 1, 1],
+                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0, 0.0, 1.0, 1.0],
             ]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::fromArray([0, 1, 1, 1, 0, 1, 1, 1]),
+            Vector::fromArray([0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::fromArray([0, 1, 1, 0, 0, 1, 1, 1]),
+            Vector::fromArray([0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0]),
         ];
     }
 
@@ -1116,25 +1116,25 @@ public function lessProvider() : Generator
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, 11.9],
+                [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
             ]),
             Matrix::fromArray([
-                [0, 0, 0, 0, 0, 0],
-                [0, 0, 0, 0, 0, 0],
-                [0, 0, 0, 1, 0, 0],
+                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
             ]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::fromArray([1, 0, 0, 0, 1, 0, 0, 0]),
+            Vector::fromArray([1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::fromArray([1, 0, 0, 1, 1, 0, 0, 0]),
+            Vector::fromArray([1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0]),
         ];
     }
 
@@ -1163,12 +1163,12 @@ public function lessEqualProvider() : Generator
             Matrix::fromArray([
                 [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
                 [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
-                [1.1, 5.0, -5.0, 30, -0.005, 11.9],
+                [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
             ]),
             Matrix::fromArray([
-                [1, 0, 0, 0, 0, 0],
-                [0, 0, 0, 1, 0, 0],
-                [0, 0, 0, 1, 0, 1],
+                [1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0, 0.0, 1.0],
             ]),
 
         ];
@@ -1176,13 +1176,13 @@ public function lessEqualProvider() : Generator
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             Vector::fromArray([0.25, 0.1, 2.0, -36.0, -1.0, -3.0, 3.3, 2.0]),
-            Vector::fromArray([1, 0, 0, 1, 1, 0, 0, 0]),
+            Vector::fromArray([1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0]),
         ];
 
         yield [
             Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]),
             25.0,
-            Vector::fromArray([1, 1, 0, 1, 1, 0, 0, 0]),
+            Vector::fromArray([1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0]),
         ];
     }
 
@@ -1254,7 +1254,7 @@ public function pow() : void
     {
         $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = $a->pow(3);
+        $b = $a->pow(3.0);
 
         $expected = Vector::fromArray([-3375.0, 15625.0, 42875.0, -46656.0, -373248.0, 704969.0, 1191016.0, 91125.0]);
 
@@ -1473,7 +1473,7 @@ public function min() : void
     {
         $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $this->assertEquals(-72, $a->min());
+        $this->assertEquals(-72.0, $a->min());
     }
 
     /**
@@ -1483,7 +1483,7 @@ public function max() : void
     {
         $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $this->assertEquals(106, $a->max());
+        $this->assertEquals(106.0, $a->max());
     }
 
     /**
@@ -1623,9 +1623,9 @@ public function clip() : void
     {
         $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
 
-        $b = $a->clip(0.0, 100);
+        $b = $a->clip(0.0, 100.0);
 
-        $expected = Vector::fromArray([0.0, 25, 35, 0.0, 0.0, 89, 100.0, 45]);
+        $expected = Vector::fromArray([0.0, 25.0, 35.0, 0.0, 0.0, 89.0, 100.0, 45.0]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
     }
@@ -1639,7 +1639,7 @@ public function clipLower() : void
 
         $b = $a->clipLower(60.0);
 
-        $expected = Vector::fromArray([60.0, 60.0, 60.0, 60.0, 60.0, 89, 106.0, 60.0]);
+        $expected = Vector::fromArray([60.0, 60.0, 60.0, 60.0, 60.0, 89.0, 106.0, 60.0]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
     }
@@ -1653,7 +1653,7 @@ public function clipUpper() : void
 
         $b = $a->clipUpper(50.0);
 
-        $expected = Vector::fromArray([-15.0, 25, 35, -36.0, -72.0, 50.0, 50.0, 45]);
+        $expected = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 50.0, 50.0, 45.0]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
     }
@@ -1667,7 +1667,7 @@ public function sign() : void
 
         $b = $a->sign();
 
-        $expected = Vector::fromArray([-1, 1, 1, -1, -1, 1, 1, 1]);
+        $expected = Vector::fromArray([-1.0, 1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
     }
@@ -1681,7 +1681,7 @@ public function negate() : void
 
         $b = $a->negate();
 
-        $expected = Vector::fromArray([15, -25, -35, 36, 72, -89, -106, -45]);
+        $expected = Vector::fromArray([15.0, -25.0, -35.0, 36.0, 72.0, -89.0, -106.0, -45.0]);
 
         $this->assertEquals($expected->asArray(), $b->asArray());
     }

From 74caee5b70d1fc1bdb2408776fc1530669d4e5dd Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 17:54:25 -0500
Subject: [PATCH 30/51] Add test

---
 tests/VectorTest.php | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index 1357514..98bfedf 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -533,6 +533,9 @@ public function dot() : void
         $this->assertEqualsWithDelta(331.54999999999995, $c, self::MAX_DELTA);
     }
 
+    /**
+     * @test
+     */
     public function matmul() : void
     {
         $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);

From 455f425314141a155ad820b29c157ab2e8490c7f Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 17:59:20 -0500
Subject: [PATCH 31/51] Add headers

---
 ext/include/arithmetic.h | 7 +++++++
 ext/include/comparison.h | 7 +++++++
 2 files changed, 14 insertions(+)

diff --git a/ext/include/arithmetic.h b/ext/include/arithmetic.h
index 0351042..01a7784 100644
--- a/ext/include/arithmetic.h
+++ b/ext/include/arithmetic.h
@@ -28,4 +28,11 @@ void tensor_pow_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_mod_col(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_mod_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
 
+void tensor_multiply_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_add_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_divide_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_subtract_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_pow_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_mod_row(zval * return_value, zval * a, zval * b, zval * n);
+
 #endif
diff --git a/ext/include/comparison.h b/ext/include/comparison.h
index 34ff116..485bef3 100644
--- a/ext/include/comparison.h
+++ b/ext/include/comparison.h
@@ -28,4 +28,11 @@ void tensor_less_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_less_equal_col(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_less_equal_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
 
+void tensor_equal_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_not_equal_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_greater_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_greater_equal_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_less_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_less_equal_row(zval * return_value, zval * a, zval * b, zval * n);
+
 #endif
\ No newline at end of file

From f142b64455f7ce1abf09468567dad90eb32112a1 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 18:04:54 -0500
Subject: [PATCH 32/51] Plug memory leak

---
 ext/include/linear_algebra.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/ext/include/linear_algebra.c b/ext/include/linear_algebra.c
index b9867c5..7d80095 100644
--- a/ext/include/linear_algebra.c
+++ b/ext/include/linear_algebra.c
@@ -589,6 +589,8 @@ void tensor_lu(zval * return_value, zval * a, zval * n)
     zval_ptr_dtor(&bufL);
 
     if (UNEXPECTED(tensor_tensorbuffer_create(&u, (zend_long) na * na, &bufU) == FAILURE)) {
+        zval_ptr_dtor(&l);
+        
         efree(perm);
         efree(lbuf);
         efree(ubuf);
@@ -610,6 +612,9 @@ void tensor_lu(zval * return_value, zval * a, zval * n)
     zval_ptr_dtor(&bufU);
 
     if (UNEXPECTED(tensor_tensorbuffer_create(&p, (zend_long) na * na, &bufP) == FAILURE)) {
+        zval_ptr_dtor(&l);
+        zval_ptr_dtor(&u);
+
         efree(perm);
         efree(lbuf);
         efree(ubuf);
@@ -703,6 +708,8 @@ void tensor_eig(zval * return_value, zval * a, zval * n)
     zval eigenvectors, buf;
 
     if (UNEXPECTED(tensor_tensorbuffer_create(&eigenvectors, (zend_long) na * na, &buf) == FAILURE)) {
+        zval_ptr_dtor(&eigenvalues);
+
         efree(w);
         efree(wr);
         efree(wi);
@@ -789,6 +796,8 @@ void tensor_eig_symmetric(zval * return_value, zval * a, zval * n)
     zval eigenvectors, buf;
 
     if (UNEXPECTED(tensor_tensorbuffer_create(&eigenvectors, (zend_long) na * na, &buf) == FAILURE)) {
+        zval_ptr_dtor(&eigenvalues);
+
         efree(w);
         efree(wr);
 
@@ -898,6 +907,9 @@ void tensor_svd(zval * return_value, zval * a, zval * m, zval * n)
     zval vt, bufVt;
 
     if (UNEXPECTED(tensor_tensorbuffer_create(&vt, (zend_long) na * na, &bufVt) == FAILURE)) {
+        zval_ptr_dtor(&u);
+        zval_ptr_dtor(&s);
+
         efree(w);
         efree(vu);
         efree(vs);

From ea49f191b532459391528ce6ae4e94dbd3b74b31 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 18:08:05 -0500
Subject: [PATCH 33/51] Will write later

---
 CHANGELOG.md                 |  7 +------
 ext/include/linear_algebra.c |  6 ++++++
 tests/MatrixTest.php         | 12 ++++++++++++
 3 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2059677..69e0f62 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,12 +1,7 @@
 # Change Log
 
 - 4.0.0
-    - Performance: the linear algebra operations (REF, RREF, Cholesky, LU, eigendecomposition, SVD), `rank()`, `symmetric()`, and the vector `outer()` product now read their input from, and return their output into, `TensorBuffer`s directly instead of round-tripping through PHP arrays, eliminating the intermediate array copies
-    - Breaking: removed the `Vector::build()`, `Vector::quick()`, `Vector::fromTensorBuffer()`, `Matrix::build()`, `Matrix::quick()`, `Matrix::fromTensorBuffer()`, and `ColumnVector::build()`, `ColumnVector::quick()`, and `ColumnVector::fromTensorBuffer()` factory methods. Build a `Vector` / `ColumnVector` with `Vector::fromArray(...)` / `ColumnVector::fromArray(...)` (or `new Vector(...)` / `new ColumnVector(...)` from a `TensorBuffer`), or a `Matrix` with `Matrix::fromArray(...)` (or `new Matrix(...)` from a `TensorBuffer`)
-    - Breaking: `Vector::__construct()` no longer accepts a `validate` argument or a PHP array; it now takes a `TensorBuffer` only. To build from an array use the new `Vector::fromArray(array $a, bool $validate = true)` static factory (inherited by `ColumnVector`)
-    - Added `Vector::fromArray(array $a, bool $validate = true)` (inherited by `ColumnVector`) mirroring `Matrix::fromArray(...)`
-    - Breaking: removed the `Matrix::fromTensorBuffers()` factory method in favor of the new `TensorBuffer::fromBuffers()` factory, which concatenates an array of `TensorBuffer`s into a single contiguous buffer
-
+    
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
     - Implemented the Moore-Penrose pseudoinverse in the extension via SVD
diff --git a/ext/include/linear_algebra.c b/ext/include/linear_algebra.c
index 7d80095..49828c0 100644
--- a/ext/include/linear_algebra.c
+++ b/ext/include/linear_algebra.c
@@ -1198,6 +1198,12 @@ void tensor_is_symmetric(zval * return_value, zval * a, zval * n)
         return;
     }
 
+    if (na < 2) {
+        RETVAL_TRUE;
+
+        return;
+    }
+
     for (i = 0; i < na - 1; ++i) {
         for (j = i + 1; j < na; ++j) {
             if (va[i * na + j] != va[j * na + i]) {
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index b69a073..fb03ad2 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -685,6 +685,18 @@ public function symmetricProvider() : Generator
             ]),
             true,
         ];
+
+        yield [
+            Matrix::fromArray([]),
+            true,
+        ];
+
+        yield [
+            Matrix::fromArray([
+                [5.0],
+            ]),
+            true,
+        ];
     }
 
     /**

From f41f7ec9e5e362b5f8e3b508560b7a1de1bc6b67 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 18:43:54 -0500
Subject: [PATCH 34/51] Fix map bug

---
 CHANGELOG.md                  |  3 ++
 ext/tensor/tensorbuffer.zep.c | 86 ++++++++---------------------------
 tensor/tensorbuffer.zep       | 14 ++----
 tests/MatrixTest.php          | 65 ++++++++++++++++++++++++++
 tests/TensorBufferTest.php    | 26 +++++++++++
 5 files changed, 118 insertions(+), 76 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 69e0f62..47326d8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Change Log
 
+- 4.0.1
+    - Fixed a segfault in `Matrix::map()` / `TensorBuffer::map()` when the callback was an array callable of the form `[instance, 'method']` on an operation with more than one element. `map()` now dispatches the callback through PHP's native `array_map()` (matching `Vector::map()`) instead of the Zephir dynamic user-callback loop that mis-resolved instance methods after the first element was cached
+
 - 4.0.0
     
 - 3.1.0
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 21b4dc4..9a3595e 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -93,7 +93,7 @@ PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
 	if (UNEXPECTED(rows == 1)) {
 		object_init_ex(return_value, tensor_tensorbuffer_ce);
 		zephir_memory_observe(&_1$$4);
-		zephir_array_fetch_long(&_1$$4, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 43);
+		zephir_array_fetch_long(&_1$$4, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 44);
 		ZEPHIR_CALL_METHOD(&_2$$4, &_1$$4, "asBuffer", NULL, 0);
 		zephir_check_call_status();
 		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_2$$4);
@@ -101,7 +101,7 @@ PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
 		RETURN_MM();
 	}
 	zephir_memory_observe(&_3);
-	zephir_array_fetch_long(&_3, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 46);
+	zephir_array_fetch_long(&_3, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 47);
 	ZVAL_LONG(&_4, 1);
 	ZEPHIR_CALL_FUNCTION(&_5, "array_slice", NULL, 29, &buffers, &_4);
 	zephir_check_call_status();
@@ -190,7 +190,7 @@ PHP_METHOD(Tensor_TensorBuffer, get)
 	zephir_fetch_params(1, 1, 0, &index_param);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
 	zephir_memory_observe(&_1);
-	zephir_array_fetch_long(&_1, &_0, index, PH_NOISY, "tensor/tensorbuffer.zep", 77);
+	zephir_array_fetch_long(&_1, &_0, index, PH_NOISY, "tensor/tensorbuffer.zep", 78);
 	RETURN_CCTOR(&_1);
 }
 
@@ -321,7 +321,7 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 		ZEPHIR_CONCAT_SS(&_5$$3, "Offset and length", " must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 115);
+		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 116);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -346,23 +346,16 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
  */
 PHP_METHOD(Tensor_TensorBuffer, map)
 {
-	zend_bool _6;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *callback, callback_sub, value, a, _0, *_1, _2, *_3, _5, buffer, _4$$3, _7$$4;
+	zval *callback, callback_sub, b, _0, _1, buffer;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&callback_sub);
-	ZVAL_UNDEF(&value);
-	ZVAL_UNDEF(&a);
+	ZVAL_UNDEF(&b);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
@@ -374,52 +367,11 @@ PHP_METHOD(Tensor_TensorBuffer, map)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &callback);
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_0, "toArray", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_FUNCTION(&b, "array_map", NULL, 16, callback, &_1);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&a) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_2);
-		zephir_string_to_char_array(&_2, &a);
-		_1 = &_2;
-	} else {
-		_1 = &a;
-	}
-	zephir_is_iterable(_1, 0, "tensor/tensorbuffer.zep", 143);
-	if (Z_TYPE_P(_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _3)
-		{
-			ZEPHIR_INIT_NVAR(&value);
-			ZVAL_COPY(&value, _3);
-			ZEPHIR_CALL_ZVAL_FUNCTION(&_4$$3, callback, NULL, 0, &value);
-			zephir_check_call_status();
-			zephir_array_append(&b, &_4$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 140);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_6 = 1;
-		while (1) {
-			if (_6) {
-				_6 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_5, _1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_5)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&value, _1, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_CALL_ZVAL_FUNCTION(&_7$$4, callback, NULL, 0, &value);
-				zephir_check_call_status();
-				zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 140);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&value);
 	ZEPHIR_INIT_VAR(&buffer);
 	tensor_buffer_from_array(&buffer, &b);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
@@ -651,7 +603,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 		ZEPHIR_CONCAT_SS(&_8$$10, "Offset, length, and", " stride must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$10, "__construct", NULL, 2, &_8$$10);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$10, "tensor/tensorbuffer.zep", 260);
+		zephir_throw_exception_debug(&_7$$10, "tensor/tensorbuffer.zep", 253);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -705,7 +657,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_get_arrval(&buffers, buffers_param);
 	ZEPHIR_INIT_VAR(&unwrapped);
 	array_init(&unwrapped);
-	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 285);
+	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 278);
 	if (Z_TYPE_P(&buffers) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&buffers), _0)
 		{
@@ -713,7 +665,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			ZVAL_COPY(&buffer, _0);
 			ZEPHIR_CALL_METHOD(&_1$$3, &buffer, "asBuffer", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 282);
+			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 275);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, &buffers, "rewind", NULL, 0);
@@ -735,7 +687,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_4$$4, &buffer, "asBuffer", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 282);
+				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 275);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -800,7 +752,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Chunk length must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 302);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 295);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -817,7 +769,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 	} else {
 		_6 = &buffers;
 	}
-	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 315);
+	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 308);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -827,7 +779,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 13, &buffer);
 			zephir_check_call_status();
-			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 312);
+			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 305);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -851,7 +803,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 13, &buffer);
 				zephir_check_call_status();
-				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 312);
+				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 305);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -901,7 +853,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Times must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 330);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 323);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/tensor/tensorbuffer.zep b/tensor/tensorbuffer.zep
index 8a49230..b7de142 100644
--- a/tensor/tensorbuffer.zep
+++ b/tensor/tensorbuffer.zep
@@ -36,6 +36,7 @@ class TensorBuffer
 
         if unlikely rows < 1 {
             var zero = tensor_buffer_from_array([]);
+
             return new self(<Buffer> zero);
         }
 
@@ -130,15 +131,7 @@ class TensorBuffer
      */
     public function map(const var callback) -> <TensorBuffer>
     {
-        var value;
-
-        array b = [];
-
-        var a = this->buffer->toArray();
-
-        for value in a {
-            let b[] = {callback}(value);
-        }
+        var b = array_map(callback, this->buffer->toArray());
 
         var buffer = tensor_buffer_from_array(b);
 
@@ -229,6 +222,7 @@ class TensorBuffer
 
             if likely !invalid {
                 let a = length - 1;
+                
                 let acc = stride;
 
                 while a > 0 {
@@ -237,6 +231,7 @@ class TensorBuffer
 
                         if product > limit {
                             let invalid = true;
+
                             break;
                         }
                     }
@@ -246,6 +241,7 @@ class TensorBuffer
                     if a > 0 {
                         if acc > (limit >> 1) {
                             let invalid = true;
+
                             break;
                         }
 
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index fb03ad2..de0ca83 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -528,6 +528,71 @@ public function transpose() : void
         $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
+    /**
+     * Regression test: passing an array callable [instance, 'method'] to
+     * Matrix::map() must not segfault. The previous Zephir dynamic
+     * user-callback dispatch inside TensorBuffer::map() was triggered only
+     * for arrays holding a non-static instance and crashed on the second
+     * and later elements.
+     *
+     * @test
+     */
+    public function mapWithInstanceArrayCallable() : void
+    {
+        $helper = new class() {
+            public float $slope = 0.1;
+
+            public function activate(float $v) : float
+            {
+                return $v > 0.0 ? $v : $v * $this->slope;
+            }
+        };
+
+        $a = Matrix::fromArray([
+            [1.0, -2.0],
+            [-3.0, 4.0],
+        ]);
+
+        $b = $a->map([$helper, 'activate']);
+
+        $expected = Matrix::fromArray([
+            [1.0, -0.2],
+            [-0.3, 4.0],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * A static array callable [Class::class, 'method'] must also work on
+     * Matrix::map() over a multi-element matrix.
+     *
+     * @test
+     */
+    public function mapWithStaticArrayCallable() : void
+    {
+        $a = Matrix::fromArray([
+            [7.0, -2.5],
+            [-3.0, 4.25],
+        ]);
+
+        $helper = new class() {
+            public static function square(float $v) : float
+            {
+                return $v * $v;
+            }
+        };
+
+        $b = $a->map([get_class($helper), 'square']);
+
+        $expected = Matrix::fromArray([
+            [49.0, 6.25],
+            [9.0, 18.0625],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
+    }
+
     /**
      * @test
      */
diff --git a/tests/TensorBufferTest.php b/tests/TensorBufferTest.php
index 987c5ea..78c6864 100644
--- a/tests/TensorBufferTest.php
+++ b/tests/TensorBufferTest.php
@@ -227,6 +227,32 @@ public function map() : void
         $this->assertEqualsWithDelta([1.0, 2.0, 3.0], $decorator->toArray(), self::MAX_DELTA);
     }
 
+    /**
+     * Regression test: mapping a decorator with an array callable
+     * [instance, 'method'] over a multi-element buffer must not segfault.
+     *
+     * @test
+     */
+    public function mapWithInstanceArrayCallable() : void
+    {
+        $decorator = new TensorBuffer(Buffer::fromArray([1.0, -2.0, -3.0, 4.0]));
+
+        $helper = new class() {
+            public float $slope = 0.5;
+
+            public function activate(float $value) : float
+            {
+                return $value > 0.0 ? $value : $value * $this->slope;
+            }
+        };
+
+        $mapped = $decorator->map([$helper, 'activate']);
+
+        $this->assertInstanceOf(TensorBuffer::class, $mapped);
+        $this->assertNotSame($decorator->asBuffer(), $mapped->asBuffer());
+        $this->assertEqualsWithDelta([1.0, -1.0, -1.5, 4.0], $mapped->toArray(), self::MAX_DELTA);
+    }
+
     /**
      * @test
      */

From fe321124ee7120f7891caa8628dabf19f8d256eb Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 19:21:48 -0500
Subject: [PATCH 35/51] Fix clobber

---
 ext/tensor/matrix.zep.c       | 152 ++++++++++++++++------------------
 ext/tensor/tensorbuffer.zep.c |  18 ++--
 ext/tensor/vector.zep.c       |  60 ++++++--------
 tensor/matrix.zep             |   2 +-
 tensor/vector.zep             |   2 +-
 5 files changed, 108 insertions(+), 126 deletions(-)

diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 1f9c6a6..dc88a74 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -884,12 +884,12 @@ PHP_METHOD(Tensor_Matrix, uniform)
  */
 PHP_METHOD(Tensor_Matrix, fromArray)
 {
-	zval _6$$4, _10$$6, _28$$11;
+	zval _6$$4, _10$$6, _26$$11;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_2 = NULL, *_14 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, rows;
-	zend_bool validate, _25, _8$$5, _11$$5, _22$$5, _26$$10, _29$$10, _39$$10;
-	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, *_7, _24, buffer, _41, _42, buffer$$3, _0$$3, _1$$3, _3$$3, _4$$3, _5$$4, *_17$$5, _18$$5, *_19$$5, _21$$5, _9$$6, _12$$7, _13$$7, _15$$7, _16$$7, _20$$8, _23$$9, *_34$$10, _35$$10, *_36$$10, _38$$10, _27$$11, _30$$12, _31$$12, _32$$12, _33$$12, _37$$13, _40$$14;
+	zend_bool validate, _23, _8$$5, _11$$5, _21$$5, _24$$10, _27$$10, _36$$10;
+	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, *_7, _22, buffer, _37, _38, buffer$$3, _0$$3, _1$$3, _3$$3, _4$$3, _5$$4, *_17$$5, _18$$5, *_19$$5, _20$$5, _9$$6, _12$$7, _13$$7, _15$$7, _16$$7, *_32$$10, _33$$10, *_34$$10, _35$$10, _25$$11, _28$$12, _29$$12, _30$$12, _31$$12;
 	zval a, flat;
 
 	ZVAL_UNDEF(&a);
@@ -898,10 +898,10 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&firstRow);
 	ZVAL_UNDEF(&n);
-	ZVAL_UNDEF(&_24);
+	ZVAL_UNDEF(&_22);
 	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_41);
-	ZVAL_UNDEF(&_42);
+	ZVAL_UNDEF(&_37);
+	ZVAL_UNDEF(&_38);
 	ZVAL_UNDEF(&buffer$$3);
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&_1$$3);
@@ -909,26 +909,22 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$4);
 	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_21$$5);
+	ZVAL_UNDEF(&_20$$5);
 	ZVAL_UNDEF(&_9$$6);
 	ZVAL_UNDEF(&_12$$7);
 	ZVAL_UNDEF(&_13$$7);
 	ZVAL_UNDEF(&_15$$7);
 	ZVAL_UNDEF(&_16$$7);
-	ZVAL_UNDEF(&_20$$8);
-	ZVAL_UNDEF(&_23$$9);
+	ZVAL_UNDEF(&_33$$10);
 	ZVAL_UNDEF(&_35$$10);
-	ZVAL_UNDEF(&_38$$10);
-	ZVAL_UNDEF(&_27$$11);
+	ZVAL_UNDEF(&_25$$11);
+	ZVAL_UNDEF(&_28$$12);
+	ZVAL_UNDEF(&_29$$12);
 	ZVAL_UNDEF(&_30$$12);
 	ZVAL_UNDEF(&_31$$12);
-	ZVAL_UNDEF(&_32$$12);
-	ZVAL_UNDEF(&_33$$12);
-	ZVAL_UNDEF(&_37$$13);
-	ZVAL_UNDEF(&_40$$14);
 	ZVAL_UNDEF(&_6$$4);
 	ZVAL_UNDEF(&_10$$6);
-	ZVAL_UNDEF(&_28$$11);
+	ZVAL_UNDEF(&_26$$11);
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
 		Z_PARAM_OPTIONAL
@@ -1029,31 +1025,27 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 				{
 					ZEPHIR_INIT_NVAR(&valueA);
 					ZVAL_COPY(&valueA, _19$$5);
-					ZEPHIR_INIT_NVAR(&_20$$8);
-					ZVAL_DOUBLE(&_20$$8, zephir_get_doubleval(&valueA));
-					zephir_array_append(&flat, &_20$$8, PH_SEPARATE, "tensor/matrix.zep", 397);
+					zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 397);
 				} ZEND_HASH_FOREACH_END();
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, _17$$5, "rewind", NULL, 0);
 				zephir_check_call_status();
-				_22$$5 = 1;
+				_21$$5 = 1;
 				while (1) {
-					if (_22$$5) {
-						_22$$5 = 0;
+					if (_21$$5) {
+						_21$$5 = 0;
 					} else {
 						ZEPHIR_CALL_METHOD(NULL, _17$$5, "next", NULL, 0);
 						zephir_check_call_status();
 					}
-					ZEPHIR_CALL_METHOD(&_21$$5, _17$$5, "valid", NULL, 0);
+					ZEPHIR_CALL_METHOD(&_20$$5, _17$$5, "valid", NULL, 0);
 					zephir_check_call_status();
-					if (!zend_is_true(&_21$$5)) {
+					if (!zend_is_true(&_20$$5)) {
 						break;
 					}
 					ZEPHIR_CALL_METHOD(&valueA, _17$$5, "current", NULL, 0);
 					zephir_check_call_status();
-						ZEPHIR_INIT_NVAR(&_23$$9);
-						ZVAL_DOUBLE(&_23$$9, zephir_get_doubleval(&valueA));
-						zephir_array_append(&flat, &_23$$9, PH_SEPARATE, "tensor/matrix.zep", 397);
+						zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 397);
 				}
 			}
 			ZEPHIR_INIT_NVAR(&valueA);
@@ -1061,93 +1053,89 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, &a, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_25 = 1;
+		_23 = 1;
 		while (1) {
-			if (_25) {
-				_25 = 0;
+			if (_23) {
+				_23 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, &a, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_24, &a, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_22, &a, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_24)) {
+			if (!zend_is_true(&_22)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&rowA, &a, "current", NULL, 0);
 			zephir_check_call_status();
-				_26$$10 = validate;
-				if (_26$$10) {
-					_26$$10 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
+				_24$$10 = validate;
+				if (_24$$10) {
+					_24$$10 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
 				}
-				if (UNEXPECTED(_26$$10)) {
-					ZEPHIR_INIT_NVAR(&_27$$11);
-					object_init_ex(&_27$$11, tensor_exceptions_invalidargumentexception_ce);
-					ZEPHIR_INIT_NVAR(&_28$$11);
-					ZEPHIR_CONCAT_SS(&_28$$11, "Matrix requires an", " array of arrays.");
-					ZEPHIR_CALL_METHOD(NULL, &_27$$11, "__construct", NULL, 2, &_28$$11);
+				if (UNEXPECTED(_24$$10)) {
+					ZEPHIR_INIT_NVAR(&_25$$11);
+					object_init_ex(&_25$$11, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_INIT_NVAR(&_26$$11);
+					ZEPHIR_CONCAT_SS(&_26$$11, "Matrix requires an", " array of arrays.");
+					ZEPHIR_CALL_METHOD(NULL, &_25$$11, "__construct", NULL, 2, &_26$$11);
 					zephir_check_call_status();
-					zephir_throw_exception_debug(&_27$$11, "tensor/matrix.zep", 387);
+					zephir_throw_exception_debug(&_25$$11, "tensor/matrix.zep", 387);
 					ZEPHIR_MM_RESTORE();
 					return;
 				}
-				_29$$10 = validate;
-				if (_29$$10) {
-					_29$$10 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
+				_27$$10 = validate;
+				if (_27$$10) {
+					_27$$10 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
 				}
-				if (UNEXPECTED(_29$$10)) {
-					ZEPHIR_INIT_NVAR(&_30$$12);
-					object_init_ex(&_30$$12, tensor_exceptions_invalidargumentexception_ce);
-					ZEPHIR_CALL_FUNCTION(&_31$$12, "strval", &_14, 3, &n);
+				if (UNEXPECTED(_27$$10)) {
+					ZEPHIR_INIT_NVAR(&_28$$12);
+					object_init_ex(&_28$$12, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_CALL_FUNCTION(&_29$$12, "strval", &_14, 3, &n);
 					zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&_32$$12);
-					ZVAL_LONG(&_32$$12, zephir_fast_count_int(&rowA));
-					ZEPHIR_INIT_NVAR(&_33$$12);
-					ZEPHIR_CONCAT_SSVSVS(&_33$$12, "The number of", " columns must be equal for all rows, ", &_31$$12, " needed but ", &_32$$12, " given.");
-					ZEPHIR_CALL_METHOD(NULL, &_30$$12, "__construct", NULL, 2, &_33$$12);
+					ZEPHIR_INIT_NVAR(&_30$$12);
+					ZVAL_LONG(&_30$$12, zephir_fast_count_int(&rowA));
+					ZEPHIR_INIT_NVAR(&_31$$12);
+					ZEPHIR_CONCAT_SSVSVS(&_31$$12, "The number of", " columns must be equal for all rows, ", &_29$$12, " needed but ", &_30$$12, " given.");
+					ZEPHIR_CALL_METHOD(NULL, &_28$$12, "__construct", NULL, 2, &_31$$12);
 					zephir_check_call_status();
-					zephir_throw_exception_debug(&_30$$12, "tensor/matrix.zep", 393);
+					zephir_throw_exception_debug(&_28$$12, "tensor/matrix.zep", 393);
 					ZEPHIR_MM_RESTORE();
 					return;
 				}
 				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_35$$10);
-					zephir_string_to_char_array(&_35$$10, &rowA);
-					_34$$10 = &_35$$10;
+					ZEPHIR_INIT_NVAR(&_33$$10);
+					zephir_string_to_char_array(&_33$$10, &rowA);
+					_32$$10 = &_33$$10;
 				} else {
-					_34$$10 = &rowA;
+					_32$$10 = &rowA;
 				}
-				zephir_is_iterable(_34$$10, 0, "tensor/matrix.zep", 399);
-				if (Z_TYPE_P(_34$$10) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_34$$10), _36$$10)
+				zephir_is_iterable(_32$$10, 0, "tensor/matrix.zep", 399);
+				if (Z_TYPE_P(_32$$10) == IS_ARRAY) {
+					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_32$$10), _34$$10)
 					{
 						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _36$$10);
-						ZEPHIR_INIT_NVAR(&_37$$13);
-						ZVAL_DOUBLE(&_37$$13, zephir_get_doubleval(&valueA));
-						zephir_array_append(&flat, &_37$$13, PH_SEPARATE, "tensor/matrix.zep", 397);
+						ZVAL_COPY(&valueA, _34$$10);
+						zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 397);
 					} ZEND_HASH_FOREACH_END();
 				} else {
-					ZEPHIR_CALL_METHOD(NULL, _34$$10, "rewind", NULL, 0);
+					ZEPHIR_CALL_METHOD(NULL, _32$$10, "rewind", NULL, 0);
 					zephir_check_call_status();
-					_39$$10 = 1;
+					_36$$10 = 1;
 					while (1) {
-						if (_39$$10) {
-							_39$$10 = 0;
+						if (_36$$10) {
+							_36$$10 = 0;
 						} else {
-							ZEPHIR_CALL_METHOD(NULL, _34$$10, "next", NULL, 0);
+							ZEPHIR_CALL_METHOD(NULL, _32$$10, "next", NULL, 0);
 							zephir_check_call_status();
 						}
-						ZEPHIR_CALL_METHOD(&_38$$10, _34$$10, "valid", NULL, 0);
+						ZEPHIR_CALL_METHOD(&_35$$10, _32$$10, "valid", NULL, 0);
 						zephir_check_call_status();
-						if (!zend_is_true(&_38$$10)) {
+						if (!zend_is_true(&_35$$10)) {
 							break;
 						}
-						ZEPHIR_CALL_METHOD(&valueA, _34$$10, "current", NULL, 0);
+						ZEPHIR_CALL_METHOD(&valueA, _32$$10, "current", NULL, 0);
 						zephir_check_call_status();
-							ZEPHIR_INIT_NVAR(&_40$$14);
-							ZVAL_DOUBLE(&_40$$14, zephir_get_doubleval(&valueA));
-							zephir_array_append(&flat, &_40$$14, PH_SEPARATE, "tensor/matrix.zep", 397);
+							zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 397);
 					}
 				}
 				ZEPHIR_INIT_NVAR(&valueA);
@@ -1157,12 +1145,12 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZEPHIR_INIT_VAR(&buffer);
 	tensor_buffer_from_array(&buffer, &flat);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_INIT_VAR(&_41);
-	object_init_ex(&_41, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, &_41, "__construct", &_2, 13, &buffer);
+	ZEPHIR_INIT_VAR(&_37);
+	object_init_ex(&_37, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, &_37, "__construct", &_2, 13, &buffer);
 	zephir_check_call_status();
-	ZVAL_LONG(&_42, rows);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_41, &_42, &n);
+	ZVAL_LONG(&_38, rows);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_37, &_38, &n);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 9a3595e..5c3b21f 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -603,7 +603,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 		ZEPHIR_CONCAT_SS(&_8$$10, "Offset, length, and", " stride must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$10, "__construct", NULL, 2, &_8$$10);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$10, "tensor/tensorbuffer.zep", 253);
+		zephir_throw_exception_debug(&_7$$10, "tensor/tensorbuffer.zep", 256);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -657,7 +657,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_get_arrval(&buffers, buffers_param);
 	ZEPHIR_INIT_VAR(&unwrapped);
 	array_init(&unwrapped);
-	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 278);
+	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 281);
 	if (Z_TYPE_P(&buffers) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&buffers), _0)
 		{
@@ -665,7 +665,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			ZVAL_COPY(&buffer, _0);
 			ZEPHIR_CALL_METHOD(&_1$$3, &buffer, "asBuffer", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 275);
+			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 278);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, &buffers, "rewind", NULL, 0);
@@ -687,7 +687,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_4$$4, &buffer, "asBuffer", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 275);
+				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 278);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -752,7 +752,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Chunk length must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 295);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 298);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -769,7 +769,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 	} else {
 		_6 = &buffers;
 	}
-	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 308);
+	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 311);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -779,7 +779,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 13, &buffer);
 			zephir_check_call_status();
-			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 305);
+			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 308);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -803,7 +803,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 13, &buffer);
 				zephir_check_call_status();
-				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 305);
+				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 308);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -853,7 +853,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Times must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 323);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 326);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 4899e6a..aa9e6f7 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -684,12 +684,12 @@ PHP_METHOD(Tensor_Vector, linspace)
  */
 PHP_METHOD(Tensor_Vector, fromArray)
 {
-	zval _5$$4, _12$$6;
+	zval _5$$4, _11$$6;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zephir_fcall_cache_entry *_6 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zend_bool validate, _9, _3$$3, _10$$5;
-	zval *a_param = NULL, *validate_param = NULL, valueA, _0, *_2, _8, buffer, _14, _7$$3, _4$$4, _13$$5, _11$$6;
+	zend_bool validate, _8, _3$$3, _9$$5;
+	zval *a_param = NULL, *validate_param = NULL, valueA, _0, *_2, _7, buffer, _12, _4$$4, _10$$6;
 	zval a, flat, _1;
 
 	ZVAL_UNDEF(&a);
@@ -697,15 +697,13 @@ PHP_METHOD(Tensor_Vector, fromArray)
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_7$$3);
+	ZVAL_UNDEF(&_12);
 	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&_13$$5);
-	ZVAL_UNDEF(&_11$$6);
+	ZVAL_UNDEF(&_10$$6);
 	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_12$$6);
+	ZVAL_UNDEF(&_11$$6);
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
 		Z_PARAM_OPTIONAL
@@ -744,57 +742,53 @@ PHP_METHOD(Tensor_Vector, fromArray)
 				ZEPHIR_MM_RESTORE();
 				return;
 			}
-			ZEPHIR_INIT_NVAR(&_7$$3);
-			ZVAL_DOUBLE(&_7$$3, zephir_get_doubleval(&valueA));
-			zephir_array_append(&flat, &_7$$3, PH_SEPARATE, "tensor/vector.zep", 284);
+			zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/vector.zep", 284);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, &_1, "rewind", NULL, 0);
 		zephir_check_call_status();
-		_9 = 1;
+		_8 = 1;
 		while (1) {
-			if (_9) {
-				_9 = 0;
+			if (_8) {
+				_8 = 0;
 			} else {
 				ZEPHIR_CALL_METHOD(NULL, &_1, "next", NULL, 0);
 				zephir_check_call_status();
 			}
-			ZEPHIR_CALL_METHOD(&_8, &_1, "valid", NULL, 0);
+			ZEPHIR_CALL_METHOD(&_7, &_1, "valid", NULL, 0);
 			zephir_check_call_status();
-			if (!zend_is_true(&_8)) {
+			if (!zend_is_true(&_7)) {
 				break;
 			}
 			ZEPHIR_CALL_METHOD(&valueA, &_1, "current", NULL, 0);
 			zephir_check_call_status();
-				_10$$5 = validate;
-				if (_10$$5) {
-					_10$$5 = Z_TYPE_P(&valueA) == IS_ARRAY;
+				_9$$5 = validate;
+				if (_9$$5) {
+					_9$$5 = Z_TYPE_P(&valueA) == IS_ARRAY;
 				}
-				if (UNEXPECTED(_10$$5)) {
+				if (UNEXPECTED(_9$$5)) {
+					ZEPHIR_INIT_NVAR(&_10$$6);
+					object_init_ex(&_10$$6, tensor_exceptions_invalidargumentexception_ce);
 					ZEPHIR_INIT_NVAR(&_11$$6);
-					object_init_ex(&_11$$6, tensor_exceptions_invalidargumentexception_ce);
-					ZEPHIR_INIT_NVAR(&_12$$6);
-					ZEPHIR_CONCAT_SS(&_12$$6, "Vector requires a", " flat array of numeric elements.");
-					ZEPHIR_CALL_METHOD(NULL, &_11$$6, "__construct", &_6, 2, &_12$$6);
+					ZEPHIR_CONCAT_SS(&_11$$6, "Vector requires a", " flat array of numeric elements.");
+					ZEPHIR_CALL_METHOD(NULL, &_10$$6, "__construct", &_6, 2, &_11$$6);
 					zephir_check_call_status();
-					zephir_throw_exception_debug(&_11$$6, "tensor/vector.zep", 281);
+					zephir_throw_exception_debug(&_10$$6, "tensor/vector.zep", 281);
 					ZEPHIR_MM_RESTORE();
 					return;
 				}
-				ZEPHIR_INIT_NVAR(&_13$$5);
-				ZVAL_DOUBLE(&_13$$5, zephir_get_doubleval(&valueA));
-				zephir_array_append(&flat, &_13$$5, PH_SEPARATE, "tensor/vector.zep", 284);
+				zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/vector.zep", 284);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&valueA);
 	ZEPHIR_INIT_VAR(&buffer);
 	tensor_buffer_from_array(&buffer, &flat);
 	object_init_ex(return_value, zend_get_called_scope(execute_data));
-	ZEPHIR_INIT_VAR(&_14);
-	object_init_ex(&_14, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, &_14, "__construct", NULL, 13, &buffer);
+	ZEPHIR_INIT_VAR(&_12);
+	object_init_ex(&_12, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, &_12, "__construct", NULL, 13, &buffer);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_14);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_12);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 07bb56b..f104b45 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -394,7 +394,7 @@ class Matrix implements Tensor
             }
 
             for valueA in rowA {
-                let flat[] = (float) valueA;
+                let flat[] = valueA;
             }
         }
 
diff --git a/tensor/vector.zep b/tensor/vector.zep
index bd0a55d..79564be 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -281,7 +281,7 @@ class Vector implements Tensor
                     . " flat array of numeric elements.");
             }
 
-            let flat[] = (float) valueA;
+            let flat[] = valueA;
         }
 
         var buffer = tensor_buffer_from_array(flat);

From bfa015e55bf3ab67c4bd44d03190196625bded71 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 19:59:46 -0500
Subject: [PATCH 36/51] Fix bugs

---
 ext/tensor/matrix.zep.c          | 536 +++++++++++++------------------
 ext/tensor/reductions/ref.zep.c  |   2 +-
 ext/tensor/reductions/rref.zep.c |   2 +-
 ext/tensor/tensorbuffer.zep.c    |   2 +-
 tensor/matrix.zep                |  16 +-
 5 files changed, 236 insertions(+), 322 deletions(-)

diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index dc88a74..b64b572 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -884,12 +884,12 @@ PHP_METHOD(Tensor_Matrix, uniform)
  */
 PHP_METHOD(Tensor_Matrix, fromArray)
 {
-	zval _6$$4, _10$$6, _26$$11;
+	zval _6$$4, _9$$6;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_2 = NULL, *_14 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, rows;
-	zend_bool validate, _23, _8$$5, _11$$5, _21$$5, _24$$10, _27$$10, _36$$10;
-	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, *_7, _22, buffer, _37, _38, buffer$$3, _0$$3, _1$$3, _3$$3, _4$$3, _5$$4, *_17$$5, _18$$5, *_19$$5, _20$$5, _9$$6, _12$$7, _13$$7, _15$$7, _16$$7, *_32$$10, _33$$10, *_34$$10, _35$$10, _25$$11, _28$$12, _29$$12, _30$$12, _31$$12;
+	zephir_fcall_cache_entry *_2 = NULL, *_13 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, rows, i = 0;
+	zend_bool validate, _7$$5, _10$$5, _20$$5;
+	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, aList, buffer, _21, _22, buffer$$3, _0$$3, _1$$3, _3$$3, _4$$3, _5$$4, *_16$$5, _17$$5, *_18$$5, _19$$5, _8$$6, _11$$7, _12$$7, _14$$7, _15$$7;
 	zval a, flat;
 
 	ZVAL_UNDEF(&a);
@@ -898,33 +898,25 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZVAL_UNDEF(&valueA);
 	ZVAL_UNDEF(&firstRow);
 	ZVAL_UNDEF(&n);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&aList);
 	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_37);
-	ZVAL_UNDEF(&_38);
+	ZVAL_UNDEF(&_21);
+	ZVAL_UNDEF(&_22);
 	ZVAL_UNDEF(&buffer$$3);
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_18$$5);
-	ZVAL_UNDEF(&_20$$5);
-	ZVAL_UNDEF(&_9$$6);
+	ZVAL_UNDEF(&_17$$5);
+	ZVAL_UNDEF(&_19$$5);
+	ZVAL_UNDEF(&_8$$6);
+	ZVAL_UNDEF(&_11$$7);
 	ZVAL_UNDEF(&_12$$7);
-	ZVAL_UNDEF(&_13$$7);
+	ZVAL_UNDEF(&_14$$7);
 	ZVAL_UNDEF(&_15$$7);
-	ZVAL_UNDEF(&_16$$7);
-	ZVAL_UNDEF(&_33$$10);
-	ZVAL_UNDEF(&_35$$10);
-	ZVAL_UNDEF(&_25$$11);
-	ZVAL_UNDEF(&_28$$12);
-	ZVAL_UNDEF(&_29$$12);
-	ZVAL_UNDEF(&_30$$12);
-	ZVAL_UNDEF(&_31$$12);
 	ZVAL_UNDEF(&_6$$4);
-	ZVAL_UNDEF(&_10$$6);
-	ZVAL_UNDEF(&_26$$11);
+	ZVAL_UNDEF(&_9$$6);
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
 		Z_PARAM_OPTIONAL
@@ -955,8 +947,10 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	ZEPHIR_CALL_FUNCTION(&firstRow, "current", NULL, 28, &a);
+	ZEPHIR_CALL_FUNCTION(&aList, "array_values", NULL, 27, &a);
 	zephir_check_call_status();
+	zephir_memory_observe(&firstRow);
+	zephir_array_fetch_long(&firstRow, &aList, 0, PH_NOISY, "tensor/matrix.zep", 377);
 	if (UNEXPECTED(!(Z_TYPE_P(&firstRow) == IS_ARRAY))) {
 		ZEPHIR_INIT_VAR(&_5$$4);
 		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
@@ -964,7 +958,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Matrix requires an", " array of arrays.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 377);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 381);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -972,185 +966,95 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZVAL_LONG(&n, zephir_fast_count_int(&firstRow));
 	ZEPHIR_INIT_VAR(&flat);
 	array_init(&flat);
-	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 401);
-	if (Z_TYPE_P(&a) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _7)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _7);
-			_8$$5 = validate;
-			if (_8$$5) {
-				_8$$5 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
-			}
-			if (UNEXPECTED(_8$$5)) {
-				ZEPHIR_INIT_NVAR(&_9$$6);
-				object_init_ex(&_9$$6, tensor_exceptions_invalidargumentexception_ce);
-				ZEPHIR_INIT_NVAR(&_10$$6);
-				ZEPHIR_CONCAT_SS(&_10$$6, "Matrix requires an", " array of arrays.");
-				ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", NULL, 2, &_10$$6);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_9$$6, "tensor/matrix.zep", 387);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-			_11$$5 = validate;
-			if (_11$$5) {
-				_11$$5 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
-			}
-			if (UNEXPECTED(_11$$5)) {
-				ZEPHIR_INIT_NVAR(&_12$$7);
-				object_init_ex(&_12$$7, tensor_exceptions_invalidargumentexception_ce);
-				ZEPHIR_CALL_FUNCTION(&_13$$7, "strval", &_14, 3, &n);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_15$$7);
-				ZVAL_LONG(&_15$$7, zephir_fast_count_int(&rowA));
-				ZEPHIR_INIT_NVAR(&_16$$7);
-				ZEPHIR_CONCAT_SSVSVS(&_16$$7, "The number of", " columns must be equal for all rows, ", &_13$$7, " needed but ", &_15$$7, " given.");
-				ZEPHIR_CALL_METHOD(NULL, &_12$$7, "__construct", NULL, 2, &_16$$7);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_12$$7, "tensor/matrix.zep", 393);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-			if (Z_TYPE_P(&rowA) == IS_STRING) {
-				ZEPHIR_INIT_NVAR(&_18$$5);
-				zephir_string_to_char_array(&_18$$5, &rowA);
-				_17$$5 = &_18$$5;
-			} else {
-				_17$$5 = &rowA;
-			}
-			zephir_is_iterable(_17$$5, 0, "tensor/matrix.zep", 399);
-			if (Z_TYPE_P(_17$$5) == IS_ARRAY) {
-				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$5), _19$$5)
-				{
-					ZEPHIR_INIT_NVAR(&valueA);
-					ZVAL_COPY(&valueA, _19$$5);
-					zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 397);
-				} ZEND_HASH_FOREACH_END();
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _17$$5, "rewind", NULL, 0);
-				zephir_check_call_status();
-				_21$$5 = 1;
-				while (1) {
-					if (_21$$5) {
-						_21$$5 = 0;
-					} else {
-						ZEPHIR_CALL_METHOD(NULL, _17$$5, "next", NULL, 0);
-						zephir_check_call_status();
-					}
-					ZEPHIR_CALL_METHOD(&_20$$5, _17$$5, "valid", NULL, 0);
-					zephir_check_call_status();
-					if (!zend_is_true(&_20$$5)) {
-						break;
-					}
-					ZEPHIR_CALL_METHOD(&valueA, _17$$5, "current", NULL, 0);
-					zephir_check_call_status();
-						zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 397);
-				}
-			}
-			ZEPHIR_INIT_NVAR(&valueA);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, &a, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_23 = 1;
-		while (1) {
-			if (_23) {
-				_23 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, &a, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_22, &a, "valid", NULL, 0);
+	i = 0;
+	while (1) {
+		if (!(i < rows)) {
+			break;
+		}
+		ZEPHIR_OBS_NVAR(&rowA);
+		zephir_array_fetch_long(&rowA, &aList, i, PH_NOISY, "tensor/matrix.zep", 391);
+		_7$$5 = validate;
+		if (_7$$5) {
+			_7$$5 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
+		}
+		if (UNEXPECTED(_7$$5)) {
+			ZEPHIR_INIT_NVAR(&_8$$6);
+			object_init_ex(&_8$$6, tensor_exceptions_invalidargumentexception_ce);
+			ZEPHIR_INIT_NVAR(&_9$$6);
+			ZEPHIR_CONCAT_SS(&_9$$6, "Matrix requires an", " array of arrays.");
+			ZEPHIR_CALL_METHOD(NULL, &_8$$6, "__construct", NULL, 2, &_9$$6);
 			zephir_check_call_status();
-			if (!zend_is_true(&_22)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, &a, "current", NULL, 0);
+			zephir_throw_exception_debug(&_8$$6, "tensor/matrix.zep", 395);
+			ZEPHIR_MM_RESTORE();
+			return;
+		}
+		_10$$5 = validate;
+		if (_10$$5) {
+			_10$$5 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
+		}
+		if (UNEXPECTED(_10$$5)) {
+			ZEPHIR_INIT_NVAR(&_11$$7);
+			object_init_ex(&_11$$7, tensor_exceptions_invalidargumentexception_ce);
+			ZEPHIR_CALL_FUNCTION(&_12$$7, "strval", &_13, 3, &n);
 			zephir_check_call_status();
-				_24$$10 = validate;
-				if (_24$$10) {
-					_24$$10 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
-				}
-				if (UNEXPECTED(_24$$10)) {
-					ZEPHIR_INIT_NVAR(&_25$$11);
-					object_init_ex(&_25$$11, tensor_exceptions_invalidargumentexception_ce);
-					ZEPHIR_INIT_NVAR(&_26$$11);
-					ZEPHIR_CONCAT_SS(&_26$$11, "Matrix requires an", " array of arrays.");
-					ZEPHIR_CALL_METHOD(NULL, &_25$$11, "__construct", NULL, 2, &_26$$11);
-					zephir_check_call_status();
-					zephir_throw_exception_debug(&_25$$11, "tensor/matrix.zep", 387);
-					ZEPHIR_MM_RESTORE();
-					return;
-				}
-				_27$$10 = validate;
-				if (_27$$10) {
-					_27$$10 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
-				}
-				if (UNEXPECTED(_27$$10)) {
-					ZEPHIR_INIT_NVAR(&_28$$12);
-					object_init_ex(&_28$$12, tensor_exceptions_invalidargumentexception_ce);
-					ZEPHIR_CALL_FUNCTION(&_29$$12, "strval", &_14, 3, &n);
-					zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&_30$$12);
-					ZVAL_LONG(&_30$$12, zephir_fast_count_int(&rowA));
-					ZEPHIR_INIT_NVAR(&_31$$12);
-					ZEPHIR_CONCAT_SSVSVS(&_31$$12, "The number of", " columns must be equal for all rows, ", &_29$$12, " needed but ", &_30$$12, " given.");
-					ZEPHIR_CALL_METHOD(NULL, &_28$$12, "__construct", NULL, 2, &_31$$12);
-					zephir_check_call_status();
-					zephir_throw_exception_debug(&_28$$12, "tensor/matrix.zep", 393);
-					ZEPHIR_MM_RESTORE();
-					return;
-				}
-				if (Z_TYPE_P(&rowA) == IS_STRING) {
-					ZEPHIR_INIT_NVAR(&_33$$10);
-					zephir_string_to_char_array(&_33$$10, &rowA);
-					_32$$10 = &_33$$10;
-				} else {
-					_32$$10 = &rowA;
-				}
-				zephir_is_iterable(_32$$10, 0, "tensor/matrix.zep", 399);
-				if (Z_TYPE_P(_32$$10) == IS_ARRAY) {
-					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_32$$10), _34$$10)
-					{
-						ZEPHIR_INIT_NVAR(&valueA);
-						ZVAL_COPY(&valueA, _34$$10);
-						zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 397);
-					} ZEND_HASH_FOREACH_END();
+			ZEPHIR_INIT_NVAR(&_14$$7);
+			ZVAL_LONG(&_14$$7, zephir_fast_count_int(&rowA));
+			ZEPHIR_INIT_NVAR(&_15$$7);
+			ZEPHIR_CONCAT_SSVSVS(&_15$$7, "The number of", " columns must be equal for all rows, ", &_12$$7, " needed but ", &_14$$7, " given.");
+			ZEPHIR_CALL_METHOD(NULL, &_11$$7, "__construct", NULL, 2, &_15$$7);
+			zephir_check_call_status();
+			zephir_throw_exception_debug(&_11$$7, "tensor/matrix.zep", 401);
+			ZEPHIR_MM_RESTORE();
+			return;
+		}
+		if (Z_TYPE_P(&rowA) == IS_STRING) {
+			ZEPHIR_INIT_NVAR(&_17$$5);
+			zephir_string_to_char_array(&_17$$5, &rowA);
+			_16$$5 = &_17$$5;
+		} else {
+			_16$$5 = &rowA;
+		}
+		zephir_is_iterable(_16$$5, 0, "tensor/matrix.zep", 408);
+		if (Z_TYPE_P(_16$$5) == IS_ARRAY) {
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_16$$5), _18$$5)
+			{
+				ZEPHIR_INIT_NVAR(&valueA);
+				ZVAL_COPY(&valueA, _18$$5);
+				zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 405);
+			} ZEND_HASH_FOREACH_END();
+		} else {
+			ZEPHIR_CALL_METHOD(NULL, _16$$5, "rewind", NULL, 0);
+			zephir_check_call_status();
+			_20$$5 = 1;
+			while (1) {
+				if (_20$$5) {
+					_20$$5 = 0;
 				} else {
-					ZEPHIR_CALL_METHOD(NULL, _32$$10, "rewind", NULL, 0);
+					ZEPHIR_CALL_METHOD(NULL, _16$$5, "next", NULL, 0);
 					zephir_check_call_status();
-					_36$$10 = 1;
-					while (1) {
-						if (_36$$10) {
-							_36$$10 = 0;
-						} else {
-							ZEPHIR_CALL_METHOD(NULL, _32$$10, "next", NULL, 0);
-							zephir_check_call_status();
-						}
-						ZEPHIR_CALL_METHOD(&_35$$10, _32$$10, "valid", NULL, 0);
-						zephir_check_call_status();
-						if (!zend_is_true(&_35$$10)) {
-							break;
-						}
-						ZEPHIR_CALL_METHOD(&valueA, _32$$10, "current", NULL, 0);
-						zephir_check_call_status();
-							zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 397);
-					}
 				}
-				ZEPHIR_INIT_NVAR(&valueA);
+				ZEPHIR_CALL_METHOD(&_19$$5, _16$$5, "valid", NULL, 0);
+				zephir_check_call_status();
+				if (!zend_is_true(&_19$$5)) {
+					break;
+				}
+				ZEPHIR_CALL_METHOD(&valueA, _16$$5, "current", NULL, 0);
+				zephir_check_call_status();
+					zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 405);
+			}
 		}
+		ZEPHIR_INIT_NVAR(&valueA);
+		i++;
 	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_INIT_VAR(&buffer);
 	tensor_buffer_from_array(&buffer, &flat);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_INIT_VAR(&_37);
-	object_init_ex(&_37, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, &_37, "__construct", &_2, 13, &buffer);
+	ZEPHIR_INIT_VAR(&_21);
+	object_init_ex(&_21, tensor_tensorbuffer_ce);
+	ZEPHIR_CALL_METHOD(NULL, &_21, "__construct", &_2, 13, &buffer);
 	zephir_check_call_status();
-	ZVAL_LONG(&_38, rows);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_37, &_38, &n);
+	ZVAL_LONG(&_22, rows);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_21, &_22, &n);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1208,7 +1112,7 @@ PHP_METHOD(Tensor_Matrix, __construct)
 		ZEPHIR_CONCAT_SS(&_2$$3, "Matrix dimensions must be", " non-negative.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 418);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 428);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1420,7 +1324,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Row offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 497);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 507);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1491,7 +1395,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Column offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 514);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 524);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1556,7 +1460,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 530);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 540);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1627,7 +1531,7 @@ PHP_METHOD(Tensor_Matrix, asVectors)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 555);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 565);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -1637,7 +1541,7 @@ PHP_METHOD(Tensor_Matrix, asVectors)
 			object_init_ex(&_7$$4, tensor_vector_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", &_8, 14, &rowBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 552);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 562);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -1661,7 +1565,7 @@ PHP_METHOD(Tensor_Matrix, asVectors)
 				object_init_ex(&_11$$5, tensor_vector_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_11$$5, "__construct", &_8, 14, &rowBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 552);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 562);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -1714,7 +1618,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 577);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 587);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -1724,7 +1628,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			object_init_ex(&_5$$4, tensor_columnvector_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_6, 14, &columnBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 574);
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 584);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -1748,7 +1652,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 				object_init_ex(&_9$$5, tensor_columnvector_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", &_6, 14, &columnBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 574);
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 584);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&columnBuffer);
@@ -1835,7 +1739,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 610);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 620);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -1843,7 +1747,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 607);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 617);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -1865,7 +1769,7 @@ PHP_METHOD(Tensor_Matrix, asArray)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 607);
+				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 617);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -1992,7 +1896,7 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 659);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 669);
 		}
 	}
 	RETURN_CTOR(&b);
@@ -2138,9 +2042,9 @@ PHP_METHOD(Tensor_Matrix, transpose)
 		RETURN_MM();
 	}
 	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 707);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 717);
 	ZVAL_LONG(&_3, 1);
-	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 29, &cols, &_3);
+	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 28, &cols, &_3);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_2, &col, "concat", NULL, 0, &_4);
 	zephir_check_call_status();
@@ -2203,7 +2107,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 724);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 734);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2214,9 +2118,9 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_5$$4, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 30, &_6$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 29, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 729);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 739);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2229,9 +2133,9 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_9$$5, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_10$$5);
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 30, &_10$$5);
+		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 29, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 736);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 746);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2289,9 +2193,9 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		object_init_ex(&_3$$3, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 30, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 29, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 753);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 763);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2341,7 +2245,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 769);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 779);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2441,7 +2345,7 @@ PHP_METHOD(Tensor_Matrix, fullRank)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_1, this_ptr, "shape", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 31, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 30, &_1);
 	zephir_check_call_status();
 	RETURN_MM_BOOL(ZEPHIR_IS_IDENTICAL(&_0, &_2));
 }
@@ -2550,7 +2454,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 837);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 847);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2625,7 +2529,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 857);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 867);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2723,7 +2627,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 2, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 875);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 885);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2737,7 +2641,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 2, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 880);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 890);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3074,7 +2978,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1024);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1034);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3145,7 +3049,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1057);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1067);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3217,7 +3121,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1091);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1101);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3289,7 +3193,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1125);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1135);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3361,7 +3265,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1159);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1169);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3433,7 +3337,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1193);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1203);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3505,7 +3409,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1227);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1237);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3577,7 +3481,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1261);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1271);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3649,7 +3553,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1295);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1305);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3721,7 +3625,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1329);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1339);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3793,7 +3697,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1363);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1373);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3865,7 +3769,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1397);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1407);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4588,7 +4492,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1582);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1592);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4596,7 +4500,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1579);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1589);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4618,7 +4522,7 @@ PHP_METHOD(Tensor_Matrix, sum)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1579);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1589);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4676,7 +4580,7 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1600);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1610);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4684,7 +4588,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1597);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1607);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4706,7 +4610,7 @@ PHP_METHOD(Tensor_Matrix, product)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1597);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1607);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4764,7 +4668,7 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1618);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1628);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4772,7 +4676,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1615);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1625);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4794,7 +4698,7 @@ PHP_METHOD(Tensor_Matrix, min)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1615);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1625);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4852,7 +4756,7 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1636);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1646);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
@@ -4860,7 +4764,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			ZVAL_COPY(&rowBuffer, _5);
 			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1633);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1643);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4882,7 +4786,7 @@ PHP_METHOD(Tensor_Matrix, max)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1633);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1643);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4988,7 +4892,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1676);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1686);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -5012,7 +4916,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1673);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1683);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -5050,7 +4954,7 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1673);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1683);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5138,7 +5042,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1690);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1700);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5159,7 +5063,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1719);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1729);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5175,7 +5079,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1709);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1719);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5187,7 +5091,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1716);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1726);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5217,7 +5121,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1709);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1719);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5229,7 +5133,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1716);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1726);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5305,7 +5209,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1735);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1745);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5325,7 +5229,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 2, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1741);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1751);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5414,7 +5318,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 2, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1766);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1776);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5524,7 +5428,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1793);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1803);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5541,7 +5445,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_12 = &_10;
 	}
-	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1816);
+	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1826);
 	if (Z_TYPE_P(_12) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
 		{
@@ -5564,7 +5468,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1813);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1823);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
@@ -5601,7 +5505,7 @@ PHP_METHOD(Tensor_Matrix, round)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1813);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1823);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5754,7 +5658,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1852);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1862);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6031,7 +5935,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1918);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1928);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6129,7 +6033,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1938);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1948);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6239,7 +6143,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1958);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1968);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6282,7 +6186,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1972);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1982);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -6385,7 +6289,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1990);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2000);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6428,7 +6332,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2004);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2014);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -6516,7 +6420,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2028);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2038);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -6525,7 +6429,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2026);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2036);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -6548,16 +6452,16 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2026);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2036);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2031);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2041);
 		ZVAL_LONG(&_13$$6, 1);
-		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 29, &bigRows, &_13$$6);
+		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 28, &bigRows, &_13$$6);
 		zephir_check_call_status();
 		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "concat", NULL, 0, &_14$$6);
 		zephir_check_call_status();
@@ -6643,7 +6547,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2054);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2064);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6719,7 +6623,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2073);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2083);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6795,7 +6699,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2092);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2102);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6871,7 +6775,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2111);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2121);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6948,7 +6852,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2131);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2141);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7025,7 +6929,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2151);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2161);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7102,7 +7006,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2171);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2181);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7178,7 +7082,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2190);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2200);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7255,7 +7159,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2210);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2220);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7332,7 +7236,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2230);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2240);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7408,7 +7312,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2249);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2259);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7484,7 +7388,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2268);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2278);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7565,7 +7469,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2288);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2298);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7648,7 +7552,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2312);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2322);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7731,7 +7635,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2336);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2346);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7814,7 +7718,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2360);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2370);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7897,7 +7801,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2384);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2394);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7980,7 +7884,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2408);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2418);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8064,7 +7968,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2433);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2443);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8147,7 +8051,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2457);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2467);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8230,7 +8134,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2481);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2491);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8313,7 +8217,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2505);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2515);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8396,7 +8300,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2529);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2539);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8480,7 +8384,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2554);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2564);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8563,7 +8467,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2578);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2588);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8646,7 +8550,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2602);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2612);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8729,7 +8633,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2626);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2636);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8812,7 +8716,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2650);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2660);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8895,7 +8799,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2674);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2684);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8978,7 +8882,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2698);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2708);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9061,7 +8965,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2722);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2732);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9144,7 +9048,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2746);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2756);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9227,7 +9131,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2770);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2780);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9310,7 +9214,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2794);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2804);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9393,7 +9297,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2818);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2828);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9476,7 +9380,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2842);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2852);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10140,7 +10044,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3027);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3037);
 	return;
 }
 
@@ -10191,7 +10095,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3051);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3061);
 	return;
 }
 
@@ -10251,7 +10155,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3065);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3075);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10268,7 +10172,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3070);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3080);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10391,16 +10295,16 @@ PHP_METHOD(Tensor_Matrix, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3113);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3123);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_2, &rebuilt, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_2);
-	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3116);
+	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3126);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_3);
-	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3117);
+	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3127);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_4);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index e6edef0..251d8cd 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -115,7 +115,7 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	swaps = zephir_get_intval(&_8);
 	object_init_ex(return_value, tensor_reductions_ref_ce);
 	ZVAL_LONG(&_9, swaps);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index d32375a..51ebf56 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -88,7 +88,7 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 15, &result, &_4, &_5);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 33, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 5c3b21f..0b683a0 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -103,7 +103,7 @@ PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
 	zephir_memory_observe(&_3);
 	zephir_array_fetch_long(&_3, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 47);
 	ZVAL_LONG(&_4, 1);
-	ZEPHIR_CALL_FUNCTION(&_5, "array_slice", NULL, 29, &buffers, &_4);
+	ZEPHIR_CALL_FUNCTION(&_5, "array_slice", NULL, 28, &buffers, &_4);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&b, &_3, "concat", NULL, 0, &_5);
 	zephir_check_call_status();
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index f104b45..b424841 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -368,9 +368,13 @@ class Matrix implements Tensor
 
         var rowA, valueA;
 
-        var firstRow, n;
+        var firstRow, n, aList;
 
-        let firstRow = current(a);
+        int i;
+
+        let aList = array_values(a);
+
+        let firstRow = aList[0];
 
         if unlikely !is_array(firstRow) {
             throw new InvalidArgumentException("Matrix requires an"
@@ -381,7 +385,11 @@ class Matrix implements Tensor
 
         array flat = [];
 
-        for rowA in a {
+        let i = 0;
+
+        while i < rows {
+            let rowA = aList[i];
+
             if unlikely validate && !is_array(rowA) {
                 throw new InvalidArgumentException("Matrix requires an"
                     . " array of arrays.");
@@ -396,6 +404,8 @@ class Matrix implements Tensor
             for valueA in rowA {
                 let flat[] = valueA;
             }
+
+            let i++;
         }
 
         var buffer = tensor_buffer_from_array(flat);

From 7ddfa115c3ee1868591831970fc2705e3eb2be0b Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 20:40:28 -0500
Subject: [PATCH 37/51] Save game

---
 benchmarks/Buffer/TensorBufferBench.php  | 100 ---
 docs/Matrix.md                           |   2 +
 docs/TensorBuffer.md                     |  37 +-
 docs/Vector.md                           |   2 +
 docs/interfaces/special.md               |  10 +-
 ext/include/buffer.c                     | 193 +++++-
 ext/include/buffer.h                     |   8 +-
 ext/tensor/columnvector.zep.c            |  26 +-
 ext/tensor/decompositions/cholesky.zep.c |   4 +-
 ext/tensor/decompositions/eigen.zep.c    |   6 +-
 ext/tensor/decompositions/lu.zep.c       |   8 +-
 ext/tensor/decompositions/svd.zep.c      |   6 +-
 ext/tensor/matrix.zep.c                  | 774 ++++++++++++++---------
 ext/tensor/matrix.zep.h                  |  10 +
 ext/tensor/reductions/ref.zep.c          |   4 +-
 ext/tensor/reductions/rref.zep.c         |   4 +-
 ext/tensor/special.zep.c                 |  12 +
 ext/tensor/special.zep.h                 |   8 +
 ext/tensor/tensorbuffer.zep.c            | 243 +------
 ext/tensor/tensorbuffer.zep.h            |  36 --
 ext/tensor/vector.zep.c                  | 381 +++++------
 ext/tensor/vector.zep.h                  |  10 +
 stubs/TensorBuffer.php                   |  28 -
 tensor/matrix.zep                        |  54 +-
 tensor/special.zep                       |  14 +
 tensor/tensorbuffer.zep                  |  92 +--
 tensor/vector.zep                        |  30 +-
 tests/MatrixTest.php                     |  36 ++
 tests/TensorBufferTest.php               | 241 -------
 tests/VectorTest.php                     |  64 ++
 30 files changed, 1140 insertions(+), 1303 deletions(-)

diff --git a/benchmarks/Buffer/TensorBufferBench.php b/benchmarks/Buffer/TensorBufferBench.php
index a93ac26..221eb74 100644
--- a/benchmarks/Buffer/TensorBufferBench.php
+++ b/benchmarks/Buffer/TensorBufferBench.php
@@ -112,106 +112,6 @@ public function sliceNative() : void
         new TensorBuffer(Buffer::fromArray($a));
     }
 
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function sum() : void
-    {
-        $this->buffer->sum();
-    }
-
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function sumNative() : int|float
-    {
-        return array_sum($this->buffer->toArray());
-    }
-
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function product() : void
-    {
-        $this->buffer->product();
-    }
-
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function productNative() : int|float
-    {
-        return array_product($this->buffer->toArray());
-    }
-
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function min() : void
-    {
-        $this->buffer->min();
-    }
-
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function minNative() : mixed
-    {
-        return min($this->buffer->toArray());
-    }
-
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function max() : void
-    {
-        $this->buffer->max();
-    }
-
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function maxNative() : mixed
-    {
-        return max($this->buffer->toArray());
-    }
-
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function argmin() : void
-    {
-        $this->buffer->argmin();
-    }
-
-    /**
-     * @Subject
-     * @Iterations(5)
-     * @OutputTimeUnit("milliseconds", precision=3)
-     */
-    public function argmax() : void
-    {
-        $this->buffer->argmax();
-    }
-
     /**
      * @Subject
      * @Iterations(5)
diff --git a/docs/Matrix.md b/docs/Matrix.md
index 2b45acd..3f07235 100644
--- a/docs/Matrix.md
+++ b/docs/Matrix.md
@@ -424,6 +424,8 @@ See [Statistical](interfaces/statistical.md) and [Special](interfaces/special.md
 - `product() : ColumnVector` — calculate the row product of the matrix
 - `min() : ColumnVector` — minimum of each row
 - `max() : ColumnVector` — maximum of each row
+- `argmin() : ColumnVector` — index of the minimum of each row; ties resolve to the first occurrence
+- `argmax() : ColumnVector` — index of the maximum of each row; ties resolve to the first occurrence
 - `mean() : ColumnVector` — means of each row
 - `median() : ColumnVector` — median vector of this matrix
 - `quantile(float $q) : ColumnVector` — q'th quantile of each row (throws `InvalidArgumentException` if `$q` is outside `[0, 1]`)
diff --git a/docs/TensorBuffer.md b/docs/TensorBuffer.md
index 690422c..d9ec500 100644
--- a/docs/TensorBuffer.md
+++ b/docs/TensorBuffer.md
@@ -62,38 +62,6 @@ Return a new decorator wrapping a new buffer of `$length` elements copied from `
 
 - **Throws:** `Tensor\Exceptions\InvalidArgumentException` if `$offset` or `$length` is negative, or the requested range exceeds the buffer size
 
-### `sum() : float`
-
-Return the sum of all elements in the buffer. An empty buffer sums to `0.0`.
-
-### `product() : float`
-
-Return the product of all elements in the buffer. An empty buffer products to `1.0`.
-
-### `min() : float`
-
-Return the minimum element in the buffer.
-
-- **Throws:** `InvalidArgumentException` if the buffer is empty
-
-### `max() : float`
-
-Return the maximum element in the buffer.
-
-- **Throws:** `InvalidArgumentException` if the buffer is empty
-
-### `argmin() : int`
-
-Return the index of the minimum element in the buffer. Ties resolve to the first occurrence.
-
-- **Throws:** `InvalidArgumentException` if the buffer is empty
-
-### `argmax() : int`
-
-Return the index of the maximum element in the buffer. Ties resolve to the first occurrence.
-
-- **Throws:** `InvalidArgumentException` if the buffer is empty
-
 ### `sliceStrided(int $offset, int $length, int $stride) : TensorBuffer`
 
 Return a new decorator wrapping a new buffer of `$length` elements gathered at `$stride` intervals from `buffer[$offset]` — i.e. `buffer[$offset + i * $stride]` for `i` in `0..length - 1`. The source buffer is left unchanged. Supports gathering rows, columns, and diagonals from a flat matrix layout.
@@ -120,6 +88,5 @@ Return a new decorator wrapping a new buffer containing the elements of this buf
 
 ## Notes
 
-- `sort()`, `slice()`, the reductions (`sum()`, `product()`, `min()`, `max()`, `argmin()`, `argmax()`), `sliceStrided()`, `concat()`, `split()`, and `repeat()` are implemented in C (`ext/include/buffer.c`) and route through this class's optimizer calls, operating directly on the buffer's raw pointer.
-- Both element kinds (`TYPE_DOUBLE` and `TYPE_LONG`) are supported; `slice()`, `sliceStrided()`, `concat()`, `split()`, and `repeat()` preserve the source kind.
-- Reductions and order statistics are float-only: even for a `TYPE_LONG` buffer, `sum()`, `product()`, `min()`, and `max()` return `float`.
\ No newline at end of file
+- `sort()`, `slice()`, `sliceStrided()`, `concat()`, `split()`, and `repeat()` are implemented in C (`ext/include/buffer.c`) and route through this class's optimizer calls, operating directly on the buffer's raw pointer.
+- Both element kinds (`TYPE_DOUBLE` and `TYPE_LONG`) are supported; `slice()`, `sliceStrided()`, `concat()`, `split()`, and `repeat()` preserve the source kind.
\ No newline at end of file
diff --git a/docs/Vector.md b/docs/Vector.md
index bf3243c..37b5ce1 100644
--- a/docs/Vector.md
+++ b/docs/Vector.md
@@ -328,6 +328,8 @@ See [Statistical](interfaces/statistical.md) and [Special](interfaces/special.md
 - `product() : float` — the product of the vector
 - `min() : float` — the minimum element
 - `max() : float` — the maximum element
+- `argmin() : int` — the index of the minimum element; ties resolve to the first occurrence
+- `argmax() : int` — the index of the maximum element; ties resolve to the first occurrence
 - `mean() : float` — the mean of the vector
 - `median() : float` — the median of the vector
 - `quantile(float $q) : float` — the q'th quantile (throws `InvalidArgumentException` if `$q` is outside `[0, 1]`)
diff --git a/docs/interfaces/special.md b/docs/interfaces/special.md
index 684e627..89b73e4 100644
--- a/docs/interfaces/special.md
+++ b/docs/interfaces/special.md
@@ -13,7 +13,7 @@ interface Special
 ```
 
 - For `Vector`, reductions return a `float` scalar.
-- For `Matrix`, the reductions `sum`, `product`, `min`, and `max` operate per-row and return a `ColumnVector`; clipping returns a new `Matrix` of the same shape.
+- For `Matrix`, the reductions `sum`, `product`, `min`, `max`, `argmin`, and `argmax` operate per-row and return a `ColumnVector`; clipping returns a new `Matrix` of the same shape.
 
 ## Methods
 
@@ -33,6 +33,14 @@ Return the minimum of the tensor.
 
 Return the maximum of the tensor.
 
+### `argmin() : mixed`
+
+Return the index of the minimum of the tensor. For a `Vector`, this is an `int`; for a `Matrix`, this is a `ColumnVector` of the per-row minimum indices. Ties resolve to the first occurrence.
+
+### `argmax() : mixed`
+
+Return the index of the maximum of the tensor. For a `Vector`, this is an `int`; for a `Matrix`, this is a `ColumnVector` of the per-row maximum indices. Ties resolve to the first occurrence.
+
 ### `clip(float $min, float $max) : mixed`
 
 Clip the tensor to be between the given minimum and maximum.
diff --git a/ext/include/buffer.c b/ext/include/buffer.c
index bcab5ca..9de71df 100644
--- a/ext/include/buffer.c
+++ b/ext/include/buffer.c
@@ -45,14 +45,32 @@ int tensor_tensorbuffer_create(zval * ret, zend_long len, zval * buffer)
 }
 
 /**
- * Build a `Tensor\Buffer` object from a PHP array of values, casting every
- * element to a double (see include/buffer.h).
+ * Allocate a new `Tensor\TensorBuffer` decorator wrapping a `Tensor\Buffer`
+ * built from a PHP array of values, casting every element to a double (see
+ * include/buffer.h).
  */
 void tensor_buffer_from_array(zval * ret, zval * arr)
 {
-	if (UNEXPECTED(zephir_buffer_create_from_array(ret, arr, ZEPHIR_BUFFER_DOUBLE) == FAILURE)) {
+	zval buffer;
+
+	if (UNEXPECTED(zephir_buffer_create_from_array(&buffer, arr, ZEPHIR_BUFFER_DOUBLE) == FAILURE)) {
 		ZVAL_NULL(ret);
+		return;
+	}
+
+	object_init_ex(ret, tensor_tensorbuffer_ce);
+
+	zend_update_property(tensor_tensorbuffer_ce, Z_OBJ_P(ret), "buffer", sizeof("buffer") - 1, &buffer);
+
+	if (UNEXPECTED(EG(exception))) {
+		zval_ptr_dtor(ret);
+		ZVAL_UNDEF(ret);
+		zval_ptr_dtor(&buffer);
+		ZVAL_UNDEF(&buffer);
+		return;
 	}
+
+	zval_ptr_dtor(&buffer);
 }
 
 /**
@@ -118,6 +136,47 @@ double * tensor_tensorbuffer_doubles(zval * obj, zend_long * len, int * success)
 	return NULL;
 }
 
+/**
+ * Resolve the underlying raw buffer for the reduction operations, accepting
+ * either a `TensorBuffer` decorator (returns a reference to its wrapped
+ * buffer) or a raw `Buffer` object as-is (returns a reference to it). The
+ * caller owns the reference written to `buf` and must release it with
+ * `zval_ptr_dtor()`.
+ *
+ * @return 1 on success, 0 on failure (throwing).
+ */
+static int tensor_resolve_underlying_buffer(zval * obj, zval * buf)
+{
+	if (Z_TYPE_P(obj) == IS_OBJECT && Z_OBJCE_P(obj) == tensor_tensorbuffer_ce) {
+		zval rv;
+		zval *prop;
+
+		ZVAL_UNDEF(&rv);
+
+		prop = zend_read_property(tensor_tensorbuffer_ce, Z_OBJ_P(obj), "buffer", sizeof("buffer") - 1, 1, &rv);
+
+		if (prop != NULL && prop != &rv) {
+			ZVAL_COPY(buf, prop);
+		} else {
+			ZVAL_UNDEF(buf);
+		}
+
+		zval_ptr_dtor(&rv);
+	} else {
+		ZVAL_COPY(buf, obj);
+	}
+
+	if (UNEXPECTED(!zephir_is_buffer(buf))) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer or TensorBuffer object."));
+		zval_ptr_dtor(buf);
+		ZVAL_UNDEF(buf);
+		return 0;
+	}
+
+	return 1;
+}
+
 static int tensor_double_cmp(const void * a, const void * b)
 {
 	double da = *(const double *) a;
@@ -303,21 +362,33 @@ void tensor_buffer_slice(zval * return_value, zval * obj, zval * offset, zval *
  */
 void tensor_buffer_sum(zval * return_value, zval * obj)
 {
-	uint8_t kind = zephir_buffer_kind(obj);
-	zend_long len = zephir_buffer_len(obj);
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
 
 	if (UNEXPECTED(kind == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
 	if (len == 0) {
-		RETURN_DOUBLE(0.0);
+		RETVAL_DOUBLE(0.0);
+		zval_ptr_dtor(&buffer);
+		return;
 	}
 
 	RETVAL_DOUBLE(tensor_buffer_sum_values(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len));
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len));
+	zval_ptr_dtor(&buffer);
 }
 
 /**
@@ -328,21 +399,33 @@ void tensor_buffer_sum(zval * return_value, zval * obj)
  */
 void tensor_buffer_product(zval * return_value, zval * obj)
 {
-	uint8_t kind = zephir_buffer_kind(obj);
-	zend_long len = zephir_buffer_len(obj);
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
 
 	if (UNEXPECTED(kind == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
 	if (len == 0) {
-		RETURN_DOUBLE(1.0);
+		RETVAL_DOUBLE(1.0);
+		zval_ptr_dtor(&buffer);
+		return;
 	}
 
 	RETVAL_DOUBLE(tensor_buffer_product_values(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len));
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len));
+	zval_ptr_dtor(&buffer);
 }
 
 /**
@@ -353,26 +436,37 @@ void tensor_buffer_product(zval * return_value, zval * obj)
  */
 void tensor_buffer_min(zval * return_value, zval * obj)
 {
-	uint8_t kind = zephir_buffer_kind(obj);
-	zend_long len = zephir_buffer_len(obj);
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+	double value = 0.0;
+	zend_long index = 0;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
 
 	if (UNEXPECTED(kind == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
 	if (UNEXPECTED(len == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Cannot compute the minimum of an empty buffer."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
-	double value = 0.0;
-	zend_long index = 0;
-
 	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len, 1, &value, &index);
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 1, &value, &index);
+
+	zval_ptr_dtor(&buffer);
 
 	RETVAL_DOUBLE(value);
 }
@@ -385,26 +479,37 @@ void tensor_buffer_min(zval * return_value, zval * obj)
  */
 void tensor_buffer_max(zval * return_value, zval * obj)
 {
-	uint8_t kind = zephir_buffer_kind(obj);
-	zend_long len = zephir_buffer_len(obj);
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+	double value = 0.0;
+	zend_long index = 0;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
 
 	if (UNEXPECTED(kind == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
 	if (UNEXPECTED(len == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Cannot compute the maximum of an empty buffer."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
-	double value = 0.0;
-	zend_long index = 0;
-
 	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len, 0, &value, &index);
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 0, &value, &index);
+
+	zval_ptr_dtor(&buffer);
 
 	RETVAL_DOUBLE(value);
 }
@@ -417,25 +522,36 @@ void tensor_buffer_max(zval * return_value, zval * obj)
  */
 void tensor_buffer_argmin(zval * return_value, zval * obj)
 {
-	uint8_t kind = zephir_buffer_kind(obj);
-	zend_long len = zephir_buffer_len(obj);
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+	zend_long index = 0;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
 
 	if (UNEXPECTED(kind == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
 	if (UNEXPECTED(len == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Cannot compute the argmin of an empty buffer."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
-	zend_long index = 0;
-
 	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len, 1, NULL, &index);
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 1, NULL, &index);
+
+	zval_ptr_dtor(&buffer);
 
 	RETVAL_LONG(index);
 }
@@ -448,25 +564,36 @@ void tensor_buffer_argmin(zval * return_value, zval * obj)
  */
 void tensor_buffer_argmax(zval * return_value, zval * obj)
 {
-	uint8_t kind = zephir_buffer_kind(obj);
-	zend_long len = zephir_buffer_len(obj);
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+	zend_long index = 0;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
 
 	if (UNEXPECTED(kind == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
 	if (UNEXPECTED(len == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
 			SL("Cannot compute the argmax of an empty buffer."));
+		zval_ptr_dtor(&buffer);
 		return;
 	}
 
-	zend_long index = 0;
-
 	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(obj) : (const void *) zephir_buffer_doubles(obj), len, 0, NULL, &index);
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 0, NULL, &index);
+
+	zval_ptr_dtor(&buffer);
 
 	RETVAL_LONG(index);
 }
diff --git a/ext/include/buffer.h b/ext/include/buffer.h
index 799a8cf..f864e16 100644
--- a/ext/include/buffer.h
+++ b/ext/include/buffer.h
@@ -24,10 +24,10 @@ int tensor_tensorbuffer_create(zval * ret, zend_long len, zval * buffer);
  * success with a NULL pointer and `*len` of 0. */
 double * tensor_tensorbuffer_doubles(zval * obj, zend_long * len, int * success);
 
-/* Build an object of the kernel `Tensor\Buffer` class from a PHP array of
- * values, casting every element to a double. Passed arrays must be 1-d and
- * positionally indexed; keys are discarded. Returns FAILURE (NULL zval) on
- * invalid input. Used to seed TensorBuffers from arrays in Zephir. */
+/* Build a `Tensor\TensorBuffer` decorator from a PHP array of values, casting
+ * every element to a double. Passed arrays must be 1-d and positionally
+ * indexed; keys are discarded. On failure `ret` is set to NULL. Used to seed
+ * tensor classes from arrays in Zephir. */
 void tensor_buffer_from_array(zval * ret, zval * arr);
 
 void tensor_buffer_sort(zval * return_value, zval * obj, zval * ascending);
diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index 68fa8f9..511f8db 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -82,7 +82,7 @@ PHP_METHOD(Tensor_ColumnVector, transpose)
 
 	object_init_ex(return_value, tensor_vector_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 3, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -192,7 +192,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -274,7 +274,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -356,7 +356,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -438,7 +438,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -520,7 +520,7 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -602,7 +602,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -684,7 +684,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -766,7 +766,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -848,7 +848,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -930,7 +930,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1012,7 +1012,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1094,7 +1094,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/cholesky.zep.c b/ext/tensor/decompositions/cholesky.zep.c
index 3da199d..42d1c40 100644
--- a/ext/tensor/decompositions/cholesky.zep.c
+++ b/ext/tensor/decompositions/cholesky.zep.c
@@ -106,9 +106,9 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_8, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 15, &l, &_7, &_8);
+	ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 14, &l, &_7, &_8);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 22, &_6);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/eigen.zep.c b/ext/tensor/decompositions/eigen.zep.c
index de6b764..ff5bce4 100644
--- a/ext/tensor/decompositions/eigen.zep.c
+++ b/ext/tensor/decompositions/eigen.zep.c
@@ -151,12 +151,12 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_15, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, &_12, "__construct", NULL, 15, &_13, &_14, &_15);
+	ZEPHIR_CALL_METHOD(NULL, &_12, "__construct", NULL, 14, &_13, &_14, &_15);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&eigenvectors, &_12, "transpose", NULL, 23);
+	ZEPHIR_CALL_METHOD(&eigenvectors, &_12, "transpose", NULL, 22);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_eigen_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 24, &eigenvalues, &eigenvectors);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &eigenvalues, &eigenvectors);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/lu.zep.c b/ext/tensor/decompositions/lu.zep.c
index bdc667b..9adc3d7 100644
--- a/ext/tensor/decompositions/lu.zep.c
+++ b/ext/tensor/decompositions/lu.zep.c
@@ -138,7 +138,7 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_10, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, &l, "__construct", NULL, 15, &_8, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, &l, "__construct", NULL, 14, &_8, &_9, &_10);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&u);
 	object_init_ex(&u, tensor_matrix_ce);
@@ -147,7 +147,7 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_13, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, &u, "__construct", NULL, 15, &_11, &_12, &_13);
+	ZEPHIR_CALL_METHOD(NULL, &u, "__construct", NULL, 14, &_11, &_12, &_13);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&p);
 	object_init_ex(&p, tensor_matrix_ce);
@@ -156,10 +156,10 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_16, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, &p, "__construct", NULL, 15, &_14, &_15, &_16);
+	ZEPHIR_CALL_METHOD(NULL, &p, "__construct", NULL, 14, &_14, &_15, &_16);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_lu_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &l, &u, &p);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 24, &l, &u, &p);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/svd.zep.c b/ext/tensor/decompositions/svd.zep.c
index 6c48761..2636dff 100644
--- a/ext/tensor/decompositions/svd.zep.c
+++ b/ext/tensor/decompositions/svd.zep.c
@@ -116,7 +116,7 @@ PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_7, a, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, &u, "__construct", NULL, 15, &_5, &_6, &_7);
+	ZEPHIR_CALL_METHOD(NULL, &u, "__construct", NULL, 14, &_5, &_6, &_7);
 	zephir_check_call_status();
 	zephir_memory_observe(&_8);
 	zephir_array_fetch_long(&_8, &usvT, 1, PH_NOISY, "tensor/decompositions/svd.zep", 56);
@@ -129,10 +129,10 @@ PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_12, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, &vT, "__construct", NULL, 15, &_10, &_11, &_12);
+	ZEPHIR_CALL_METHOD(NULL, &vT, "__construct", NULL, 14, &_10, &_11, &_12);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_svd_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 26, &u, &singularValues, &vT);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &u, &singularValues, &vT);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index b64b572..1d6e04c 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -256,7 +256,7 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 	zephir_fetch_params(1, 1, 0, &elements_param);
 	zephir_get_arrval(&elements, elements_param);
 	n = zephir_fast_count_int(&elements);
-	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 27, &elements);
+	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 26, &elements);
 	zephir_check_call_status();
 	ZEPHIR_CPY_WRT(&elements, &_0);
 	ZEPHIR_INIT_VAR(&a);
@@ -884,12 +884,12 @@ PHP_METHOD(Tensor_Matrix, uniform)
  */
 PHP_METHOD(Tensor_Matrix, fromArray)
 {
-	zval _6$$4, _9$$6;
+	zval _4$$4, _7$$6;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_2 = NULL, *_13 = NULL;
+	zephir_fcall_cache_entry *_11 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, rows, i = 0;
-	zend_bool validate, _7$$5, _10$$5, _20$$5;
-	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, aList, buffer, _21, _22, buffer$$3, _0$$3, _1$$3, _3$$3, _4$$3, _5$$4, *_16$$5, _17$$5, *_18$$5, _19$$5, _8$$6, _11$$7, _12$$7, _14$$7, _15$$7;
+	zend_bool validate, _5$$5, _8$$5, _18$$5;
+	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, aList, buffer, _19, buffer$$3, _0$$3, _1$$3, _2$$3, _3$$4, *_14$$5, _15$$5, *_16$$5, _17$$5, _6$$6, _9$$7, _10$$7, _12$$7, _13$$7;
 	zval a, flat;
 
 	ZVAL_UNDEF(&a);
@@ -900,23 +900,21 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZVAL_UNDEF(&n);
 	ZVAL_UNDEF(&aList);
 	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_21);
-	ZVAL_UNDEF(&_22);
+	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&buffer$$3);
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&_1$$3);
-	ZVAL_UNDEF(&_3$$3);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$4);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$4);
+	ZVAL_UNDEF(&_15$$5);
 	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_19$$5);
-	ZVAL_UNDEF(&_8$$6);
-	ZVAL_UNDEF(&_11$$7);
+	ZVAL_UNDEF(&_6$$6);
+	ZVAL_UNDEF(&_9$$7);
+	ZVAL_UNDEF(&_10$$7);
 	ZVAL_UNDEF(&_12$$7);
-	ZVAL_UNDEF(&_14$$7);
-	ZVAL_UNDEF(&_15$$7);
-	ZVAL_UNDEF(&_6$$4);
-	ZVAL_UNDEF(&_9$$6);
+	ZVAL_UNDEF(&_13$$7);
+	ZVAL_UNDEF(&_4$$4);
+	ZVAL_UNDEF(&_7$$6);
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
 		Z_PARAM_OPTIONAL
@@ -937,28 +935,24 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 		array_init(&_0$$3);
 		tensor_buffer_from_array(&buffer$$3, &_0$$3);
 		object_init_ex(return_value, tensor_matrix_ce);
-		ZEPHIR_INIT_VAR(&_1$$3);
-		object_init_ex(&_1$$3, tensor_tensorbuffer_ce);
-		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", &_2, 13, &buffer$$3);
-		zephir_check_call_status();
-		ZVAL_LONG(&_3$$3, 0);
-		ZVAL_LONG(&_4$$3, 0);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_1$$3, &_3$$3, &_4$$3);
+		ZVAL_LONG(&_1$$3, 0);
+		ZVAL_LONG(&_2$$3, 0);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &buffer$$3, &_1$$3, &_2$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	ZEPHIR_CALL_FUNCTION(&aList, "array_values", NULL, 27, &a);
+	ZEPHIR_CALL_FUNCTION(&aList, "array_values", NULL, 26, &a);
 	zephir_check_call_status();
 	zephir_memory_observe(&firstRow);
 	zephir_array_fetch_long(&firstRow, &aList, 0, PH_NOISY, "tensor/matrix.zep", 377);
 	if (UNEXPECTED(!(Z_TYPE_P(&firstRow) == IS_ARRAY))) {
-		ZEPHIR_INIT_VAR(&_5$$4);
-		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_INIT_VAR(&_6$$4);
-		ZEPHIR_CONCAT_SS(&_6$$4, "Matrix requires an", " array of arrays.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_6$$4);
+		ZEPHIR_INIT_VAR(&_3$$4);
+		object_init_ex(&_3$$4, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_4$$4);
+		ZEPHIR_CONCAT_SS(&_4$$4, "Matrix requires an", " array of arrays.");
+		ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 2, &_4$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 381);
+		zephir_throw_exception_debug(&_3$$4, "tensor/matrix.zep", 381);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -973,72 +967,72 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 		}
 		ZEPHIR_OBS_NVAR(&rowA);
 		zephir_array_fetch_long(&rowA, &aList, i, PH_NOISY, "tensor/matrix.zep", 391);
-		_7$$5 = validate;
-		if (_7$$5) {
-			_7$$5 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
+		_5$$5 = validate;
+		if (_5$$5) {
+			_5$$5 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
 		}
-		if (UNEXPECTED(_7$$5)) {
-			ZEPHIR_INIT_NVAR(&_8$$6);
-			object_init_ex(&_8$$6, tensor_exceptions_invalidargumentexception_ce);
-			ZEPHIR_INIT_NVAR(&_9$$6);
-			ZEPHIR_CONCAT_SS(&_9$$6, "Matrix requires an", " array of arrays.");
-			ZEPHIR_CALL_METHOD(NULL, &_8$$6, "__construct", NULL, 2, &_9$$6);
+		if (UNEXPECTED(_5$$5)) {
+			ZEPHIR_INIT_NVAR(&_6$$6);
+			object_init_ex(&_6$$6, tensor_exceptions_invalidargumentexception_ce);
+			ZEPHIR_INIT_NVAR(&_7$$6);
+			ZEPHIR_CONCAT_SS(&_7$$6, "Matrix requires an", " array of arrays.");
+			ZEPHIR_CALL_METHOD(NULL, &_6$$6, "__construct", NULL, 2, &_7$$6);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_8$$6, "tensor/matrix.zep", 395);
+			zephir_throw_exception_debug(&_6$$6, "tensor/matrix.zep", 395);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
-		_10$$5 = validate;
-		if (_10$$5) {
-			_10$$5 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
+		_8$$5 = validate;
+		if (_8$$5) {
+			_8$$5 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
 		}
-		if (UNEXPECTED(_10$$5)) {
-			ZEPHIR_INIT_NVAR(&_11$$7);
-			object_init_ex(&_11$$7, tensor_exceptions_invalidargumentexception_ce);
-			ZEPHIR_CALL_FUNCTION(&_12$$7, "strval", &_13, 3, &n);
+		if (UNEXPECTED(_8$$5)) {
+			ZEPHIR_INIT_NVAR(&_9$$7);
+			object_init_ex(&_9$$7, tensor_exceptions_invalidargumentexception_ce);
+			ZEPHIR_CALL_FUNCTION(&_10$$7, "strval", &_11, 3, &n);
 			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&_14$$7);
-			ZVAL_LONG(&_14$$7, zephir_fast_count_int(&rowA));
-			ZEPHIR_INIT_NVAR(&_15$$7);
-			ZEPHIR_CONCAT_SSVSVS(&_15$$7, "The number of", " columns must be equal for all rows, ", &_12$$7, " needed but ", &_14$$7, " given.");
-			ZEPHIR_CALL_METHOD(NULL, &_11$$7, "__construct", NULL, 2, &_15$$7);
+			ZEPHIR_INIT_NVAR(&_12$$7);
+			ZVAL_LONG(&_12$$7, zephir_fast_count_int(&rowA));
+			ZEPHIR_INIT_NVAR(&_13$$7);
+			ZEPHIR_CONCAT_SSVSVS(&_13$$7, "The number of", " columns must be equal for all rows, ", &_10$$7, " needed but ", &_12$$7, " given.");
+			ZEPHIR_CALL_METHOD(NULL, &_9$$7, "__construct", NULL, 2, &_13$$7);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_11$$7, "tensor/matrix.zep", 401);
+			zephir_throw_exception_debug(&_9$$7, "tensor/matrix.zep", 401);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
 		if (Z_TYPE_P(&rowA) == IS_STRING) {
-			ZEPHIR_INIT_NVAR(&_17$$5);
-			zephir_string_to_char_array(&_17$$5, &rowA);
-			_16$$5 = &_17$$5;
+			ZEPHIR_INIT_NVAR(&_15$$5);
+			zephir_string_to_char_array(&_15$$5, &rowA);
+			_14$$5 = &_15$$5;
 		} else {
-			_16$$5 = &rowA;
+			_14$$5 = &rowA;
 		}
-		zephir_is_iterable(_16$$5, 0, "tensor/matrix.zep", 408);
-		if (Z_TYPE_P(_16$$5) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_16$$5), _18$$5)
+		zephir_is_iterable(_14$$5, 0, "tensor/matrix.zep", 408);
+		if (Z_TYPE_P(_14$$5) == IS_ARRAY) {
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_14$$5), _16$$5)
 			{
 				ZEPHIR_INIT_NVAR(&valueA);
-				ZVAL_COPY(&valueA, _18$$5);
+				ZVAL_COPY(&valueA, _16$$5);
 				zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 405);
 			} ZEND_HASH_FOREACH_END();
 		} else {
-			ZEPHIR_CALL_METHOD(NULL, _16$$5, "rewind", NULL, 0);
+			ZEPHIR_CALL_METHOD(NULL, _14$$5, "rewind", NULL, 0);
 			zephir_check_call_status();
-			_20$$5 = 1;
+			_18$$5 = 1;
 			while (1) {
-				if (_20$$5) {
-					_20$$5 = 0;
+				if (_18$$5) {
+					_18$$5 = 0;
 				} else {
-					ZEPHIR_CALL_METHOD(NULL, _16$$5, "next", NULL, 0);
+					ZEPHIR_CALL_METHOD(NULL, _14$$5, "next", NULL, 0);
 					zephir_check_call_status();
 				}
-				ZEPHIR_CALL_METHOD(&_19$$5, _16$$5, "valid", NULL, 0);
+				ZEPHIR_CALL_METHOD(&_17$$5, _14$$5, "valid", NULL, 0);
 				zephir_check_call_status();
-				if (!zend_is_true(&_19$$5)) {
+				if (!zend_is_true(&_17$$5)) {
 					break;
 				}
-				ZEPHIR_CALL_METHOD(&valueA, _16$$5, "current", NULL, 0);
+				ZEPHIR_CALL_METHOD(&valueA, _14$$5, "current", NULL, 0);
 				zephir_check_call_status();
 					zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 405);
 			}
@@ -1049,12 +1043,8 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 	ZEPHIR_INIT_VAR(&buffer);
 	tensor_buffer_from_array(&buffer, &flat);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_INIT_VAR(&_21);
-	object_init_ex(&_21, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, &_21, "__construct", &_2, 13, &buffer);
-	zephir_check_call_status();
-	ZVAL_LONG(&_22, rows);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_21, &_22, &n);
+	ZVAL_LONG(&_19, rows);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &buffer, &_19, &n);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1335,7 +1325,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 	ZVAL_LONG(&_8, (index * (zend_long) zephir_get_numberval(&_6)));
 	ZEPHIR_CALL_METHOD(&_5, &_4, "slice", NULL, 0, &_8, &_7);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1406,7 +1396,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 	ZVAL_LONG(&_8, index);
 	ZEPHIR_CALL_METHOD(&_5, &_4, "sliceStrided", NULL, 0, &_8, &_6, &_7);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1472,7 +1462,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 	ZVAL_LONG(&_9, (zephir_get_numberval(&_7) + 1));
 	ZEPHIR_CALL_METHOD(&_5, &_4, "sliceStrided", NULL, 0, &_8, &_6, &_9);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1539,7 +1529,7 @@ PHP_METHOD(Tensor_Matrix, asVectors)
 			ZVAL_COPY(&rowBuffer, _6);
 			ZEPHIR_INIT_NVAR(&_7$$4);
 			object_init_ex(&_7$$4, tensor_vector_ce);
-			ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", &_8, 14, &rowBuffer);
+			ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", &_8, 13, &rowBuffer);
 			zephir_check_call_status();
 			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 562);
 		} ZEND_HASH_FOREACH_END();
@@ -1563,7 +1553,7 @@ PHP_METHOD(Tensor_Matrix, asVectors)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_11$$5);
 				object_init_ex(&_11$$5, tensor_vector_ce);
-				ZEPHIR_CALL_METHOD(NULL, &_11$$5, "__construct", &_8, 14, &rowBuffer);
+				ZEPHIR_CALL_METHOD(NULL, &_11$$5, "__construct", &_8, 13, &rowBuffer);
 				zephir_check_call_status();
 				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 562);
 		}
@@ -1626,7 +1616,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			ZVAL_COPY(&columnBuffer, _4);
 			ZEPHIR_INIT_NVAR(&_5$$4);
 			object_init_ex(&_5$$4, tensor_columnvector_ce);
-			ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_6, 14, &columnBuffer);
+			ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_6, 13, &columnBuffer);
 			zephir_check_call_status();
 			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 584);
 		} ZEND_HASH_FOREACH_END();
@@ -1650,7 +1640,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_9$$5);
 				object_init_ex(&_9$$5, tensor_columnvector_ce);
-				ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", &_6, 14, &columnBuffer);
+				ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", &_6, 13, &columnBuffer);
 				zephir_check_call_status();
 				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 584);
 		}
@@ -1681,7 +1671,7 @@ PHP_METHOD(Tensor_Matrix, flatten)
 
 	object_init_ex(return_value, tensor_vector_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1914,12 +1904,14 @@ PHP_METHOD(Tensor_Matrix, map)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *callback, callback_sub, _0, _1, _2, _3;
+	zval *callback, callback_sub, b, _0, _1, buffer, _2, _3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&callback_sub);
+	ZVAL_UNDEF(&b);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&buffer);
 	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
@@ -1941,13 +1933,17 @@ PHP_METHOD(Tensor_Matrix, map)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &callback);
-	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "map", NULL, 0, callback);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_FUNCTION(&b, "array_map", NULL, 15, callback, &_1);
 	zephir_check_call_status();
+	ZEPHIR_INIT_VAR(&buffer);
+	tensor_buffer_from_array(&buffer, &b);
+	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_1, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &buffer, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1995,7 +1991,7 @@ PHP_METHOD(Tensor_Matrix, reduce)
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_2, initial);
-	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 17, &_1, callback, &_2);
+	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 16, &_1, callback, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2042,9 +2038,9 @@ PHP_METHOD(Tensor_Matrix, transpose)
 		RETURN_MM();
 	}
 	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 717);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 721);
 	ZVAL_LONG(&_3, 1);
-	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 28, &cols, &_3);
+	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 27, &cols, &_3);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_2, &col, "concat", NULL, 0, &_4);
 	zephir_check_call_status();
@@ -2052,7 +2048,7 @@ PHP_METHOD(Tensor_Matrix, transpose)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &col, &_3, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &col, &_3, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2107,7 +2103,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 734);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 738);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2118,9 +2114,9 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_5$$4, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 29, &_6$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 28, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 739);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 743);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2133,16 +2129,16 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_9$$5, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_10$$5);
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 29, &_10$$5);
+		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 28, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 746);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 750);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_11, &_12);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_11, &_12);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2193,16 +2189,16 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		object_init_ex(&_3$$3, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 29, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 28, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 763);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 767);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_5, &_6);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_5, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2245,7 +2241,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 779);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 783);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2260,7 +2256,7 @@ PHP_METHOD(Tensor_Matrix, det)
 	ZEPHIR_CALL_METHOD(&_6, &ref, "swaps", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_7, -1.0);
-	ZEPHIR_CALL_FUNCTION(&_8, "pow", NULL, 18, &_7, &_6);
+	ZEPHIR_CALL_FUNCTION(&_8, "pow", NULL, 17, &_7, &_6);
 	zephir_check_call_status();
 	mul_function(return_value, &pi, &_8);
 	RETURN_MM();
@@ -2345,7 +2341,7 @@ PHP_METHOD(Tensor_Matrix, fullRank)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_1, this_ptr, "shape", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 30, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 29, &_1);
 	zephir_check_call_status();
 	RETURN_MM_BOOL(ZEPHIR_IS_IDENTICAL(&_0, &_2));
 }
@@ -2454,7 +2450,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 847);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 851);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2470,7 +2466,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_14, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_13, &_14);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_13, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2529,7 +2525,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 867);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 871);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2627,7 +2623,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 2, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 885);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 889);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2641,7 +2637,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 2, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 890);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 894);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2659,19 +2655,19 @@ PHP_METHOD(Tensor_Matrix, convolve)
 	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_19, ((zephir_get_numberval(&_18) + stride) - 1));
 	ZVAL_LONG(&_20, stride);
-	ZEPHIR_CALL_FUNCTION(&_21, "intdiv", NULL, 19, &_19, &_20);
+	ZEPHIR_CALL_FUNCTION(&_21, "intdiv", NULL, 18, &_19, &_20);
 	zephir_check_call_status();
 	outM = zephir_get_intval(&_21);
 	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_20, ((zephir_get_numberval(&_19) + stride) - 1));
 	ZVAL_LONG(&_22, stride);
-	ZEPHIR_CALL_FUNCTION(&_23, "intdiv", NULL, 19, &_20, &_22);
+	ZEPHIR_CALL_FUNCTION(&_23, "intdiv", NULL, 18, &_20, &_22);
 	zephir_check_call_status();
 	outN = zephir_get_intval(&_23);
 	object_init_ex(return_value, tensor_matrix_ce);
 	ZVAL_LONG(&_20, outM);
 	ZVAL_LONG(&_22, outN);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_20, &_22);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_20, &_22);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2978,7 +2974,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1034);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1038);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3049,7 +3045,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1067);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1071);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3121,7 +3117,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1101);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1105);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3193,7 +3189,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1135);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1139);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3265,7 +3261,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1169);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1173);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3337,7 +3333,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1203);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1207);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3409,7 +3405,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1237);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1241);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3481,7 +3477,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1271);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1275);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3553,7 +3549,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1305);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1309);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3625,7 +3621,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1339);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1343);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3697,7 +3693,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1373);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1377);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3769,7 +3765,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1407);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1411);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3846,7 +3842,7 @@ PHP_METHOD(Tensor_Matrix, abs)
 	tensor_abs(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3906,7 +3902,7 @@ PHP_METHOD(Tensor_Matrix, sqrt)
 	tensor_sqrt(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3948,7 +3944,7 @@ PHP_METHOD(Tensor_Matrix, exp)
 	tensor_exp(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3990,7 +3986,7 @@ PHP_METHOD(Tensor_Matrix, expm1)
 	tensor_expm1(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4050,7 +4046,7 @@ PHP_METHOD(Tensor_Matrix, log)
 		tensor_log(&_0$$3, &_1$$3);
 		zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 		zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0$$3, &_2$$3, &_3$$3);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0$$3, &_2$$3, &_3$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
@@ -4061,7 +4057,7 @@ PHP_METHOD(Tensor_Matrix, log)
 	tensor_log_base(&_4, &_5, &_6);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_4, &_7, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_4, &_7, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4103,7 +4099,7 @@ PHP_METHOD(Tensor_Matrix, log1p)
 	tensor_log1p(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4145,7 +4141,7 @@ PHP_METHOD(Tensor_Matrix, sin)
 	tensor_sin(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4187,7 +4183,7 @@ PHP_METHOD(Tensor_Matrix, asin)
 	tensor_asin(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4229,7 +4225,7 @@ PHP_METHOD(Tensor_Matrix, cos)
 	tensor_cos(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4271,7 +4267,7 @@ PHP_METHOD(Tensor_Matrix, acos)
 	tensor_acos(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4313,7 +4309,7 @@ PHP_METHOD(Tensor_Matrix, tan)
 	tensor_tan(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4355,7 +4351,7 @@ PHP_METHOD(Tensor_Matrix, atan)
 	tensor_atan(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4397,7 +4393,7 @@ PHP_METHOD(Tensor_Matrix, rad2deg)
 	tensor_rad2deg(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4439,7 +4435,7 @@ PHP_METHOD(Tensor_Matrix, deg2rad)
 	tensor_deg2rad(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4492,15 +4488,15 @@ PHP_METHOD(Tensor_Matrix, sum)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1592);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1596);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
 			ZEPHIR_INIT_NVAR(&rowBuffer);
 			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "sum", NULL, 0);
-			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1589);
+			ZEPHIR_INIT_NVAR(&_6$$3);
+			tensor_buffer_sum(&_6$$3, &rowBuffer);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1593);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4520,9 +4516,9 @@ PHP_METHOD(Tensor_Matrix, sum)
 			}
 			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "sum", NULL, 0);
-				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1589);
+				ZEPHIR_INIT_NVAR(&_9$$4);
+				tensor_buffer_sum(&_9$$4, &rowBuffer);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1593);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4580,15 +4576,15 @@ PHP_METHOD(Tensor_Matrix, product)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1610);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1614);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
 			ZEPHIR_INIT_NVAR(&rowBuffer);
 			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "product", NULL, 0);
-			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1607);
+			ZEPHIR_INIT_NVAR(&_6$$3);
+			tensor_buffer_product(&_6$$3, &rowBuffer);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1611);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4608,9 +4604,9 @@ PHP_METHOD(Tensor_Matrix, product)
 			}
 			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "product", NULL, 0);
-				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1607);
+				ZEPHIR_INIT_NVAR(&_9$$4);
+				tensor_buffer_product(&_9$$4, &rowBuffer);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1611);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4668,15 +4664,15 @@ PHP_METHOD(Tensor_Matrix, min)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1628);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1632);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
 			ZEPHIR_INIT_NVAR(&rowBuffer);
 			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "min", NULL, 0);
-			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1625);
+			ZEPHIR_INIT_NVAR(&_6$$3);
+			tensor_buffer_min(&_6$$3, &rowBuffer);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1629);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4696,9 +4692,9 @@ PHP_METHOD(Tensor_Matrix, min)
 			}
 			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "min", NULL, 0);
-				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1625);
+				ZEPHIR_INIT_NVAR(&_9$$4);
+				tensor_buffer_min(&_9$$4, &rowBuffer);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1629);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4756,15 +4752,103 @@ PHP_METHOD(Tensor_Matrix, max)
 	} else {
 		_3 = &_1;
 	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1646);
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1650);
 	if (Z_TYPE_P(_3) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
 		{
 			ZEPHIR_INIT_NVAR(&rowBuffer);
 			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_CALL_METHOD(&_6$$3, &rowBuffer, "max", NULL, 0);
+			ZEPHIR_INIT_NVAR(&_6$$3);
+			tensor_buffer_max(&_6$$3, &rowBuffer);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1647);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_8 = 1;
+		while (1) {
+			if (_8) {
+				_8 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
+				zephir_check_call_status();
+			}
+			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1643);
+			if (!zend_is_true(&_7)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_9$$4);
+				tensor_buffer_max(&_9$$4, &rowBuffer);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1647);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&rowBuffer);
+	ZVAL_BOOL(&_10, 0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return the index of the minimum of each row in the matrix.
+ *
+ * @return \Tensor\ColumnVector
+ */
+PHP_METHOD(Tensor_Matrix, argmin)
+{
+	zend_bool _8;
+	zval b;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&rowBuffer);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_9$$4);
+	ZVAL_UNDEF(&b);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
+	} else {
+		_3 = &_1;
+	}
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1668);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
+		{
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _5);
+			ZEPHIR_INIT_NVAR(&_6$$3);
+			tensor_buffer_argmin(&_6$$3, &rowBuffer);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1665);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
@@ -4784,9 +4868,97 @@ PHP_METHOD(Tensor_Matrix, max)
 			}
 			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
 			zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(&_9$$4, &rowBuffer, "max", NULL, 0);
+				ZEPHIR_INIT_NVAR(&_9$$4);
+				tensor_buffer_argmin(&_9$$4, &rowBuffer);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1665);
+		}
+	}
+	ZEPHIR_INIT_NVAR(&rowBuffer);
+	ZVAL_BOOL(&_10, 0);
+	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
+	zephir_check_call_status();
+	RETURN_MM();
+}
+
+/**
+ * Return the index of the maximum of each row in the matrix.
+ *
+ * @return \Tensor\ColumnVector
+ */
+PHP_METHOD(Tensor_Matrix, argmax)
+{
+	zend_bool _8;
+	zval b;
+	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&rowBuffer);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_9$$4);
+	ZVAL_UNDEF(&b);
+	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_INIT_VAR(&b);
+	array_init(&b);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
+	zephir_check_call_status();
+	if (Z_TYPE_P(&_1) == IS_STRING) {
+		ZEPHIR_INIT_VAR(&_4);
+		zephir_string_to_char_array(&_4, &_1);
+		_3 = &_4;
+	} else {
+		_3 = &_1;
+	}
+	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1686);
+	if (Z_TYPE_P(_3) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
+		{
+			ZEPHIR_INIT_NVAR(&rowBuffer);
+			ZVAL_COPY(&rowBuffer, _5);
+			ZEPHIR_INIT_NVAR(&_6$$3);
+			tensor_buffer_argmax(&_6$$3, &rowBuffer);
+			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1683);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_8 = 1;
+		while (1) {
+			if (_8) {
+				_8 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1643);
+			}
+			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_7)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
+			zephir_check_call_status();
+				ZEPHIR_INIT_NVAR(&_9$$4);
+				tensor_buffer_argmax(&_9$$4, &rowBuffer);
+				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1683);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -4876,7 +5048,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_1, 2);
-	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 19, &_0, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 18, &_0, &_1);
 	zephir_check_call_status();
 	mid = zephir_get_intval(&_2);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
@@ -4892,7 +5064,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	} else {
 		_6 = &_4;
 	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1686);
+	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1726);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -4916,7 +5088,7 @@ PHP_METHOD(Tensor_Matrix, median)
 				ZEPHIR_INIT_NVAR(&median);
 				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
 			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1683);
+			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1723);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -4954,7 +5126,7 @@ PHP_METHOD(Tensor_Matrix, median)
 					ZEPHIR_INIT_NVAR(&median);
 					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
 				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1683);
+				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1723);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5042,7 +5214,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1700);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1740);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5063,7 +5235,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	} else {
 		_9 = &_7;
 	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1729);
+	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1769);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5079,7 +5251,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1719);
+				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1759);
 				continue;
 			}
 			ZVAL_LONG(&_18$$4, (xHat - 1));
@@ -5091,7 +5263,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 			zephir_check_call_status();
 			ZEPHIR_INIT_NVAR(&_20$$4);
 			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1726);
+			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1766);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5121,7 +5293,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 					zephir_check_call_status();
 					ZEPHIR_INIT_NVAR(&_27$$7);
 					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1719);
+					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1759);
 					continue;
 				}
 				ZVAL_LONG(&_29$$6, (xHat - 1));
@@ -5133,7 +5305,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 				zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_31$$6);
 				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1726);
+				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1766);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -5209,7 +5381,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1745);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1785);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5229,7 +5401,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 2, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1751);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1791);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5318,7 +5490,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 2, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1776);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1816);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5414,7 +5586,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		tensor_round(&_0$$3, &_1$$3, &_2$$3);
 		zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 		zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0$$3, &_3$$3, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0$$3, &_3$$3, &_4$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
@@ -5428,7 +5600,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less than 0, ", &_7$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1803);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1843);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5445,7 +5617,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	} else {
 		_12 = &_10;
 	}
-	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1826);
+	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1866);
 	if (Z_TYPE_P(_12) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
 		{
@@ -5468,7 +5640,7 @@ PHP_METHOD(Tensor_Matrix, round)
 				zephir_check_call_status();
 				i++;
 			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1823);
+			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1863);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
@@ -5505,7 +5677,7 @@ PHP_METHOD(Tensor_Matrix, round)
 					zephir_check_call_status();
 					i++;
 				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1823);
+				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1863);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowA);
@@ -5514,7 +5686,7 @@ PHP_METHOD(Tensor_Matrix, round)
 	zephir_check_call_status();
 	zephir_read_property_cached(&_30, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_31, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_29, &_30, &_31);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_29, &_30, &_31);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5556,7 +5728,7 @@ PHP_METHOD(Tensor_Matrix, floor)
 	tensor_floor(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5598,7 +5770,7 @@ PHP_METHOD(Tensor_Matrix, ceil)
 	tensor_ceil(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5658,7 +5830,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1862);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1902);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5670,7 +5842,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 	tensor_clip(&_2, &_3, &_4, &_5);
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_2, &_6, &_7);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_2, &_6, &_7);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5721,7 +5893,7 @@ PHP_METHOD(Tensor_Matrix, clipLower)
 	tensor_clip_lower(&_0, &_1, &_2);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_3, &_4);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_3, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5772,7 +5944,7 @@ PHP_METHOD(Tensor_Matrix, clipUpper)
 	tensor_clip_upper(&_0, &_1, &_2);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_3, &_4);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_3, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5814,7 +5986,7 @@ PHP_METHOD(Tensor_Matrix, sign)
 	tensor_sign(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5856,7 +6028,7 @@ PHP_METHOD(Tensor_Matrix, negate)
 	tensor_negate(&_0, &_1);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5935,7 +6107,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1928);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1968);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5954,7 +6126,7 @@ PHP_METHOD(Tensor_Matrix, augmentAbove)
 	ZEPHIR_INIT_VAR(&_15);
 	zephir_add_function(&_15, &_13, &_14);
 	zephir_read_property_cached(&_14, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &buffer, &_15, &_14);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &buffer, &_15, &_14);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6033,7 +6205,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1948);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1988);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6052,7 +6224,7 @@ PHP_METHOD(Tensor_Matrix, augmentBelow)
 	ZEPHIR_INIT_VAR(&_15);
 	zephir_add_function(&_15, &_13, &_14);
 	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &buffer, &_15, &_13);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &buffer, &_15, &_13);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6143,7 +6315,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1968);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2008);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6186,7 +6358,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1982);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2022);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -6198,7 +6370,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&_27);
 	zephir_add_function(&_27, &_25, &_26);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_23, &_24, &_27);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_23, &_24, &_27);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6289,7 +6461,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2000);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2040);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6332,7 +6504,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2014);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2054);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -6344,7 +6516,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&_27);
 	zephir_add_function(&_27, &_25, &_26);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_23, &_24, &_27);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_23, &_24, &_27);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6420,7 +6592,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		} else {
 			_3$$3 = &_1$$3;
 		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2038);
+		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2078);
 		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
 			{
@@ -6429,7 +6601,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 				ZVAL_LONG(&_7$$4, (n + 1));
 				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
 				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2036);
+				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2076);
 			} ZEND_HASH_FOREACH_END();
 		} else {
 			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
@@ -6452,16 +6624,16 @@ PHP_METHOD(Tensor_Matrix, repeat)
 					ZVAL_LONG(&_11$$5, (n + 1));
 					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
 					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2036);
+					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2076);
 			}
 		}
 		ZEPHIR_INIT_NVAR(&rowA);
 	}
 	if (zephir_fast_count_int(&bigRows) > 0) {
 		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2041);
+		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2081);
 		ZVAL_LONG(&_13$$6, 1);
-		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 28, &bigRows, &_13$$6);
+		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 27, &bigRows, &_13$$6);
 		zephir_check_call_status();
 		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "concat", NULL, 0, &_14$$6);
 		zephir_check_call_status();
@@ -6475,7 +6647,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		zephir_read_property_cached(&_15$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 		ZVAL_LONG(&_16$$6, (zephir_get_numberval(&_13$$6) * ((m + 1))));
 		ZVAL_LONG(&_17$$6, (zephir_get_numberval(&_15$$6) * ((n + 1))));
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &flat$$6, &_16$$6, &_17$$6);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &flat$$6, &_16$$6, &_17$$6);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
@@ -6547,7 +6719,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2064);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2104);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6558,7 +6730,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6623,7 +6795,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2083);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2123);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6634,7 +6806,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6699,7 +6871,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2102);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2142);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6710,7 +6882,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6775,7 +6947,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2121);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2161);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6786,7 +6958,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6852,7 +7024,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2141);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2181);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6863,7 +7035,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6929,7 +7101,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2161);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2201);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6940,7 +7112,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7006,7 +7178,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2181);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2221);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7017,7 +7189,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7082,7 +7254,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2200);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2240);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7093,7 +7265,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7159,7 +7331,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2220);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2260);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7170,7 +7342,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7236,7 +7408,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2240);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2280);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7247,7 +7419,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7312,7 +7484,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2259);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2299);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7323,7 +7495,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7388,7 +7560,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2278);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2318);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7399,7 +7571,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_8, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_8, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7469,7 +7641,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2298);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2338);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7482,7 +7654,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7552,7 +7724,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2322);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2362);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7565,7 +7737,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7635,7 +7807,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2346);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2386);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7648,7 +7820,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7718,7 +7890,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2370);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2410);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7731,7 +7903,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7801,7 +7973,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2394);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2434);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7814,7 +7986,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7884,7 +8056,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2418);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2458);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7897,7 +8069,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -7968,7 +8140,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2443);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2483);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7981,7 +8153,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8051,7 +8223,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2467);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2507);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8064,7 +8236,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8134,7 +8306,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2491);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2531);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8147,7 +8319,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8217,7 +8389,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2515);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2555);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8230,7 +8402,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8300,7 +8472,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2539);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2579);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8313,7 +8485,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8384,7 +8556,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2564);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2604);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8397,7 +8569,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8467,7 +8639,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2588);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2628);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8480,7 +8652,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8550,7 +8722,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2612);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2652);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8563,7 +8735,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8633,7 +8805,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2636);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2676);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8646,7 +8818,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8716,7 +8888,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2660);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2700);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8729,7 +8901,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8799,7 +8971,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2684);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2724);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8812,7 +8984,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8882,7 +9054,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2708);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2748);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8895,7 +9067,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -8965,7 +9137,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2732);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2772);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8978,7 +9150,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9048,7 +9220,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2756);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2796);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9061,7 +9233,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9131,7 +9303,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2780);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2820);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9144,7 +9316,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9214,7 +9386,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2804);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2844);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9227,7 +9399,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9297,7 +9469,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2828);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2868);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9310,7 +9482,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9380,7 +9552,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2852);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2892);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9393,7 +9565,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_10, &_11);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9444,7 +9616,7 @@ PHP_METHOD(Tensor_Matrix, multiplyScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9495,7 +9667,7 @@ PHP_METHOD(Tensor_Matrix, divideScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9546,7 +9718,7 @@ PHP_METHOD(Tensor_Matrix, addScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9597,7 +9769,7 @@ PHP_METHOD(Tensor_Matrix, subtractScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9648,7 +9820,7 @@ PHP_METHOD(Tensor_Matrix, powScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9699,7 +9871,7 @@ PHP_METHOD(Tensor_Matrix, modScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9750,7 +9922,7 @@ PHP_METHOD(Tensor_Matrix, equalScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9801,7 +9973,7 @@ PHP_METHOD(Tensor_Matrix, notEqualScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9852,7 +10024,7 @@ PHP_METHOD(Tensor_Matrix, greaterScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9904,7 +10076,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -9955,7 +10127,7 @@ PHP_METHOD(Tensor_Matrix, lessScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10007,7 +10179,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualScalar)
 	object_init_ex(return_value, tensor_matrix_ce);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_2, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_2, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10044,7 +10216,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3037);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3077);
 	return;
 }
 
@@ -10095,7 +10267,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3061);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3101);
 	return;
 }
 
@@ -10155,7 +10327,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3075);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3115);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10172,7 +10344,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3080);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3120);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10184,7 +10356,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 	zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_9, &_8, "slice", NULL, 0, &_11, &_10);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10208,7 +10380,7 @@ PHP_METHOD(Tensor_Matrix, getIterator)
 	object_init_ex(return_value, spl_ce_ArrayIterator);
 	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asVectors", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 20, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -10295,16 +10467,16 @@ PHP_METHOD(Tensor_Matrix, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3123);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3163);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_2, &rebuilt, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_2);
-	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3126);
+	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3166);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_3);
-	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3127);
+	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3167);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_4);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/ext/tensor/matrix.zep.h b/ext/tensor/matrix.zep.h
index 0ae0733..cf5346d 100644
--- a/ext/tensor/matrix.zep.h
+++ b/ext/tensor/matrix.zep.h
@@ -85,6 +85,8 @@ PHP_METHOD(Tensor_Matrix, sum);
 PHP_METHOD(Tensor_Matrix, product);
 PHP_METHOD(Tensor_Matrix, min);
 PHP_METHOD(Tensor_Matrix, max);
+PHP_METHOD(Tensor_Matrix, argmin);
+PHP_METHOD(Tensor_Matrix, argmax);
 PHP_METHOD(Tensor_Matrix, mean);
 PHP_METHOD(Tensor_Matrix, median);
 PHP_METHOD(Tensor_Matrix, quantile);
@@ -452,6 +454,12 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_max, 0, 0, Tensor\\ColumnVector, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_argmin, 0, 0, Tensor\\ColumnVector, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_argmax, 0, 0, Tensor\\ColumnVector, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_matrix_mean, 0, 0, Tensor\\ColumnVector, 0)
 ZEND_END_ARG_INFO()
 
@@ -827,6 +835,8 @@ ZEPHIR_INIT_FUNCS(tensor_matrix_method_entry) {
 	PHP_ME(Tensor_Matrix, product, arginfo_tensor_matrix_product, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, min, arginfo_tensor_matrix_min, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, max, arginfo_tensor_matrix_max, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, argmin, arginfo_tensor_matrix_argmin, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Matrix, argmax, arginfo_tensor_matrix_argmax, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, mean, arginfo_tensor_matrix_mean, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, median, arginfo_tensor_matrix_median, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Matrix, quantile, arginfo_tensor_matrix_quantile, ZEND_ACC_PUBLIC)
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index 251d8cd..b45afed 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -108,14 +108,14 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_7, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, &b, "__construct", NULL, 15, &_5, &_6, &_7);
+	ZEPHIR_CALL_METHOD(NULL, &b, "__construct", NULL, 14, &_5, &_6, &_7);
 	zephir_check_call_status();
 	zephir_memory_observe(&_8);
 	zephir_array_fetch_long(&_8, &ref, 1, PH_NOISY, "tensor/reductions/ref.zep", 52);
 	swaps = zephir_get_intval(&_8);
 	object_init_ex(return_value, tensor_reductions_ref_ce);
 	ZVAL_LONG(&_9, swaps);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 30, &b, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index 51ebf56..ae98634 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -86,9 +86,9 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_5, a, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 15, &result, &_4, &_5);
+	ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 14, &result, &_4, &_5);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/special.zep.c b/ext/tensor/special.zep.c
index 893009a..2ce658e 100644
--- a/ext/tensor/special.zep.c
+++ b/ext/tensor/special.zep.c
@@ -43,6 +43,18 @@ ZEPHIR_DOC_METHOD(Tensor_Special, min);
  * @return mixed
  */
 ZEPHIR_DOC_METHOD(Tensor_Special, max);
+/**
+ * Return the index (or per-row indices) of the minimum of the tensor.
+ *
+ * @return mixed
+ */
+ZEPHIR_DOC_METHOD(Tensor_Special, argmin);
+/**
+ * Return the index (or per-row indices) of the maximum of the tensor.
+ *
+ * @return mixed
+ */
+ZEPHIR_DOC_METHOD(Tensor_Special, argmax);
 /**
  * Clip the tensor to be between the given minimum and maximum.
  *
diff --git a/ext/tensor/special.zep.h b/ext/tensor/special.zep.h
index da9312d..f43bfcc 100644
--- a/ext/tensor/special.zep.h
+++ b/ext/tensor/special.zep.h
@@ -15,6 +15,12 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_special_max, 0, 0, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_special_argmin, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_special_argmax, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_INFO_EX(arginfo_tensor_special_clip, 0, 0, 2)
 	ZEND_ARG_TYPE_INFO(0, min, IS_DOUBLE, 0)
 	ZEND_ARG_TYPE_INFO(0, max, IS_DOUBLE, 0)
@@ -33,6 +39,8 @@ ZEPHIR_INIT_FUNCS(tensor_special_method_entry) {
 	PHP_ABSTRACT_ME(Tensor_Special, product, arginfo_tensor_special_product)
 	PHP_ABSTRACT_ME(Tensor_Special, min, arginfo_tensor_special_min)
 	PHP_ABSTRACT_ME(Tensor_Special, max, arginfo_tensor_special_max)
+	PHP_ABSTRACT_ME(Tensor_Special, argmin, arginfo_tensor_special_argmin)
+	PHP_ABSTRACT_ME(Tensor_Special, argmax, arginfo_tensor_special_argmax)
 	PHP_ABSTRACT_ME(Tensor_Special, clip, arginfo_tensor_special_clip)
 	PHP_ABSTRACT_ME(Tensor_Special, clipLower, arginfo_tensor_special_cliplower)
 	PHP_ABSTRACT_ME(Tensor_Special, clipUpper, arginfo_tensor_special_clipupper)
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 0b683a0..06cf1f3 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -13,8 +13,8 @@
 
 #include "kernel/main.h"
 #include "kernel/memory.h"
-#include "kernel/fcall.h"
 #include "kernel/array.h"
+#include "kernel/fcall.h"
 #include "kernel/operators.h"
 #include "kernel/object.h"
 #include "kernel/exception.h"
@@ -26,8 +26,9 @@
 /**
  * TensorBuffer
  *
- * A decorator that wraps the kernel Buffer class and provides additional
- * operations such as sorting and slicing.
+ * A decorator that wraps the kernel Buffer class and provides structural
+ * operations such as sorting, slicing, splitting, concatenating, and
+ * repeating.
  *
  * @internal
  *
@@ -59,19 +60,15 @@ PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
 {
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS, rows;
-	zval *buffers_param = NULL, b, _3, _4, _5, _6, zero$$3, _0$$3, _1$$4, _2$$4;
+	zval *buffers_param = NULL, _2, _3, _4, _0$$3, _1$$4;
 	zval buffers;
 
 	ZVAL_UNDEF(&buffers);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_2);
 	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&zero$$3);
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&_1$$4);
-	ZVAL_UNDEF(&_2$$4);
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		ZEPHIR_Z_PARAM_ARRAY(buffers, buffers_param)
 	ZEND_PARSE_PARAMETERS_END();
@@ -81,36 +78,22 @@ PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
 	zephir_get_arrval(&buffers, buffers_param);
 	rows = zephir_fast_count_int(&buffers);
 	if (UNEXPECTED(rows < 1)) {
-		ZEPHIR_INIT_VAR(&zero$$3);
 		ZEPHIR_INIT_VAR(&_0$$3);
 		array_init(&_0$$3);
-		tensor_buffer_from_array(&zero$$3, &_0$$3);
-		object_init_ex(return_value, tensor_tensorbuffer_ce);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &zero$$3);
-		zephir_check_call_status();
+		tensor_buffer_from_array(return_value, &_0$$3);
 		RETURN_MM();
 	}
 	if (UNEXPECTED(rows == 1)) {
-		object_init_ex(return_value, tensor_tensorbuffer_ce);
 		zephir_memory_observe(&_1$$4);
-		zephir_array_fetch_long(&_1$$4, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 44);
-		ZEPHIR_CALL_METHOD(&_2$$4, &_1$$4, "asBuffer", NULL, 0);
-		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_2$$4);
-		zephir_check_call_status();
-		RETURN_MM();
+		zephir_array_fetch_long(&_1$$4, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 43);
+		RETURN_CCTOR(&_1$$4);
 	}
-	zephir_memory_observe(&_3);
-	zephir_array_fetch_long(&_3, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 47);
-	ZVAL_LONG(&_4, 1);
-	ZEPHIR_CALL_FUNCTION(&_5, "array_slice", NULL, 28, &buffers, &_4);
-	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&b, &_3, "concat", NULL, 0, &_5);
+	zephir_memory_observe(&_2);
+	zephir_array_fetch_long(&_2, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 46);
+	ZVAL_LONG(&_3, 1);
+	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 27, &buffers, &_3);
 	zephir_check_call_status();
-	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(&_6, &b, "asBuffer", NULL, 0);
-	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_6);
+	ZEPHIR_RETURN_CALL_METHOD(&_2, "concat", NULL, 0, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -190,7 +173,7 @@ PHP_METHOD(Tensor_TensorBuffer, get)
 	zephir_fetch_params(1, 1, 0, &index_param);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
 	zephir_memory_observe(&_1);
-	zephir_array_fetch_long(&_1, &_0, index, PH_NOISY, "tensor/tensorbuffer.zep", 78);
+	zephir_array_fetch_long(&_1, &_0, index, PH_NOISY, "tensor/tensorbuffer.zep", 75);
 	RETURN_CCTOR(&_1);
 }
 
@@ -321,7 +304,7 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 		ZEPHIR_CONCAT_SS(&_5$$3, "Offset and length", " must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 116);
+		zephir_throw_exception_debug(&_4$$3, "tensor/tensorbuffer.zep", 113);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -331,175 +314,11 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 	ZVAL_LONG(&_8, length);
 	tensor_buffer_slice(&b, &_6, &_7, &_8);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
 
-/**
- * Map a function over the elements in the buffer and return a new decorator.
- *
- * @internal
- *
- * @param callable callback
- * @return self
- */
-PHP_METHOD(Tensor_TensorBuffer, map)
-{
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *callback, callback_sub, b, _0, _1, buffer;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&callback_sub);
-	ZVAL_UNDEF(&b);
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&buffer);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
-	}
-
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_ZVAL(callback)
-	ZEND_PARSE_PARAMETERS_END();
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-	zephir_fetch_params(1, 1, 0, &callback);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
-	zephir_check_call_status();
-	ZEPHIR_CALL_FUNCTION(&b, "array_map", NULL, 16, callback, &_1);
-	zephir_check_call_status();
-	ZEPHIR_INIT_VAR(&buffer);
-	tensor_buffer_from_array(&buffer, &b);
-	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &buffer);
-	zephir_check_call_status();
-	RETURN_MM();
-}
-
-/**
- * Return the sum of the elements in the buffer.
- *
- * @return float
- */
-PHP_METHOD(Tensor_TensorBuffer, sum)
-{
-	zval _0;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
-	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_sum(return_value, &_0);
-	return;
-}
-
-/**
- * Return the product of the elements in the buffer.
- *
- * @return float
- */
-PHP_METHOD(Tensor_TensorBuffer, product)
-{
-	zval _0;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
-	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_product(return_value, &_0);
-	return;
-}
-
-/**
- * Return the minimum element in the buffer.
- *
- * @return float
- */
-PHP_METHOD(Tensor_TensorBuffer, min)
-{
-	zval _0;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
-	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_min(return_value, &_0);
-	return;
-}
-
-/**
- * Return the maximum element in the buffer.
- *
- * @return float
- */
-PHP_METHOD(Tensor_TensorBuffer, max)
-{
-	zval _0;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
-	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_max(return_value, &_0);
-	return;
-}
-
-/**
- * Return the index of the minimum element in the buffer.
- *
- * @return int
- */
-PHP_METHOD(Tensor_TensorBuffer, argmin)
-{
-	zval _0;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
-	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_argmin(return_value, &_0);
-	return;
-}
-
-/**
- * Return the index of the maximum element in the buffer.
- *
- * @return int
- */
-PHP_METHOD(Tensor_TensorBuffer, argmax)
-{
-	zval _0;
-	zval *this_ptr = getThis();
-
-	ZVAL_UNDEF(&_0);
-	static zend_string *_zephir_prop_0 = NULL;
-	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("buffer", 6, 1);
-	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_argmax(return_value, &_0);
-	return;
-}
-
 /**
  * Return a slice of the buffer with a given stride as a new decorator.
  *
@@ -603,7 +422,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 		ZEPHIR_CONCAT_SS(&_8$$10, "Offset, length, and", " stride must be within the bounds of the buffer.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$10, "__construct", NULL, 2, &_8$$10);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$10, "tensor/tensorbuffer.zep", 256);
+		zephir_throw_exception_debug(&_7$$10, "tensor/tensorbuffer.zep", 176);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -614,7 +433,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 	ZVAL_LONG(&_12, stride);
 	tensor_buffer_slice_strided(&b, &_9, &_10, &_11, &_12);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -657,7 +476,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_get_arrval(&buffers, buffers_param);
 	ZEPHIR_INIT_VAR(&unwrapped);
 	array_init(&unwrapped);
-	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 281);
+	zephir_is_iterable(&buffers, 0, "tensor/tensorbuffer.zep", 201);
 	if (Z_TYPE_P(&buffers) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&buffers), _0)
 		{
@@ -665,7 +484,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			ZVAL_COPY(&buffer, _0);
 			ZEPHIR_CALL_METHOD(&_1$$3, &buffer, "asBuffer", NULL, 0);
 			zephir_check_call_status();
-			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 278);
+			zephir_array_append(&unwrapped, &_1$$3, PH_SEPARATE, "tensor/tensorbuffer.zep", 198);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, &buffers, "rewind", NULL, 0);
@@ -687,7 +506,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 			zephir_check_call_status();
 				ZEPHIR_CALL_METHOD(&_4$$4, &buffer, "asBuffer", NULL, 0);
 				zephir_check_call_status();
-				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 278);
+				zephir_array_append(&unwrapped, &_4$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 198);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -695,7 +514,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
 	tensor_buffer_concat(&b, &_5, &unwrapped);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -752,7 +571,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Chunk length must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 298);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 218);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -769,7 +588,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 	} else {
 		_6 = &buffers;
 	}
-	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 311);
+	zephir_is_iterable(_6, 0, "tensor/tensorbuffer.zep", 231);
 	if (Z_TYPE_P(_6) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
 		{
@@ -777,9 +596,9 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			ZVAL_COPY(&buffer, _8);
 			ZEPHIR_INIT_NVAR(&_9$$4);
 			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
-			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 13, &buffer);
+			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 32, &buffer);
 			zephir_check_call_status();
-			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 308);
+			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 228);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
@@ -801,9 +620,9 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_13$$5);
 				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
-				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 13, &buffer);
+				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 32, &buffer);
 				zephir_check_call_status();
-				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 308);
+				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 228);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&buffer);
@@ -853,7 +672,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Times must be", " greater than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 326);
+		zephir_throw_exception_debug(&_0$$3, "tensor/tensorbuffer.zep", 246);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -862,7 +681,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 	ZVAL_LONG(&_5, times);
 	tensor_buffer_repeat(&b, &_4, &_5);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/tensorbuffer.zep.h b/ext/tensor/tensorbuffer.zep.h
index 1a6154f..6c30ca8 100644
--- a/ext/tensor/tensorbuffer.zep.h
+++ b/ext/tensor/tensorbuffer.zep.h
@@ -10,13 +10,6 @@ PHP_METHOD(Tensor_TensorBuffer, get);
 PHP_METHOD(Tensor_TensorBuffer, set);
 PHP_METHOD(Tensor_TensorBuffer, sort);
 PHP_METHOD(Tensor_TensorBuffer, slice);
-PHP_METHOD(Tensor_TensorBuffer, map);
-PHP_METHOD(Tensor_TensorBuffer, sum);
-PHP_METHOD(Tensor_TensorBuffer, product);
-PHP_METHOD(Tensor_TensorBuffer, min);
-PHP_METHOD(Tensor_TensorBuffer, max);
-PHP_METHOD(Tensor_TensorBuffer, argmin);
-PHP_METHOD(Tensor_TensorBuffer, argmax);
 PHP_METHOD(Tensor_TensorBuffer, sliceStrided);
 PHP_METHOD(Tensor_TensorBuffer, concat);
 PHP_METHOD(Tensor_TensorBuffer, split);
@@ -56,28 +49,6 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_slice, 0, 2,
 	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_map, 0, 1, Tensor\\TensorBuffer, 0)
-	ZEND_ARG_INFO(0, callback)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_sum, 0, 0, IS_DOUBLE, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_product, 0, 0, IS_DOUBLE, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_min, 0, 0, IS_DOUBLE, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_max, 0, 0, IS_DOUBLE, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_argmin, 0, 0, IS_LONG, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_tensorbuffer_argmax, 0, 0, IS_LONG, 0)
-ZEND_END_ARG_INFO()
-
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_tensor_tensorbuffer_slicestrided, 0, 3, Tensor\\TensorBuffer, 0)
 	ZEND_ARG_TYPE_INFO(0, offset, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
@@ -113,13 +84,6 @@ ZEPHIR_INIT_FUNCS(tensor_tensorbuffer_method_entry) {
 	PHP_ME(Tensor_TensorBuffer, set, arginfo_tensor_tensorbuffer_set, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, sort, arginfo_tensor_tensorbuffer_sort, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, slice, arginfo_tensor_tensorbuffer_slice, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_TensorBuffer, map, arginfo_tensor_tensorbuffer_map, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_TensorBuffer, sum, arginfo_tensor_tensorbuffer_sum, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_TensorBuffer, product, arginfo_tensor_tensorbuffer_product, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_TensorBuffer, min, arginfo_tensor_tensorbuffer_min, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_TensorBuffer, max, arginfo_tensor_tensorbuffer_max, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_TensorBuffer, argmin, arginfo_tensor_tensorbuffer_argmin, ZEND_ACC_PUBLIC)
-	PHP_ME(Tensor_TensorBuffer, argmax, arginfo_tensor_tensorbuffer_argmax, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, sliceStrided, arginfo_tensor_tensorbuffer_slicestrided, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, concat, arginfo_tensor_tensorbuffer_concat, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_TensorBuffer, split, arginfo_tensor_tensorbuffer_split, ZEND_ACC_PUBLIC)
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index aa9e6f7..fab6632 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -689,7 +689,7 @@ PHP_METHOD(Tensor_Vector, fromArray)
 	zephir_fcall_cache_entry *_6 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zend_bool validate, _8, _3$$3, _9$$5;
-	zval *a_param = NULL, *validate_param = NULL, valueA, _0, *_2, _7, buffer, _12, _4$$4, _10$$6;
+	zval *a_param = NULL, *validate_param = NULL, valueA, _0, *_2, _7, buffer, _4$$4, _10$$6;
 	zval a, flat, _1;
 
 	ZVAL_UNDEF(&a);
@@ -699,7 +699,6 @@ PHP_METHOD(Tensor_Vector, fromArray)
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_12);
 	ZVAL_UNDEF(&_4$$4);
 	ZVAL_UNDEF(&_10$$6);
 	ZVAL_UNDEF(&_5$$4);
@@ -784,11 +783,7 @@ PHP_METHOD(Tensor_Vector, fromArray)
 	ZEPHIR_INIT_VAR(&buffer);
 	tensor_buffer_from_array(&buffer, &flat);
 	object_init_ex(return_value, zend_get_called_scope(execute_data));
-	ZEPHIR_INIT_VAR(&_12);
-	object_init_ex(&_12, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, &_12, "__construct", NULL, 13, &buffer);
-	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_12);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &buffer);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -985,7 +980,7 @@ PHP_METHOD(Tensor_Vector, asRowMatrix)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_2, 1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_2, &_1);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_2, &_1);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1020,7 +1015,7 @@ PHP_METHOD(Tensor_Vector, asColumnMatrix)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_2, 1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0, &_1, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1104,7 +1099,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_9, m);
 	ZVAL_LONG(&_10, n);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_8, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1131,7 +1126,7 @@ PHP_METHOD(Tensor_Vector, transpose)
 
 	object_init_ex(return_value, tensor_columnvector_ce);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1170,7 +1165,7 @@ PHP_METHOD(Tensor_Vector, map)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 16, callback, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "array_map", NULL, 15, callback, &_1);
 	zephir_check_call_status();
 	ZVAL_BOOL(&_3, 0);
 	ZEPHIR_RETURN_CALL_STATIC("fromArray", NULL, 0, &_2, &_3);
@@ -1221,7 +1216,7 @@ PHP_METHOD(Tensor_Vector, reduce)
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_2, initial);
-	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 17, &_1, callback, &_2);
+	ZEPHIR_RETURN_CALL_FUNCTION("array_reduce", NULL, 16, &_1, callback, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1377,7 +1372,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_11, stride);
 	tensor_convolve_1d(&_8, &_9, &_10, &_11);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1483,7 +1478,7 @@ PHP_METHOD(Tensor_Vector, outer)
 	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_5, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &result, &_4, &_5);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_4, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1592,7 +1587,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 	ZEPHIR_CALL_METHOD(&_7, &_5, "sum", NULL, 0);
 	zephir_check_call_status();
 	ZVAL_DOUBLE(&_6, zephir_safe_div_double_double(1.0, p));
-	ZEPHIR_RETURN_CALL_FUNCTION("pow", NULL, 18, &_7, &_6);
+	ZEPHIR_RETURN_CALL_FUNCTION("pow", NULL, 17, &_7, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2477,7 +2472,7 @@ PHP_METHOD(Tensor_Vector, abs)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_abs(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2525,7 +2520,7 @@ PHP_METHOD(Tensor_Vector, sqrt)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_sqrt(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2555,7 +2550,7 @@ PHP_METHOD(Tensor_Vector, exp)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_exp(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2585,7 +2580,7 @@ PHP_METHOD(Tensor_Vector, expm1)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_expm1(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2649,7 +2644,7 @@ PHP_METHOD(Tensor_Vector, log)
 		ZEPHIR_INIT_VAR(&_4$$4);
 		zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 		tensor_log(&_4$$4, &_5$$4);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_4$$4);
+		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_4$$4);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
@@ -2658,7 +2653,7 @@ PHP_METHOD(Tensor_Vector, log)
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_8, base);
 	tensor_log_base(&_6, &_7, &_8);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_6);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2688,7 +2683,7 @@ PHP_METHOD(Tensor_Vector, log1p)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_log1p(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2718,7 +2713,7 @@ PHP_METHOD(Tensor_Vector, sin)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_sin(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2748,7 +2743,7 @@ PHP_METHOD(Tensor_Vector, asin)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_asin(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2778,7 +2773,7 @@ PHP_METHOD(Tensor_Vector, cos)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_cos(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2808,7 +2803,7 @@ PHP_METHOD(Tensor_Vector, acos)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_acos(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2838,7 +2833,7 @@ PHP_METHOD(Tensor_Vector, tan)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_tan(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2868,7 +2863,7 @@ PHP_METHOD(Tensor_Vector, atan)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_atan(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2898,7 +2893,7 @@ PHP_METHOD(Tensor_Vector, rad2deg)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_rad2deg(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2928,7 +2923,7 @@ PHP_METHOD(Tensor_Vector, deg2rad)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_deg2rad(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2941,8 +2936,6 @@ PHP_METHOD(Tensor_Vector, deg2rad)
 PHP_METHOD(Tensor_Vector, sum)
 {
 	zval _0;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
@@ -2950,13 +2943,9 @@ PHP_METHOD(Tensor_Vector, sum)
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "sum", NULL, 0);
-	zephir_check_call_status();
-	RETURN_MM();
+	tensor_buffer_sum(return_value, &_0);
+	return;
 }
 
 /**
@@ -2967,8 +2956,6 @@ PHP_METHOD(Tensor_Vector, sum)
 PHP_METHOD(Tensor_Vector, product)
 {
 	zval _0;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
@@ -2976,13 +2963,9 @@ PHP_METHOD(Tensor_Vector, product)
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "product", NULL, 0);
-	zephir_check_call_status();
-	RETURN_MM();
+	tensor_buffer_product(return_value, &_0);
+	return;
 }
 
 /**
@@ -2993,8 +2976,6 @@ PHP_METHOD(Tensor_Vector, product)
 PHP_METHOD(Tensor_Vector, min)
 {
 	zval _0;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
@@ -3002,13 +2983,9 @@ PHP_METHOD(Tensor_Vector, min)
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "min", NULL, 0);
-	zephir_check_call_status();
-	RETURN_MM();
+	tensor_buffer_min(return_value, &_0);
+	return;
 }
 
 /**
@@ -3019,8 +2996,6 @@ PHP_METHOD(Tensor_Vector, min)
 PHP_METHOD(Tensor_Vector, max)
 {
 	zval _0;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
@@ -3028,13 +3003,49 @@ PHP_METHOD(Tensor_Vector, max)
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_buffer_max(return_value, &_0);
+	return;
+}
 
+/**
+ * Return the index of the minimum element in the vector.
+ *
+ * @return int
+ */
+PHP_METHOD(Tensor_Vector, argmin)
+{
+	zval _0;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "max", NULL, 0);
-	zephir_check_call_status();
-	RETURN_MM();
+	tensor_buffer_argmin(return_value, &_0);
+	return;
+}
+
+/**
+ * Return the index of the maximum element in the vector.
+ *
+ * @return int
+ */
+PHP_METHOD(Tensor_Vector, argmax)
+{
+	zval _0;
+	zval *this_ptr = getThis();
+
+	ZVAL_UNDEF(&_0);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
+	tensor_buffer_argmax(return_value, &_0);
+	return;
 }
 
 /**
@@ -3099,25 +3110,25 @@ PHP_METHOD(Tensor_Vector, median)
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_1, 2);
-	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 19, &_0, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 18, &_0, &_1);
 	zephir_check_call_status();
 	mid = zephir_get_intval(&_2);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&a, &_1, "toArray", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_MAKE_REF(&a);
-	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 20, &a);
+	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 19, &a);
 	ZEPHIR_UNREF(&a);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
 		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1186);
+		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1206);
 	} else {
 		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1188);
+		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1208);
 		zephir_memory_observe(&_5$$4);
-		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1188);
+		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1208);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
 		ZEPHIR_INIT_NVAR(&median);
@@ -3184,7 +3195,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1205);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1225);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3192,7 +3203,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 	ZEPHIR_CALL_METHOD(&a, &_5, "toArray", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_MAKE_REF(&a);
-	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 20, &a);
+	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 19, &a);
 	ZEPHIR_UNREF(&a);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
@@ -3202,15 +3213,15 @@ PHP_METHOD(Tensor_Vector, quantile)
 	if (ZEPHIR_LE_LONG(&_7, xHat)) {
 		zephir_memory_observe(&_8$$4);
 		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1217);
+		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1237);
 		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
 	}
 	remainder =  ((x -  (double) xHat));
 	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1222);
+	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1242);
 	t =  (zephir_get_doubleval(&_10));
 	zephir_memory_observe(&_11);
-	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1224);
+	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1244);
 	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
 }
 
@@ -3269,7 +3280,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 2, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1239);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1259);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3335,7 +3346,7 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1263);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1283);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3344,7 +3355,7 @@ PHP_METHOD(Tensor_Vector, round)
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_6, precision);
 	tensor_round(&_4, &_5, &_6);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_4);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_4);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3374,7 +3385,7 @@ PHP_METHOD(Tensor_Vector, floor)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_floor(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3404,7 +3415,7 @@ PHP_METHOD(Tensor_Vector, ceil)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_ceil(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3454,7 +3465,7 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1302);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1322);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3464,7 +3475,7 @@ PHP_METHOD(Tensor_Vector, clip)
 	ZVAL_DOUBLE(&_4, min);
 	ZVAL_DOUBLE(&_5, max);
 	tensor_clip(&_2, &_3, &_4, &_5);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_2);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3503,7 +3514,7 @@ PHP_METHOD(Tensor_Vector, clipLower)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, min);
 	tensor_clip_lower(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3542,7 +3553,7 @@ PHP_METHOD(Tensor_Vector, clipUpper)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, max);
 	tensor_clip_upper(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3572,7 +3583,7 @@ PHP_METHOD(Tensor_Vector, sign)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_sign(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3602,7 +3613,7 @@ PHP_METHOD(Tensor_Vector, negate)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	tensor_negate(&_0, &_1);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3676,7 +3687,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1362);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1382);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3691,7 +3702,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1373);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1393);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3700,7 +3711,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1370);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1390);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3723,7 +3734,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1370);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1390);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3734,7 +3745,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3808,7 +3819,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1388);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1408);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3823,7 +3834,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1399);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1419);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3832,7 +3843,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1396);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1416);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3855,7 +3866,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1396);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1416);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3866,7 +3877,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3940,7 +3951,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1414);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1434);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3955,7 +3966,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1425);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1445);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3964,7 +3975,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1422);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1442);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3987,7 +3998,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1422);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1442);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3998,7 +4009,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4072,7 +4083,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1440);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1460);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4087,7 +4098,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1451);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1471);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4096,7 +4107,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1448);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1468);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4119,7 +4130,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1448);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1468);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4130,7 +4141,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4204,7 +4215,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1466);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1486);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4219,7 +4230,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1477);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1497);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4228,7 +4239,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1474);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1494);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4251,7 +4262,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1474);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1494);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4262,7 +4273,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4336,7 +4347,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1492);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1512);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4351,7 +4362,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1503);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1523);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4360,7 +4371,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1500);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1520);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4383,7 +4394,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1500);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1520);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4394,7 +4405,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4468,7 +4479,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1518);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1538);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4483,7 +4494,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1529);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1549);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4492,7 +4503,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1526);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1546);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4515,7 +4526,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1526);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1546);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4526,7 +4537,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4600,7 +4611,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1544);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1564);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4615,7 +4626,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1555);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1575);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4624,7 +4635,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1552);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1572);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4647,7 +4658,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1552);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1572);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4658,7 +4669,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4732,7 +4743,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1570);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1590);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4747,7 +4758,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1581);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1601);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4756,7 +4767,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1578);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1598);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4779,7 +4790,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1578);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1598);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4790,7 +4801,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4864,7 +4875,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1596);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1616);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4879,7 +4890,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1607);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1627);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4888,7 +4899,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1604);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1624);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4911,7 +4922,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1604);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1624);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4922,7 +4933,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4996,7 +5007,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1622);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1642);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5011,7 +5022,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1633);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1653);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5020,7 +5031,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1630);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1650);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5043,7 +5054,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1630);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1650);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5054,7 +5065,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5128,7 +5139,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1648);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1668);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5143,7 +5154,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1659);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1679);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5152,7 +5163,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1656);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1676);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5175,7 +5186,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1656);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1676);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5186,7 +5197,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 15, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5249,7 +5260,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1674);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1694);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5258,7 +5269,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_multiply(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5321,7 +5332,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1692);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1712);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5330,7 +5341,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_divide(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5393,7 +5404,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1710);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1730);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5402,7 +5413,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_add(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5465,7 +5476,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1728);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1748);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5474,7 +5485,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_subtract(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5537,7 +5548,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1746);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1766);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5546,7 +5557,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_pow(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5609,7 +5620,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1764);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1784);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5618,7 +5629,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_mod(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5682,7 +5693,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1783);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1803);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5691,7 +5702,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_equal(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5754,7 +5765,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1801);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1821);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5763,7 +5774,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_not_equal(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5826,7 +5837,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1819);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1839);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5835,7 +5846,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5898,7 +5909,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1837);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1857);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5907,7 +5918,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_greater_equal(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5970,7 +5981,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1855);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1875);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5979,7 +5990,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6042,7 +6053,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1873);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1893);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6051,7 +6062,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_10, b, _zephir_prop_1, 0, PH_NOISY_CC | PH_READONLY);
 	tensor_less_equal(&_8, &_9, &_10);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6090,7 +6101,7 @@ PHP_METHOD(Tensor_Vector, multiplyScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_multiply_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6129,7 +6140,7 @@ PHP_METHOD(Tensor_Vector, divideScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_divide_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6168,7 +6179,7 @@ PHP_METHOD(Tensor_Vector, addScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_add_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6207,7 +6218,7 @@ PHP_METHOD(Tensor_Vector, subtractScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_subtract_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6246,7 +6257,7 @@ PHP_METHOD(Tensor_Vector, powScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_pow_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6285,7 +6296,7 @@ PHP_METHOD(Tensor_Vector, modScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_mod_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6324,7 +6335,7 @@ PHP_METHOD(Tensor_Vector, equalScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6363,7 +6374,7 @@ PHP_METHOD(Tensor_Vector, notEqualScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_not_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6402,7 +6413,7 @@ PHP_METHOD(Tensor_Vector, greaterScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_greater_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6442,7 +6453,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_greater_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6481,7 +6492,7 @@ PHP_METHOD(Tensor_Vector, lessScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_less_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6521,7 +6532,7 @@ PHP_METHOD(Tensor_Vector, lessEqualScalar)
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_2, b);
 	tensor_less_equal_scalar(&_0, &_1, &_2);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6553,7 +6564,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2030);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2050);
 	return;
 }
 
@@ -6604,7 +6615,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2054);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2074);
 	return;
 }
 
@@ -6662,7 +6673,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2068);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2088);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6697,7 +6708,7 @@ PHP_METHOD(Tensor_Vector, getIterator)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_1);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 20, &_1);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6770,13 +6781,13 @@ PHP_METHOD(Tensor_Vector, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2109);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2129);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, &_1);
-	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2112);
+	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2132);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_2);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/ext/tensor/vector.zep.h b/ext/tensor/vector.zep.h
index a9c07d7..ebe64fe 100644
--- a/ext/tensor/vector.zep.h
+++ b/ext/tensor/vector.zep.h
@@ -68,6 +68,8 @@ PHP_METHOD(Tensor_Vector, sum);
 PHP_METHOD(Tensor_Vector, product);
 PHP_METHOD(Tensor_Vector, min);
 PHP_METHOD(Tensor_Vector, max);
+PHP_METHOD(Tensor_Vector, argmin);
+PHP_METHOD(Tensor_Vector, argmax);
 PHP_METHOD(Tensor_Vector, mean);
 PHP_METHOD(Tensor_Vector, median);
 PHP_METHOD(Tensor_Vector, quantile);
@@ -363,6 +365,12 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_vector_max, 0, 0, IS_DOUBLE, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_vector_argmin, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_vector_argmax, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_tensor_vector_mean, 0, 0, IS_DOUBLE, 0)
 ZEND_END_ARG_INFO()
 
@@ -648,6 +656,8 @@ PHP_ME(Tensor_Vector, transpose, arginfo_tensor_vector_transpose, ZEND_ACC_PUBLI
 	PHP_ME(Tensor_Vector, product, arginfo_tensor_vector_product, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, min, arginfo_tensor_vector_min, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, max, arginfo_tensor_vector_max, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Vector, argmin, arginfo_tensor_vector_argmin, ZEND_ACC_PUBLIC)
+	PHP_ME(Tensor_Vector, argmax, arginfo_tensor_vector_argmax, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, mean, arginfo_tensor_vector_mean, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, median, arginfo_tensor_vector_median, ZEND_ACC_PUBLIC)
 	PHP_ME(Tensor_Vector, quantile, arginfo_tensor_vector_quantile, ZEND_ACC_PUBLIC)
diff --git a/stubs/TensorBuffer.php b/stubs/TensorBuffer.php
index 2b29be1..55d095e 100644
--- a/stubs/TensorBuffer.php
+++ b/stubs/TensorBuffer.php
@@ -116,34 +116,6 @@ public function slice(int $offset, int $length) : TensorBuffer
         {
         }
 
-        public function map(callable $callback) : TensorBuffer
-        {
-        }
-
-        public function sum() : float
-        {
-        }
-
-        public function product() : float
-        {
-        }
-
-        public function min() : float
-        {
-        }
-
-        public function max() : float
-        {
-        }
-
-        public function argmin() : int
-        {
-        }
-
-        public function argmax() : int
-        {
-        }
-
         public function sliceStrided(int $offset, int $length, int $stride) : TensorBuffer
         {
         }
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index b424841..5d9899b 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -363,7 +363,7 @@ class Matrix implements Tensor
         if unlikely rows < 1 {
             var buffer = tensor_buffer_from_array([]);
 
-            return new self(new TensorBuffer(<Buffer> buffer), 0, 0);
+            return new self(buffer, 0, 0);
         }
 
         var rowA, valueA;
@@ -410,7 +410,7 @@ class Matrix implements Tensor
 
         var buffer = tensor_buffer_from_array(flat);
 
-        return new self(new TensorBuffer(<Buffer> buffer), rows, n);
+        return new self(buffer, rows, n);
     }
 
     /**
@@ -682,7 +682,11 @@ class Matrix implements Tensor
      */
     public function map(const var callback) -> <Matrix>
     {
-        return new self(this->a->map(callback), this->m, this->n);
+        var b = array_map(callback, this->a->toArray());
+
+        var buffer = tensor_buffer_from_array(b);
+
+        return new self(buffer, this->m, this->n);
     }
 
     /**
@@ -1586,7 +1590,7 @@ class Matrix implements Tensor
         array b = [];
 
         for rowBuffer in this->a->split(this->n) {
-            let b[] = rowBuffer->sum();
+            let b[] = tensor_buffer_sum(rowBuffer);
         }
 
         return ColumnVector::fromArray(b, false);
@@ -1604,7 +1608,7 @@ class Matrix implements Tensor
         array b = [];
 
         for rowBuffer in this->a->split(this->n) {
-            let b[] = rowBuffer->product();
+            let b[] = tensor_buffer_product(rowBuffer);
         }
 
         return ColumnVector::fromArray(b, false);
@@ -1622,7 +1626,7 @@ class Matrix implements Tensor
         array b = [];
 
         for rowBuffer in this->a->split(this->n) {
-            let b[] = rowBuffer->min();
+            let b[] = tensor_buffer_min(rowBuffer);
         }
 
         return ColumnVector::fromArray(b, false);
@@ -1640,7 +1644,43 @@ class Matrix implements Tensor
         array b = [];
 
         for rowBuffer in this->a->split(this->n) {
-            let b[] = rowBuffer->max();
+            let b[] = tensor_buffer_max(rowBuffer);
+        }
+
+        return ColumnVector::fromArray(b, false);
+    }
+
+    /**
+     * Return the index of the minimum of each row in the matrix.
+     *
+     * @return \Tensor\ColumnVector
+     */
+    public function argmin() -> <ColumnVector>
+    {
+        var rowBuffer;
+
+        array b = [];
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = tensor_buffer_argmin(rowBuffer);
+        }
+
+        return ColumnVector::fromArray(b, false);
+    }
+
+    /**
+     * Return the index of the maximum of each row in the matrix.
+     *
+     * @return \Tensor\ColumnVector
+     */
+    public function argmax() -> <ColumnVector>
+    {
+        var rowBuffer;
+
+        array b = [];
+
+        for rowBuffer in this->a->split(this->n) {
+            let b[] = tensor_buffer_argmax(rowBuffer);
         }
 
         return ColumnVector::fromArray(b, false);
diff --git a/tensor/special.zep b/tensor/special.zep
index f0ab1af..094f4f0 100644
--- a/tensor/special.zep
+++ b/tensor/special.zep
@@ -30,6 +30,20 @@ interface Special
      */
     public function max();
 
+    /**
+     * Return the index (or per-row indices) of the minimum of the tensor.
+     *
+     * @return mixed
+     */
+    public function argmin();
+
+    /**
+     * Return the index (or per-row indices) of the maximum of the tensor.
+     *
+     * @return mixed
+     */
+    public function argmax();
+
     /**
      * Clip the tensor to be between the given minimum and maximum.
      *
diff --git a/tensor/tensorbuffer.zep b/tensor/tensorbuffer.zep
index b7de142..0ecc735 100644
--- a/tensor/tensorbuffer.zep
+++ b/tensor/tensorbuffer.zep
@@ -5,8 +5,9 @@ use Tensor\Exceptions\InvalidArgumentException;
 /**
  * TensorBuffer
  *
- * A decorator that wraps the kernel Buffer class and provides additional
- * operations such as sorting and slicing.
+ * A decorator that wraps the kernel Buffer class and provides structural
+ * operations such as sorting, slicing, splitting, concatenating, and
+ * repeating.
  *
  * @internal
  *
@@ -35,18 +36,14 @@ class TensorBuffer
         int rows = count(buffers);
 
         if unlikely rows < 1 {
-            var zero = tensor_buffer_from_array([]);
-
-            return new self(<Buffer> zero);
+            return tensor_buffer_from_array([]);
         }
 
         if unlikely rows == 1 {
-            return new self(buffers[0]->asBuffer());
+            return buffers[0];
         }
 
-        var b = buffers[0]->concat(array_slice(buffers, 1));
-
-        return new self(b->asBuffer());
+        return buffers[0]->concat(array_slice(buffers, 1));
     }
 
     /**
@@ -121,83 +118,6 @@ class TensorBuffer
         return new TensorBuffer(<Buffer> b);
     }
 
-    /**
-     * Map a function over the elements in the buffer and return a new decorator.
-     *
-     * @internal
-     *
-     * @param callable callback
-     * @return self
-     */
-    public function map(const var callback) -> <TensorBuffer>
-    {
-        var b = array_map(callback, this->buffer->toArray());
-
-        var buffer = tensor_buffer_from_array(b);
-
-        return new TensorBuffer(<Buffer> buffer);
-    }
-
-    /**
-     * Return the sum of the elements in the buffer.
-     *
-     * @return float
-     */
-    public function sum() -> float
-    {
-        return tensor_buffer_sum(this->buffer);
-    }
-
-    /**
-     * Return the product of the elements in the buffer.
-     *
-     * @return float
-     */
-    public function product() -> float
-    {
-        return tensor_buffer_product(this->buffer);
-    }
-
-    /**
-     * Return the minimum element in the buffer.
-     *
-     * @return float
-     */
-    public function min() -> float
-    {
-        return tensor_buffer_min(this->buffer);
-    }
-
-    /**
-     * Return the maximum element in the buffer.
-     *
-     * @return float
-     */
-    public function max() -> float
-    {
-        return tensor_buffer_max(this->buffer);
-    }
-
-    /**
-     * Return the index of the minimum element in the buffer.
-     *
-     * @return int
-     */
-    public function argmin() -> int
-    {
-        return tensor_buffer_argmin(this->buffer);
-    }
-
-    /**
-     * Return the index of the maximum element in the buffer.
-     *
-     * @return int
-     */
-    public function argmax() -> int
-    {
-        return tensor_buffer_argmax(this->buffer);
-    }
-
     /**
      * Return a slice of the buffer with a given stride as a new decorator.
      *
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 79564be..4d595dc 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -286,7 +286,7 @@ class Vector implements Tensor
 
         var buffer = tensor_buffer_from_array(flat);
 
-        return new static(new TensorBuffer(<Buffer> buffer));
+        return new static(buffer);
     }
 
     /**
@@ -1124,7 +1124,7 @@ class Vector implements Tensor
      */
     public function sum() -> float
     {
-        return this->a->sum();
+        return tensor_buffer_sum(this->a);
     }
 
     /**
@@ -1134,7 +1134,7 @@ class Vector implements Tensor
      */
     public function product() -> float
     {
-        return this->a->product();
+        return tensor_buffer_product(this->a);
     }
 
     /**
@@ -1144,7 +1144,7 @@ class Vector implements Tensor
      */
     public function min() -> float
     {
-        return this->a->min();
+        return tensor_buffer_min(this->a);
     }
 
     /**
@@ -1154,7 +1154,27 @@ class Vector implements Tensor
      */
     public function max() -> float
     {
-        return this->a->max();
+        return tensor_buffer_max(this->a);
+    }
+
+    /**
+     * Return the index of the minimum element in the vector.
+     *
+     * @return int
+     */
+    public function argmin() -> int
+    {
+        return tensor_buffer_argmin(this->a);
+    }
+
+    /**
+     * Return the index of the maximum element in the vector.
+     *
+     * @return int
+     */
+    public function argmax() -> int
+    {
+        return tensor_buffer_argmax(this->a);
     }
 
     /**
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index de0ca83..fa501a9 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -2677,6 +2677,42 @@ public function max() : void
         $this->assertEquals($expected->asArray(), $b->asArray());
     }
 
+    /**
+     * @test
+     */
+    public function argmin() : void
+    {
+        $a = Matrix::fromArray([
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
+        ]);
+
+        $b = $a->argmin();
+
+        $expected = ColumnVector::fromArray([1, 2, 2]);
+
+        $this->assertEquals($expected->asArray(), $b->asArray());
+    }
+
+    /**
+     * @test
+     */
+    public function argmax() : void
+    {
+        $a = Matrix::fromArray([
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
+        ]);
+
+        $b = $a->argmax();
+
+        $expected = ColumnVector::fromArray([0, 1, 0]);
+
+        $this->assertEquals($expected->asArray(), $b->asArray());
+    }
+
     /**
      * @test
      */
diff --git a/tests/TensorBufferTest.php b/tests/TensorBufferTest.php
index 78c6864..cf9f1d6 100644
--- a/tests/TensorBufferTest.php
+++ b/tests/TensorBufferTest.php
@@ -210,247 +210,6 @@ public function sliceNegativeLength() : void
         $decorator->slice(0, -1);
     }
 
-    /**
-     * @test
-     */
-    public function map() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 2.0, 3.0]));
-
-        $mapped = $decorator->map(static function ($value) : float {
-            return $value ** 2;
-        });
-
-        $this->assertInstanceOf(TensorBuffer::class, $mapped);
-        $this->assertNotSame($decorator->asBuffer(), $mapped->asBuffer());
-        $this->assertEqualsWithDelta([1.0, 4.0, 9.0], $mapped->toArray(), self::MAX_DELTA);
-        $this->assertEqualsWithDelta([1.0, 2.0, 3.0], $decorator->toArray(), self::MAX_DELTA);
-    }
-
-    /**
-     * Regression test: mapping a decorator with an array callable
-     * [instance, 'method'] over a multi-element buffer must not segfault.
-     *
-     * @test
-     */
-    public function mapWithInstanceArrayCallable() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([1.0, -2.0, -3.0, 4.0]));
-
-        $helper = new class() {
-            public float $slope = 0.5;
-
-            public function activate(float $value) : float
-            {
-                return $value > 0.0 ? $value : $value * $this->slope;
-            }
-        };
-
-        $mapped = $decorator->map([$helper, 'activate']);
-
-        $this->assertInstanceOf(TensorBuffer::class, $mapped);
-        $this->assertNotSame($decorator->asBuffer(), $mapped->asBuffer());
-        $this->assertEqualsWithDelta([1.0, -1.0, -1.5, 4.0], $mapped->toArray(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function sum() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
-
-        $this->assertEqualsWithDelta(6.0, $decorator->sum(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function sumLongBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
-
-        $this->assertEqualsWithDelta(6.0, $decorator->sum(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function sumEmptyBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
-
-        $this->assertEqualsWithDelta(0.0, $decorator->sum(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function product() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
-
-        $this->assertEqualsWithDelta(6.0, $decorator->product(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function productLongBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
-
-        $this->assertEqualsWithDelta(6.0, $decorator->product(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function productEmptyBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
-
-        $this->assertEqualsWithDelta(1.0, $decorator->product(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function min() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
-
-        $this->assertEqualsWithDelta(1.0, $decorator->min(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function minLongBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
-
-        $this->assertEqualsWithDelta(1.0, $decorator->min(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function minEmptyBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
-
-        $this->expectException(\InvalidArgumentException::class);
-
-        $decorator->min();
-    }
-
-    /**
-     * @test
-     */
-    public function max() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
-
-        $this->assertEqualsWithDelta(3.0, $decorator->max(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function maxLongBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
-
-        $this->assertEqualsWithDelta(3.0, $decorator->max(), self::MAX_DELTA);
-    }
-
-    /**
-     * @test
-     */
-    public function maxEmptyBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
-
-        $this->expectException(\InvalidArgumentException::class);
-
-        $decorator->max();
-    }
-
-    /**
-     * @test
-     */
-    public function argmin() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
-
-        $this->assertSame(1, $decorator->argmin());
-    }
-
-    /**
-     * @test
-     */
-    public function argminLongBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
-
-        $this->assertSame(1, $decorator->argmin());
-    }
-
-    /**
-     * @test
-     */
-    public function argminTie() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([1.0, 1.0, 2.0]));
-
-        $this->assertSame(0, $decorator->argmin());
-    }
-
-    /**
-     * @test
-     */
-    public function argminEmptyBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
-
-        $this->expectException(\InvalidArgumentException::class);
-
-        $decorator->argmin();
-    }
-
-    /**
-     * @test
-     */
-    public function argmax() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3.0, 1.0, 2.0]));
-
-        $this->assertSame(0, $decorator->argmax());
-    }
-
-    /**
-     * @test
-     */
-    public function argmaxLongBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([3, 1, 2], Buffer::TYPE_LONG));
-
-        $this->assertSame(0, $decorator->argmax());
-    }
-
-    /**
-     * @test
-     */
-    public function argmaxEmptyBuffer() : void
-    {
-        $decorator = new TensorBuffer(Buffer::fromArray([], Buffer::TYPE_DOUBLE));
-
-        $this->expectException(\InvalidArgumentException::class);
-
-        $decorator->argmax();
-    }
-
     /**
      * @test
      */
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index 98bfedf..6df4451 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -1489,6 +1489,70 @@ public function max() : void
         $this->assertEquals(106.0, $a->max());
     }
 
+    /**
+     * @test
+     */
+    public function argmin() : void
+    {
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+
+        $this->assertSame(4, $a->argmin());
+    }
+
+    /**
+     * @test
+     */
+    public function argminTie() : void
+    {
+        $a = Vector::fromArray([2.0, 1.0, 1.0, 3.0]);
+
+        $this->assertSame(1, $a->argmin());
+    }
+
+    /**
+     * @test
+     */
+    public function argminEmptyVector() : void
+    {
+        $a = Vector::fromArray([], false);
+
+        $this->expectException(\InvalidArgumentException::class);
+
+        $a->argmin();
+    }
+
+    /**
+     * @test
+     */
+    public function argmax() : void
+    {
+        $a = Vector::fromArray([-15.0, 25.0, 35.0, -36.0, -72.0, 89.0, 106.0, 45.0]);
+
+        $this->assertSame(6, $a->argmax());
+    }
+
+    /**
+     * @test
+     */
+    public function argmaxTie() : void
+    {
+        $a = Vector::fromArray([2.0, 3.0, 3.0, 1.0]);
+
+        $this->assertSame(1, $a->argmax());
+    }
+
+    /**
+     * @test
+     */
+    public function argmaxEmptyVector() : void
+    {
+        $a = Vector::fromArray([], false);
+
+        $this->expectException(\InvalidArgumentException::class);
+
+        $a->argmax();
+    }
+
     /**
      * @test
      */

From 0aa4dede324c4892e23a12d5e41b2c5b2160a10d Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 21:07:48 -0500
Subject: [PATCH 38/51] Unlock multithreading

---
 config.json | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/config.json b/config.json
index e37ff6d..5862393 100644
--- a/config.json
+++ b/config.json
@@ -19,10 +19,6 @@
     ],
     "initializers": {
         "module": [
-            {
-                "include": "cblas.h",
-                "code": "openblas_set_num_threads(1)"
-            },
             {
                 "code": "extern zend_class_entry *tensor_buffer_ce; extern zend_class_entry *zephir_buffer_ce; tensor_buffer_ce = zephir_buffer_ce;"
             }

From 20602ceda2bdfe9c1189d2ce53eed5643f0811e1 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 21:23:32 -0500
Subject: [PATCH 39/51] A little nicer

---
 config.json                                 |   5 +
 ext/config.m4                               |   1 +
 ext/config.w32                              |   2 +-
 ext/include/buffer.c                        | 364 -------------------
 ext/include/buffer.h                        |   6 -
 ext/include/reductions.c                    | 380 ++++++++++++++++++++
 ext/include/reductions.h                    |  13 +
 ext/tensor/matrix.zep.c                     |   1 +
 ext/tensor/vector.zep.c                     |   1 +
 optimizers/TensorBufferArgmaxOptimizer.php  |   2 +-
 optimizers/TensorBufferArgminOptimizer.php  |   2 +-
 optimizers/TensorBufferMaxOptimizer.php     |   2 +-
 optimizers/TensorBufferMinOptimizer.php     |   2 +-
 optimizers/TensorBufferProductOptimizer.php |   2 +-
 optimizers/TensorBufferSumOptimizer.php     |   2 +-
 15 files changed, 408 insertions(+), 377 deletions(-)
 create mode 100644 ext/include/reductions.c
 create mode 100644 ext/include/reductions.h

diff --git a/config.json b/config.json
index 5862393..95d66d9 100644
--- a/config.json
+++ b/config.json
@@ -12,6 +12,7 @@
         "include/arithmetic.c",
         "include/buffer.c",
         "include/comparison.c",
+        "include/reductions.c",
         "include/unary.c",
         "include/linear_algebra.c",
         "include/signal_processing.c",
@@ -19,6 +20,10 @@
     ],
     "initializers": {
         "module": [
+            {
+                "include": "cblas.h",
+                "code": "openblas_set_num_threads(1)"
+            },
             {
                 "code": "extern zend_class_entry *tensor_buffer_ce; extern zend_class_entry *zephir_buffer_ce; tensor_buffer_ce = zephir_buffer_ce;"
             }
diff --git a/ext/config.m4 b/ext/config.m4
index f902605..cd7782b 100644
--- a/ext/config.m4
+++ b/ext/config.m4
@@ -35,6 +35,7 @@ if test "$PHP_TENSOR_EXT" = "yes"; then
 	tensor/tensorbuffer.zep.c include/arithmetic.c
 	include/buffer.c
 	include/comparison.c
+	include/reductions.c
 	include/unary.c
 	include/linear_algebra.c
 	include/signal_processing.c
diff --git a/ext/config.w32 b/ext/config.w32
index ffc215e..6aff90e 100644
--- a/ext/config.w32
+++ b/ext/config.w32
@@ -9,7 +9,7 @@ if (PHP_TENSOR_EXT != "no") {
     ADD_EXTENSION_DEP("tensor_ext", "json");
     AC_DEFINE("ZEPHIR_USE_PHP_JSON", 1, "Whether PHP json extension is present at compile time");
   }
-  ADD_SOURCES(configure_module_dirname + "/include", "arithmetic.c buffer.c comparison.c unary.c linear_algebra.c signal_processing.c settings.c", "tensor_ext");
+  ADD_SOURCES(configure_module_dirname + "/include", "arithmetic.c buffer.c comparison.c reductions.c unary.c linear_algebra.c signal_processing.c settings.c", "tensor_ext");
   ADD_SOURCES(configure_module_dirname + "/tensor", "algebraic.zep.c arithmetic.zep.c arraylike.zep.c comparable.zep.c special.zep.c statistical.zep.c trigonometric.zep.c tensor.zep.c vector.zep.c columnvector.zep.c matrix.zep.c settings.zep.c tensorbuffer.zep.c", "tensor_ext");
 	ADD_SOURCES(configure_module_dirname + "/tensor/exceptions", "tensorexception.zep.c invalidargumentexception.zep.c runtimeexception.zep.c dimensionalitymismatch.zep.c singularmatrix.zep.c", "tensor_ext");
 	ADD_SOURCES(configure_module_dirname + "/tensor/decompositions", "cholesky.zep.c eigen.zep.c lu.zep.c svd.zep.c", "tensor_ext");
diff --git a/ext/include/buffer.c b/ext/include/buffer.c
index 9de71df..d9f8920 100644
--- a/ext/include/buffer.c
+++ b/ext/include/buffer.c
@@ -136,47 +136,6 @@ double * tensor_tensorbuffer_doubles(zval * obj, zend_long * len, int * success)
 	return NULL;
 }
 
-/**
- * Resolve the underlying raw buffer for the reduction operations, accepting
- * either a `TensorBuffer` decorator (returns a reference to its wrapped
- * buffer) or a raw `Buffer` object as-is (returns a reference to it). The
- * caller owns the reference written to `buf` and must release it with
- * `zval_ptr_dtor()`.
- *
- * @return 1 on success, 0 on failure (throwing).
- */
-static int tensor_resolve_underlying_buffer(zval * obj, zval * buf)
-{
-	if (Z_TYPE_P(obj) == IS_OBJECT && Z_OBJCE_P(obj) == tensor_tensorbuffer_ce) {
-		zval rv;
-		zval *prop;
-
-		ZVAL_UNDEF(&rv);
-
-		prop = zend_read_property(tensor_tensorbuffer_ce, Z_OBJ_P(obj), "buffer", sizeof("buffer") - 1, 1, &rv);
-
-		if (prop != NULL && prop != &rv) {
-			ZVAL_COPY(buf, prop);
-		} else {
-			ZVAL_UNDEF(buf);
-		}
-
-		zval_ptr_dtor(&rv);
-	} else {
-		ZVAL_COPY(buf, obj);
-	}
-
-	if (UNEXPECTED(!zephir_is_buffer(buf))) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer or TensorBuffer object."));
-		zval_ptr_dtor(buf);
-		ZVAL_UNDEF(buf);
-		return 0;
-	}
-
-	return 1;
-}
-
 static int tensor_double_cmp(const void * a, const void * b)
 {
 	double da = *(const double *) a;
@@ -203,85 +162,6 @@ static int tensor_long_cmp_desc(const void * a, const void * b)
 	return tensor_long_cmp(b, a);
 }
 
-static double tensor_buffer_sum_values(const uint8_t kind, const void * data, const zend_long len)
-{
-	double acc = 0.0;
-	zend_long i;
-
-	if (kind == ZEPHIR_BUFFER_LONG) {
-		const zend_long * ptr = (const zend_long *) data;
-
-		for (i = 0; i < len; ++i) {
-			acc += (double) ptr[i];
-		}
-	} else {
-		const double * ptr = (const double *) data;
-
-		for (i = 0; i < len; ++i) {
-			acc += ptr[i];
-		}
-	}
-
-	return acc;
-}
-
-static double tensor_buffer_product_values(const uint8_t kind, const void * data, const zend_long len)
-{
-	double acc = 1.0;
-	zend_long i;
-
-	if (kind == ZEPHIR_BUFFER_LONG) {
-		const zend_long * ptr = (const zend_long *) data;
-
-		for (i = 0; i < len; ++i) {
-			acc *= (double) ptr[i];
-		}
-	} else {
-		const double * ptr = (const double *) data;
-
-		for (i = 0; i < len; ++i) {
-			acc *= ptr[i];
-		}
-	}
-
-	return acc;
-}
-
-static void tensor_buffer_extreme(const uint8_t kind, const void * data, const zend_long len, const int find_min, double * value, zend_long * index)
-{
-	zend_long i;
-
-	if (kind == ZEPHIR_BUFFER_LONG) {
-		const zend_long * ptr = (const zend_long *) data;
-		zend_long best = ptr[0];
-
-		for (i = 1; i < len; ++i) {
-			if (find_min ? ptr[i] < best : ptr[i] > best) {
-				best = ptr[i];
-				*index = i;
-			}
-		}
-
-		if (value != NULL) {
-			*value = (double) best;
-		}
-	} else {
-		const double * ptr = (const double *) data;
-		double best = ptr[0];
-
-		for (i = 1; i < len; ++i) {
-			if (find_min ? ptr[i] < best : ptr[i] > best) {
-				best = ptr[i];
-				*index = i;
-			}
-		}
-
-		if (value != NULL) {
-			*value = best;
-		}
-	}
-}
-
 /**
  * Sort the elements of a Buffer in place.
  *
@@ -354,250 +234,6 @@ void tensor_buffer_slice(zval * return_value, zval * obj, zval * offset, zval *
 	}
 }
 
-/**
- * Return the sum of the elements of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_sum(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
-
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	if (len == 0) {
-		RETVAL_DOUBLE(0.0);
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	RETVAL_DOUBLE(tensor_buffer_sum_values(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len));
-	zval_ptr_dtor(&buffer);
-}
-
-/**
- * Return the product of the elements of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_product(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
-
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	if (len == 0) {
-		RETVAL_DOUBLE(1.0);
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	RETVAL_DOUBLE(tensor_buffer_product_values(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len));
-	zval_ptr_dtor(&buffer);
-}
-
-/**
- * Return the minimum element of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_min(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-	double value = 0.0;
-	zend_long index = 0;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
-
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	if (UNEXPECTED(len == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Cannot compute the minimum of an empty buffer."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 1, &value, &index);
-
-	zval_ptr_dtor(&buffer);
-
-	RETVAL_DOUBLE(value);
-}
-
-/**
- * Return the maximum element of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_max(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-	double value = 0.0;
-	zend_long index = 0;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
-
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	if (UNEXPECTED(len == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Cannot compute the maximum of an empty buffer."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 0, &value, &index);
-
-	zval_ptr_dtor(&buffer);
-
-	RETVAL_DOUBLE(value);
-}
-
-/**
- * Return the index of the minimum element of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_argmin(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-	zend_long index = 0;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
-
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	if (UNEXPECTED(len == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Cannot compute the argmin of an empty buffer."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 1, NULL, &index);
-
-	zval_ptr_dtor(&buffer);
-
-	RETVAL_LONG(index);
-}
-
-/**
- * Return the index of the maximum element of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_argmax(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-	zend_long index = 0;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
-
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	if (UNEXPECTED(len == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Cannot compute the argmax of an empty buffer."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 0, NULL, &index);
-
-	zval_ptr_dtor(&buffer);
-
-	RETVAL_LONG(index);
-}
-
 /**
  * Return a new Buffer populated with a strided slice of the given buffer.
  *
diff --git a/ext/include/buffer.h b/ext/include/buffer.h
index f864e16..b5d0e32 100644
--- a/ext/include/buffer.h
+++ b/ext/include/buffer.h
@@ -32,12 +32,6 @@ void tensor_buffer_from_array(zval * ret, zval * arr);
 
 void tensor_buffer_sort(zval * return_value, zval * obj, zval * ascending);
 void tensor_buffer_slice(zval * return_value, zval * obj, zval * offset, zval * length);
-void tensor_buffer_sum(zval * return_value, zval * obj);
-void tensor_buffer_product(zval * return_value, zval * obj);
-void tensor_buffer_min(zval * return_value, zval * obj);
-void tensor_buffer_max(zval * return_value, zval * obj);
-void tensor_buffer_argmin(zval * return_value, zval * obj);
-void tensor_buffer_argmax(zval * return_value, zval * obj);
 void tensor_buffer_slice_strided(zval * return_value, zval * obj, zval * offset, zval * length, zval * stride);
 void tensor_buffer_concat(zval * return_value, zval * obj, zval * others);
 void tensor_buffer_split(zval * return_value, zval * obj, zval * chunk_length);
diff --git a/ext/include/reductions.c b/ext/include/reductions.c
new file mode 100644
index 0000000..07ff6b7
--- /dev/null
+++ b/ext/include/reductions.c
@@ -0,0 +1,380 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <php.h>
+#include <stdlib.h>
+#include <ext/spl/spl_exceptions.h>
+#include "kernel/main.h"
+#include "kernel/buffer.h"
+#include "kernel/exception.h"
+#include "include/buffer.h"
+#include "include/reductions.h"
+
+#ifdef ZEPHIR_BUFFER_ENABLED
+
+/**
+ * Resolve the underlying raw buffer for the reduction operations, accepting
+ * either a `TensorBuffer` decorator (returns a reference to its wrapped
+ * buffer) or a raw `Buffer` object as-is (returns a reference to it). The
+ * caller owns the reference written to `buf` and must release it with
+ * `zval_ptr_dtor()`.
+ *
+ * @return 1 on success, 0 on failure (throwing).
+ */
+static int tensor_resolve_underlying_buffer(zval * obj, zval * buf)
+{
+	if (Z_TYPE_P(obj) == IS_OBJECT && Z_OBJCE_P(obj) == tensor_tensorbuffer_ce) {
+		zval rv;
+		zval *prop;
+
+		ZVAL_UNDEF(&rv);
+
+		prop = zend_read_property(tensor_tensorbuffer_ce, Z_OBJ_P(obj), "buffer", sizeof("buffer") - 1, 1, &rv);
+
+		if (prop != NULL && prop != &rv) {
+			ZVAL_COPY(buf, prop);
+		} else {
+			ZVAL_UNDEF(buf);
+		}
+
+		zval_ptr_dtor(&rv);
+	} else {
+		ZVAL_COPY(buf, obj);
+	}
+
+	if (UNEXPECTED(!zephir_is_buffer(buf))) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer or TensorBuffer object."));
+		zval_ptr_dtor(buf);
+		ZVAL_UNDEF(buf);
+		return 0;
+	}
+
+	return 1;
+}
+
+static double tensor_buffer_sum_values(const uint8_t kind, const void * data, const zend_long len)
+{
+	double acc = 0.0;
+	zend_long i;
+
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		const zend_long * ptr = (const zend_long *) data;
+
+		for (i = 0; i < len; ++i) {
+			acc += (double) ptr[i];
+		}
+	} else {
+		const double * ptr = (const double *) data;
+
+		for (i = 0; i < len; ++i) {
+			acc += ptr[i];
+		}
+	}
+
+	return acc;
+}
+
+static double tensor_buffer_product_values(const uint8_t kind, const void * data, const zend_long len)
+{
+	double acc = 1.0;
+	zend_long i;
+
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		const zend_long * ptr = (const zend_long *) data;
+
+		for (i = 0; i < len; ++i) {
+			acc *= (double) ptr[i];
+		}
+	} else {
+		const double * ptr = (const double *) data;
+
+		for (i = 0; i < len; ++i) {
+			acc *= ptr[i];
+		}
+	}
+
+	return acc;
+}
+
+static void tensor_buffer_extreme(const uint8_t kind, const void * data, const zend_long len, const int find_min, double * value, zend_long * index)
+{
+	zend_long i;
+
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		const zend_long * ptr = (const zend_long *) data;
+		zend_long best = ptr[0];
+
+		for (i = 1; i < len; ++i) {
+			if (find_min ? ptr[i] < best : ptr[i] > best) {
+				best = ptr[i];
+				*index = i;
+			}
+		}
+
+		if (value != NULL) {
+			*value = (double) best;
+		}
+	} else {
+		const double * ptr = (const double *) data;
+		double best = ptr[0];
+
+		for (i = 1; i < len; ++i) {
+			if (find_min ? ptr[i] < best : ptr[i] > best) {
+				best = ptr[i];
+				*index = i;
+			}
+		}
+
+		if (value != NULL) {
+			*value = best;
+		}
+	}
+}
+
+/**
+ * Return the sum of the elements of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_sum(zval * return_value, zval * obj)
+{
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	if (len == 0) {
+		RETVAL_DOUBLE(0.0);
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	RETVAL_DOUBLE(tensor_buffer_sum_values(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len));
+	zval_ptr_dtor(&buffer);
+}
+
+/**
+ * Return the product of the elements of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_product(zval * return_value, zval * obj)
+{
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	if (len == 0) {
+		RETVAL_DOUBLE(1.0);
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	RETVAL_DOUBLE(tensor_buffer_product_values(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len));
+	zval_ptr_dtor(&buffer);
+}
+
+/**
+ * Return the minimum element of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_min(zval * return_value, zval * obj)
+{
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+	double value = 0.0;
+	zend_long index = 0;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	if (UNEXPECTED(len == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Cannot compute the minimum of an empty buffer."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 1, &value, &index);
+
+	zval_ptr_dtor(&buffer);
+
+	RETVAL_DOUBLE(value);
+}
+
+/**
+ * Return the maximum element of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_max(zval * return_value, zval * obj)
+{
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+	double value = 0.0;
+	zend_long index = 0;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	if (UNEXPECTED(len == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Cannot compute the maximum of an empty buffer."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 0, &value, &index);
+
+	zval_ptr_dtor(&buffer);
+
+	RETVAL_DOUBLE(value);
+}
+
+/**
+ * Return the index of the minimum element of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_argmin(zval * return_value, zval * obj)
+{
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+	zend_long index = 0;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	if (UNEXPECTED(len == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Cannot compute the argmin of an empty buffer."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 1, NULL, &index);
+
+	zval_ptr_dtor(&buffer);
+
+	RETVAL_LONG(index);
+}
+
+/**
+ * Return the index of the maximum element of a Buffer.
+ *
+ * @param return_value
+ * @param obj
+ */
+void tensor_buffer_argmax(zval * return_value, zval * obj)
+{
+	zval buffer;
+	uint8_t kind;
+	zend_long len;
+	zend_long index = 0;
+
+	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
+		return;
+	}
+
+	kind = zephir_buffer_kind(&buffer);
+	len = zephir_buffer_len(&buffer);
+
+	if (UNEXPECTED(kind == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Argument must be a Buffer object."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	if (UNEXPECTED(len == 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Cannot compute the argmax of an empty buffer."));
+		zval_ptr_dtor(&buffer);
+		return;
+	}
+
+	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
+		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 0, NULL, &index);
+
+	zval_ptr_dtor(&buffer);
+
+	RETVAL_LONG(index);
+}
+
+#endif
\ No newline at end of file
diff --git a/ext/include/reductions.h b/ext/include/reductions.h
new file mode 100644
index 0000000..b88662b
--- /dev/null
+++ b/ext/include/reductions.h
@@ -0,0 +1,13 @@
+#ifndef TENSOR_REDUCTIONS_H
+#define TENSOR_REDUCTIONS_H
+
+#include <Zend/zend.h>
+
+void tensor_buffer_sum(zval * return_value, zval * obj);
+void tensor_buffer_product(zval * return_value, zval * obj);
+void tensor_buffer_min(zval * return_value, zval * obj);
+void tensor_buffer_max(zval * return_value, zval * obj);
+void tensor_buffer_argmin(zval * return_value, zval * obj);
+void tensor_buffer_argmax(zval * return_value, zval * obj);
+
+#endif
\ No newline at end of file
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 1d6e04c..d8ca9c1 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -27,6 +27,7 @@
 #include "include/linear_algebra.h"
 #include "include/signal_processing.h"
 #include "include/unary.h"
+#include "include/reductions.h"
 #include "include/arithmetic.h"
 #include "include/comparison.h"
 
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index fab6632..51ecd2a 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -27,6 +27,7 @@
 #include "include/linear_algebra.h"
 #include "include/signal_processing.h"
 #include "include/unary.h"
+#include "include/reductions.h"
 #include "include/arithmetic.h"
 #include "include/comparison.h"
 
diff --git a/optimizers/TensorBufferArgmaxOptimizer.php b/optimizers/TensorBufferArgmaxOptimizer.php
index 9883e2b..90fb4f8 100644
--- a/optimizers/TensorBufferArgmaxOptimizer.php
+++ b/optimizers/TensorBufferArgmaxOptimizer.php
@@ -51,7 +51,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         }
 
         $context->headersManager->add(
-            'include/buffer',
+            'include/reductions',
             HeadersManager::POSITION_LAST
         );
 
diff --git a/optimizers/TensorBufferArgminOptimizer.php b/optimizers/TensorBufferArgminOptimizer.php
index 8f7f3ae..fc5c658 100644
--- a/optimizers/TensorBufferArgminOptimizer.php
+++ b/optimizers/TensorBufferArgminOptimizer.php
@@ -51,7 +51,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         }
 
         $context->headersManager->add(
-            'include/buffer',
+            'include/reductions',
             HeadersManager::POSITION_LAST
         );
 
diff --git a/optimizers/TensorBufferMaxOptimizer.php b/optimizers/TensorBufferMaxOptimizer.php
index d0c3697..6c7cf6e 100644
--- a/optimizers/TensorBufferMaxOptimizer.php
+++ b/optimizers/TensorBufferMaxOptimizer.php
@@ -51,7 +51,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         }
 
         $context->headersManager->add(
-            'include/buffer',
+            'include/reductions',
             HeadersManager::POSITION_LAST
         );
 
diff --git a/optimizers/TensorBufferMinOptimizer.php b/optimizers/TensorBufferMinOptimizer.php
index e4812f5..b5b603c 100644
--- a/optimizers/TensorBufferMinOptimizer.php
+++ b/optimizers/TensorBufferMinOptimizer.php
@@ -51,7 +51,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         }
 
         $context->headersManager->add(
-            'include/buffer',
+            'include/reductions',
             HeadersManager::POSITION_LAST
         );
 
diff --git a/optimizers/TensorBufferProductOptimizer.php b/optimizers/TensorBufferProductOptimizer.php
index b2a160b..8d8f8f7 100644
--- a/optimizers/TensorBufferProductOptimizer.php
+++ b/optimizers/TensorBufferProductOptimizer.php
@@ -51,7 +51,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         }
 
         $context->headersManager->add(
-            'include/buffer',
+            'include/reductions',
             HeadersManager::POSITION_LAST
         );
 
diff --git a/optimizers/TensorBufferSumOptimizer.php b/optimizers/TensorBufferSumOptimizer.php
index 2498502..b6335c6 100644
--- a/optimizers/TensorBufferSumOptimizer.php
+++ b/optimizers/TensorBufferSumOptimizer.php
@@ -51,7 +51,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         }
 
         $context->headersManager->add(
-            'include/buffer',
+            'include/reductions',
             HeadersManager::POSITION_LAST
         );
 

From 03c8ee9d831189dcbcde3d96c1e0563363e48552 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 21:47:42 -0500
Subject: [PATCH 40/51] Optimize matrix reducers

---
 CHANGELOG.md                                 |    3 -
 ext/include/reductions.c                     |  507 ++++++++
 ext/include/reductions.h                     |   11 +
 ext/tensor/matrix.zep.c                      | 1172 ++++--------------
 optimizers/TensorMatrixArgmaxOptimizer.php   |   76 ++
 optimizers/TensorMatrixArgminOptimizer.php   |   76 ++
 optimizers/TensorMatrixMaxOptimizer.php      |   76 ++
 optimizers/TensorMatrixMedianOptimizer.php   |   76 ++
 optimizers/TensorMatrixMinOptimizer.php      |   76 ++
 optimizers/TensorMatrixProductOptimizer.php  |   76 ++
 optimizers/TensorMatrixQuantileOptimizer.php |   76 ++
 optimizers/TensorMatrixRepeatOptimizer.php   |   76 ++
 optimizers/TensorMatrixSumOptimizer.php      |   76 ++
 optimizers/TensorMatrixToArrayOptimizer.php  |   76 ++
 tensor/matrix.zep                            |  175 +--
 tests/MatrixTest.php                         |   38 +
 16 files changed, 1557 insertions(+), 1109 deletions(-)
 create mode 100644 optimizers/TensorMatrixArgmaxOptimizer.php
 create mode 100644 optimizers/TensorMatrixArgminOptimizer.php
 create mode 100644 optimizers/TensorMatrixMaxOptimizer.php
 create mode 100644 optimizers/TensorMatrixMedianOptimizer.php
 create mode 100644 optimizers/TensorMatrixMinOptimizer.php
 create mode 100644 optimizers/TensorMatrixProductOptimizer.php
 create mode 100644 optimizers/TensorMatrixQuantileOptimizer.php
 create mode 100644 optimizers/TensorMatrixRepeatOptimizer.php
 create mode 100644 optimizers/TensorMatrixSumOptimizer.php
 create mode 100644 optimizers/TensorMatrixToArrayOptimizer.php

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47326d8..69e0f62 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,5 @@
 # Change Log
 
-- 4.0.1
-    - Fixed a segfault in `Matrix::map()` / `TensorBuffer::map()` when the callback was an array callable of the form `[instance, 'method']` on an operation with more than one element. `map()` now dispatches the callback through PHP's native `array_map()` (matching `Vector::map()`) instead of the Zephir dynamic user-callback loop that mis-resolved instance methods after the first element was cached
-
 - 4.0.0
     
 - 3.1.0
diff --git a/ext/include/reductions.c b/ext/include/reductions.c
index 07ff6b7..3275704 100644
--- a/ext/include/reductions.c
+++ b/ext/include/reductions.c
@@ -377,4 +377,511 @@ void tensor_buffer_argmax(zval * return_value, zval * obj)
 	RETVAL_LONG(index);
 }
 
+/**
+ * Row-wise operations work directly on the flat row-major buffer that backs a
+ * Matrix (m * n doubles) instead of materializing per-row Buffers. This
+ * helper unwraps the buffer and validates that it can be divided into whole
+ * rows of length n, mirroring the semantics of `TensorBuffer::split()`. The
+ * derived row count `*m` and the raw data pointer are written on success.
+ *
+ * @return 1 on success, 0 on failure (throwing).
+ */
+static int tensor_matrix_doubles(zval * obj, zval * n_zval, double ** ptr, zend_long * m, zend_long * n)
+{
+	zend_long total = 0;
+	int ok = 0;
+
+	double * va = tensor_tensorbuffer_doubles(obj, &total, &ok);
+
+	if (UNEXPECTED(!ok)) {
+		return 0;
+	}
+
+	zend_long n_hat = zephir_get_intval(n_zval);
+
+	if (UNEXPECTED(n_hat < 1)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Chunk length must be greater than 0."));
+		return 0;
+	}
+
+	if (UNEXPECTED(total % n_hat != 0)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Matrix and row dimensions must agree."));
+		return 0;
+	}
+
+	*ptr = va;
+	*n = n_hat;
+	*m = total / n_hat;
+
+	return 1;
+}
+
+static int tensor_matrix_double_cmp(const void * a, const void * b)
+{
+	double da = *(const double *) a;
+	double db = *(const double *) b;
+
+	return (da > db) - (da < db);
+}
+
+/**
+ * Return the sum of each row of a matrix as a column buffer.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ */
+void tensor_matrix_sum(zval * return_value, zval * obj, zval * n)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long i, j;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < m; ++i) {
+		const double * row = va + i * n_hat;
+		double acc = 0.0;
+
+		for (j = 0; j < n_hat; ++j) {
+			acc += row[j];
+		}
+
+		vc[i] = acc;
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+/**
+ * Return the product of the elements of each row of a matrix as a column
+ * buffer.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ */
+void tensor_matrix_product(zval * return_value, zval * obj, zval * n)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long i, j;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < m; ++i) {
+		const double * row = va + i * n_hat;
+		double acc = 1.0;
+
+		for (j = 0; j < n_hat; ++j) {
+			acc *= row[j];
+		}
+
+		vc[i] = acc;
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+/**
+ * Return the minimum of each row of a matrix as a column buffer.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ */
+void tensor_matrix_min(zval * return_value, zval * obj, zval * n)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long i, j;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < m; ++i) {
+		const double * row = va + i * n_hat;
+		double best = row[0];
+
+		for (j = 1; j < n_hat; ++j) {
+			if (row[j] < best) {
+				best = row[j];
+			}
+		}
+
+		vc[i] = best;
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+/**
+ * Return the maximum of each row of a matrix as a column buffer.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ */
+void tensor_matrix_max(zval * return_value, zval * obj, zval * n)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long i, j;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < m; ++i) {
+		const double * row = va + i * n_hat;
+		double best = row[0];
+
+		for (j = 1; j < n_hat; ++j) {
+			if (row[j] > best) {
+				best = row[j];
+			}
+		}
+
+		vc[i] = best;
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+/**
+ * Return the index of the minimum of each row of a matrix as a column buffer.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ */
+void tensor_matrix_argmin(zval * return_value, zval * obj, zval * n)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long i, j;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < m; ++i) {
+		const double * row = va + i * n_hat;
+		double best = row[0];
+		zend_long index = 0;
+
+		for (j = 1; j < n_hat; ++j) {
+			if (row[j] < best) {
+				best = row[j];
+				index = j;
+			}
+		}
+
+		vc[i] = (double) index;
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+/**
+ * Return the index of the maximum of each row of a matrix as a column buffer.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ */
+void tensor_matrix_argmax(zval * return_value, zval * obj, zval * n)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long i, j;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	for (i = 0; i < m; ++i) {
+		const double * row = va + i * n_hat;
+		double best = row[0];
+		zend_long index = 0;
+
+		for (j = 1; j < n_hat; ++j) {
+			if (row[j] > best) {
+				best = row[j];
+				index = j;
+			}
+		}
+
+		vc[i] = (double) index;
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+/**
+ * Return the median of each row of a matrix as a column buffer. The matrix
+ * buffer itself is never modified; the rows are copied once and sorted.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ */
+void tensor_matrix_median(zval * return_value, zval * obj, zval * n)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long i;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	double * copy = NULL;
+
+	if (UNEXPECTED(m > 0 && n_hat > 0)) {
+		copy = safe_emalloc((size_t) m * (size_t) n_hat, sizeof(double), 0);
+
+		memcpy(copy, va, (size_t) m * (size_t) n_hat * sizeof(double));
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
+		efree(copy);
+
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	zend_long mid = n_hat / 2;
+	int odd = n_hat % 2 == 1;
+
+	for (i = 0; i < m; ++i) {
+		double * row = copy + i * n_hat;
+
+		qsort(row, (size_t) n_hat, sizeof(double), tensor_matrix_double_cmp);
+
+		if (odd) {
+			vc[i] = row[mid];
+		} else {
+			vc[i] = (row[mid - 1] + row[mid]) / 2.0;
+		}
+	}
+
+	efree(copy);
+
+	zval_ptr_dtor(&c);
+}
+
+/**
+ * Return the q'th quantile of each row of a matrix as a column buffer. The
+ * matrix buffer itself is never modified; the rows are copied once and sorted.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ * @param q
+ */
+void tensor_matrix_quantile(zval * return_value, zval * obj, zval * n, zval * q)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long i;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	double * copy = NULL;
+
+	if (UNEXPECTED(m > 0 && n_hat > 0)) {
+		copy = safe_emalloc((size_t) m * (size_t) n_hat, sizeof(double), 0);
+
+		memcpy(copy, va, (size_t) m * (size_t) n_hat * sizeof(double));
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
+		efree(copy);
+
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	double q_hat = zephir_get_doubleval(q);
+
+	double x = q_hat * (n_hat - 1) + 1;
+
+	zend_long x_hat = (zend_long) x;
+	double remainder = x - (double) x_hat;
+
+	for (i = 0; i < m; ++i) {
+		double * row = copy + i * n_hat;
+		double value;
+
+		qsort(row, (size_t) n_hat, sizeof(double), tensor_matrix_double_cmp);
+
+		if (x_hat >= n_hat) {
+			value = row[n_hat - 1];
+		} else {
+			double t = row[x_hat - 1];
+
+			value = t + remainder * (row[x_hat] - t);
+		}
+
+		vc[i] = value;
+	}
+
+	efree(copy);
+
+	zval_ptr_dtor(&c);
+}
+
+/**
+ * Return a new matrix buffer with rows and columns repeated the given number
+ * of times. Result element (r, c) is element (r % m, c % n) of the input,
+ * yielding (m * (times_m + 1)) rows and (n * (times_n + 1)) columns.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ * @param times_m
+ * @param times_n
+ */
+void tensor_matrix_repeat(zval * return_value, zval * obj, zval * n, zval * times_m, zval * times_n)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long t_m = 0, t_n = 0;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	t_m = zephir_get_intval(times_m);
+	t_n = zephir_get_intval(times_n);
+
+	if (UNEXPECTED(t_m < 0 || t_n < 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Times must be non-negative."));
+		return;
+	}
+
+	zend_long rows = m * (t_m + 1);
+	zend_long cols = n_hat * (t_n + 1);
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, rows * cols, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	zend_long i, k;
+
+	for (i = 0; i < rows; ++i) {
+		const double * src = va + (i % m) * n_hat;
+		double * dst = vc + i * cols;
+
+		for (k = 0; k <= t_n; ++k) {
+			memcpy(dst + k * n_hat, src, (size_t) n_hat * sizeof(double));
+		}
+	}
+
+	zval_ptr_dtor(&c);
+}
+
+/**
+ * Return the matrix as an array of arrays, built directly from the flat
+ * row-major buffer.
+ *
+ * @param return_value
+ * @param obj
+ * @param n
+ */
+void tensor_matrix_to_array(zval * return_value, zval * obj, zval * n)
+{
+	double * va = NULL;
+	zend_long m = 0, n_hat = 0;
+	zend_long i, j;
+
+	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
+		return;
+	}
+
+	array_init_size(return_value, (zend_ulong) m);
+
+	for (i = 0; i < m; ++i) {
+		const double * row = va + i * n_hat;
+		zval row_value;
+
+		array_init_size(&row_value, (zend_ulong) n_hat);
+
+		for (j = 0; j < n_hat; ++j) {
+			add_next_index_double(&row_value, row[j]);
+		}
+
+		add_next_index_zval(return_value, &row_value);
+	}
+}
+
 #endif
\ No newline at end of file
diff --git a/ext/include/reductions.h b/ext/include/reductions.h
index b88662b..b0ec39c 100644
--- a/ext/include/reductions.h
+++ b/ext/include/reductions.h
@@ -10,4 +10,15 @@ void tensor_buffer_max(zval * return_value, zval * obj);
 void tensor_buffer_argmin(zval * return_value, zval * obj);
 void tensor_buffer_argmax(zval * return_value, zval * obj);
 
+void tensor_matrix_sum(zval * return_value, zval * obj, zval * n);
+void tensor_matrix_product(zval * return_value, zval * obj, zval * n);
+void tensor_matrix_min(zval * return_value, zval * obj, zval * n);
+void tensor_matrix_max(zval * return_value, zval * obj, zval * n);
+void tensor_matrix_argmin(zval * return_value, zval * obj, zval * n);
+void tensor_matrix_argmax(zval * return_value, zval * obj, zval * n);
+void tensor_matrix_median(zval * return_value, zval * obj, zval * n);
+void tensor_matrix_quantile(zval * return_value, zval * obj, zval * n, zval * q);
+void tensor_matrix_repeat(zval * return_value, zval * obj, zval * n, zval * times_m, zval * times_n);
+void tensor_matrix_to_array(zval * return_value, zval * obj, zval * n);
+
 #endif
\ No newline at end of file
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index d8ca9c1..19bbd3e 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -24,10 +24,10 @@
 #include "kernel/math.h"
 #include "ext/spl/spl_array.h"
 #include "include/buffer.h"
+#include "include/reductions.h"
 #include "include/linear_algebra.h"
 #include "include/signal_processing.h"
 #include "include/unary.h"
-#include "include/reductions.h"
 #include "include/arithmetic.h"
 #include "include/comparison.h"
 
@@ -1684,23 +1684,12 @@ PHP_METHOD(Tensor_Matrix, flatten)
  */
 PHP_METHOD(Tensor_Matrix, asArray)
 {
-	zend_bool _9;
-	zval b;
-	zval rowBuffer, _0, _1, _2, _3, *_4, _5, *_6, _8, _7$$4, _10$$5;
-	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval _0, _1, _2;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_3);
-	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -1709,62 +1698,15 @@ PHP_METHOD(Tensor_Matrix, asArray)
 	if (UNEXPECTED(!_zephir_prop_1)) {
 		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
-	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
-	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
-
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
 		array_init(return_value);
-		RETURN_MM();
+		return;
 	}
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_2, &_1, "split", NULL, 0, &_3);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_2) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_5);
-		zephir_string_to_char_array(&_5, &_2);
-		_4 = &_5;
-	} else {
-		_4 = &_2;
-	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 620);
-	if (Z_TYPE_P(_4) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _6);
-			ZEPHIR_CALL_METHOD(&_7$$4, &rowBuffer, "toArray", NULL, 0);
-			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 617);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_9 = 1;
-		while (1) {
-			if (_9) {
-				_9 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _4, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_8, _4, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_8)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _4, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "toArray", NULL, 0);
-				zephir_check_call_status();
-				zephir_array_append(&b, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 617);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	RETURN_CTOR(&b);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_matrix_to_array(return_value, &_1, &_2);
+	return;
 }
 
 /**
@@ -1887,7 +1829,7 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 669);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 661);
 		}
 	}
 	RETURN_CTOR(&b);
@@ -2039,7 +1981,7 @@ PHP_METHOD(Tensor_Matrix, transpose)
 		RETURN_MM();
 	}
 	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 721);
+	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 713);
 	ZVAL_LONG(&_3, 1);
 	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 27, &cols, &_3);
 	zephir_check_call_status();
@@ -2104,7 +2046,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 738);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 730);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2117,7 +2059,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 28, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 743);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 735);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2132,7 +2074,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 28, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 750);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 742);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2192,7 +2134,7 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 28, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 767);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 759);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2242,7 +2184,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 783);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 775);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2451,7 +2393,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 851);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 843);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2526,7 +2468,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 871);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 863);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2624,7 +2566,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 2, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 889);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 881);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2638,7 +2580,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 2, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 894);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 886);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2975,7 +2917,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1038);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1030);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3046,7 +2988,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1071);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1063);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3118,7 +3060,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1105);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1097);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3190,7 +3132,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1139);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1131);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3262,7 +3204,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1173);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1165);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3334,7 +3276,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1207);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1199);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3406,7 +3348,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1241);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1233);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3478,7 +3420,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1275);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1267);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3550,7 +3492,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1309);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1301);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3622,7 +3564,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1343);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1335);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3694,7 +3636,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1377);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1369);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3766,7 +3708,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1411);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1403);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4448,23 +4390,14 @@ PHP_METHOD(Tensor_Matrix, deg2rad)
  */
 PHP_METHOD(Tensor_Matrix, sum)
 {
-	zend_bool _8;
-	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -4476,55 +4409,12 @@ PHP_METHOD(Tensor_Matrix, sum)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1596);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_INIT_NVAR(&_6$$3);
-			tensor_buffer_sum(&_6$$3, &rowBuffer);
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1593);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_8 = 1;
-		while (1) {
-			if (_8) {
-				_8 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_7)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_9$$4);
-				tensor_buffer_sum(&_9$$4, &rowBuffer);
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1593);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZVAL_BOOL(&_10, 0);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
+	tensor_matrix_sum(&_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4536,23 +4426,14 @@ PHP_METHOD(Tensor_Matrix, sum)
  */
 PHP_METHOD(Tensor_Matrix, product)
 {
-	zend_bool _8;
-	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -4564,55 +4445,12 @@ PHP_METHOD(Tensor_Matrix, product)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1614);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_INIT_NVAR(&_6$$3);
-			tensor_buffer_product(&_6$$3, &rowBuffer);
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1611);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_8 = 1;
-		while (1) {
-			if (_8) {
-				_8 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_7)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_9$$4);
-				tensor_buffer_product(&_9$$4, &rowBuffer);
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1611);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZVAL_BOOL(&_10, 0);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
+	tensor_matrix_product(&_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4624,23 +4462,14 @@ PHP_METHOD(Tensor_Matrix, product)
  */
 PHP_METHOD(Tensor_Matrix, min)
 {
-	zend_bool _8;
-	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -4652,55 +4481,12 @@ PHP_METHOD(Tensor_Matrix, min)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1632);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_INIT_NVAR(&_6$$3);
-			tensor_buffer_min(&_6$$3, &rowBuffer);
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1629);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_8 = 1;
-		while (1) {
-			if (_8) {
-				_8 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_7)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_9$$4);
-				tensor_buffer_min(&_9$$4, &rowBuffer);
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1629);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZVAL_BOOL(&_10, 0);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
+	tensor_matrix_min(&_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4712,23 +4498,14 @@ PHP_METHOD(Tensor_Matrix, min)
  */
 PHP_METHOD(Tensor_Matrix, max)
 {
-	zend_bool _8;
-	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -4740,55 +4517,12 @@ PHP_METHOD(Tensor_Matrix, max)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1650);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_INIT_NVAR(&_6$$3);
-			tensor_buffer_max(&_6$$3, &rowBuffer);
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1647);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_8 = 1;
-		while (1) {
-			if (_8) {
-				_8 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_7)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_9$$4);
-				tensor_buffer_max(&_9$$4, &rowBuffer);
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1647);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZVAL_BOOL(&_10, 0);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
+	tensor_matrix_max(&_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4800,23 +4534,14 @@ PHP_METHOD(Tensor_Matrix, max)
  */
 PHP_METHOD(Tensor_Matrix, argmin)
 {
-	zend_bool _8;
-	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -4828,55 +4553,12 @@ PHP_METHOD(Tensor_Matrix, argmin)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1668);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_INIT_NVAR(&_6$$3);
-			tensor_buffer_argmin(&_6$$3, &rowBuffer);
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1665);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_8 = 1;
-		while (1) {
-			if (_8) {
-				_8 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_7)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_9$$4);
-				tensor_buffer_argmin(&_9$$4, &rowBuffer);
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1665);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZVAL_BOOL(&_10, 0);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
+	tensor_matrix_argmin(&_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4888,23 +4570,14 @@ PHP_METHOD(Tensor_Matrix, argmin)
  */
 PHP_METHOD(Tensor_Matrix, argmax)
 {
-	zend_bool _8;
-	zval b;
-	zval rowBuffer, _0, _1, _2, *_3, _4, *_5, _7, _10, _6$$3, _9$$4;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_6$$3);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -4916,55 +4589,12 @@ PHP_METHOD(Tensor_Matrix, argmax)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_1, &_0, "split", NULL, 0, &_2);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_1) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_4);
-		zephir_string_to_char_array(&_4, &_1);
-		_3 = &_4;
-	} else {
-		_3 = &_1;
-	}
-	zephir_is_iterable(_3, 0, "tensor/matrix.zep", 1686);
-	if (Z_TYPE_P(_3) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3), _5)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _5);
-			ZEPHIR_INIT_NVAR(&_6$$3);
-			tensor_buffer_argmax(&_6$$3, &rowBuffer);
-			zephir_array_append(&b, &_6$$3, PH_SEPARATE, "tensor/matrix.zep", 1683);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _3, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_8 = 1;
-		while (1) {
-			if (_8) {
-				_8 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _3, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_7, _3, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_7)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _3, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_9$$4);
-				tensor_buffer_argmax(&_9$$4, &rowBuffer);
-				zephir_array_append(&b, &_9$$4, PH_SEPARATE, "tensor/matrix.zep", 1683);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZVAL_BOOL(&_10, 0);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_10);
+	tensor_matrix_argmax(&_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5005,134 +4635,31 @@ PHP_METHOD(Tensor_Matrix, mean)
  */
 PHP_METHOD(Tensor_Matrix, median)
 {
-	zend_bool odd, _15;
-	zval b;
-	zval rowBuffer, median, _0, _1, _2, _3, _4, _5, *_6, _7, *_8, _14, _21, _9$$4, _10$$5, _11$$5, _12$$5, _13$$5, _16$$7, _17$$8, _18$$8, _19$$8, _20$$8;
+	zval _0, _1, _2;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, mid;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowBuffer);
-	ZVAL_UNDEF(&median);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&_3);
-	ZVAL_UNDEF(&_4);
-	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_7);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_21);
-	ZVAL_UNDEF(&_9$$4);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_11$$5);
-	ZVAL_UNDEF(&_12$$5);
-	ZVAL_UNDEF(&_13$$5);
-	ZVAL_UNDEF(&_16$$7);
-	ZVAL_UNDEF(&_17$$8);
-	ZVAL_UNDEF(&_18$$8);
-	ZVAL_UNDEF(&_19$$8);
-	ZVAL_UNDEF(&_20$$8);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("n", 1, 1);
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZVAL_LONG(&_1, 2);
-	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 18, &_0, &_1);
-	zephir_check_call_status();
-	mid = zephir_get_intval(&_2);
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	odd = zephir_safe_mod_zval_long(&_1, 2) == 1;
-	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_4, &_3, "split", NULL, 0, &_5);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_4) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_7);
-		zephir_string_to_char_array(&_7, &_4);
-		_6 = &_7;
-	} else {
-		_6 = &_4;
-	}
-	zephir_is_iterable(_6, 0, "tensor/matrix.zep", 1726);
-	if (Z_TYPE_P(_6) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_6), _8)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _8);
-			ZEPHIR_CALL_METHOD(NULL, &rowBuffer, "sort", NULL, 0);
-			zephir_check_call_status();
-			if (odd) {
-				ZVAL_LONG(&_9$$4, mid);
-				ZEPHIR_CALL_METHOD(&median, &rowBuffer, "get", NULL, 0, &_9$$4);
-				zephir_check_call_status();
-			} else {
-				ZVAL_LONG(&_11$$5, (mid - 1));
-				ZEPHIR_CALL_METHOD(&_10$$5, &rowBuffer, "get", NULL, 0, &_11$$5);
-				zephir_check_call_status();
-				ZVAL_LONG(&_11$$5, mid);
-				ZEPHIR_CALL_METHOD(&_12$$5, &rowBuffer, "get", NULL, 0, &_11$$5);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_13$$5);
-				zephir_add_function(&_13$$5, &_10$$5, &_12$$5);
-				ZEPHIR_INIT_NVAR(&median);
-				ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_13$$5, 2.0));
-			}
-			zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1723);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _6, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _6, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _6, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(NULL, &rowBuffer, "sort", NULL, 0);
-				zephir_check_call_status();
-				if (odd) {
-					ZVAL_LONG(&_16$$7, mid);
-					ZEPHIR_CALL_METHOD(&median, &rowBuffer, "get", NULL, 0, &_16$$7);
-					zephir_check_call_status();
-				} else {
-					ZVAL_LONG(&_18$$8, (mid - 1));
-					ZEPHIR_CALL_METHOD(&_17$$8, &rowBuffer, "get", NULL, 0, &_18$$8);
-					zephir_check_call_status();
-					ZVAL_LONG(&_18$$8, mid);
-					ZEPHIR_CALL_METHOD(&_19$$8, &rowBuffer, "get", NULL, 0, &_18$$8);
-					zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&_20$$8);
-					zephir_add_function(&_20$$8, &_17$$8, &_19$$8);
-					ZEPHIR_INIT_NVAR(&median);
-					ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_20$$8, 2.0));
-				}
-				zephir_array_append(&b, &median, PH_SEPARATE, "tensor/matrix.zep", 1723);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZVAL_BOOL(&_21, 0);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_21);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_INIT_VAR(&_0);
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_matrix_median(&_0, &_1, &_2);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5146,52 +4673,28 @@ PHP_METHOD(Tensor_Matrix, median)
  */
 PHP_METHOD(Tensor_Matrix, quantile)
 {
-	zval b;
-	zend_bool _0, _22;
+	zend_bool _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, xHat;
-	zval *q_param = NULL, rowBuffer, _5, _6, _7, _8, *_9, _10, *_11, _21, _32, _1$$3, _2$$3, _3$$3, _4$$3, _12$$4, _17$$4, _18$$4, _19$$4, _20$$4, _13$$5, _14$$5, _15$$5, _16$$5, _23$$6, _28$$6, _29$$6, _30$$6, _31$$6, _24$$7, _25$$7, _26$$7, _27$$7;
-	double q, t = 0, x, remainder;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *q_param = NULL, _5, _6, _7, _8, _1$$3, _2$$3, _3$$3, _4$$3;
+	double q;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowBuffer);
 	ZVAL_UNDEF(&_5);
 	ZVAL_UNDEF(&_6);
 	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_8);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_21);
-	ZVAL_UNDEF(&_32);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_17$$4);
-	ZVAL_UNDEF(&_18$$4);
-	ZVAL_UNDEF(&_19$$4);
-	ZVAL_UNDEF(&_20$$4);
-	ZVAL_UNDEF(&_13$$5);
-	ZVAL_UNDEF(&_14$$5);
-	ZVAL_UNDEF(&_15$$5);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_23$$6);
-	ZVAL_UNDEF(&_28$$6);
-	ZVAL_UNDEF(&_29$$6);
-	ZVAL_UNDEF(&_30$$6);
-	ZVAL_UNDEF(&_31$$6);
-	ZVAL_UNDEF(&_24$$7);
-	ZVAL_UNDEF(&_25$$7);
-	ZVAL_UNDEF(&_26$$7);
-	ZVAL_UNDEF(&_27$$7);
-	ZVAL_UNDEF(&b);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("n", 1, 1);
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -5215,103 +4718,17 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1740);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1664);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	x =  (((q * (double) ((zephir_get_numberval(&_5) - 1))) + (double) (1)));
-	xHat = (int) x;
-	remainder =  ((x -  (double) xHat));
-	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_7, &_6, "split", NULL, 0, &_8);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_7) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_7);
-		_9 = &_10;
-	} else {
-		_9 = &_7;
-	}
-	zephir_is_iterable(_9, 0, "tensor/matrix.zep", 1769);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowBuffer);
-			ZVAL_COPY(&rowBuffer, _11);
-			ZEPHIR_CALL_METHOD(NULL, &rowBuffer, "sort", NULL, 0);
-			zephir_check_call_status();
-			zephir_read_property_cached(&_12$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-			if (ZEPHIR_LE_LONG(&_12$$4, xHat)) {
-				zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-				ZVAL_LONG(&_15$$5, (zephir_get_numberval(&_14$$5) - 1));
-				ZEPHIR_CALL_METHOD(&_13$$5, &rowBuffer, "get", NULL, 0, &_15$$5);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				ZVAL_DOUBLE(&_16$$5, zephir_get_doubleval(&_13$$5));
-				zephir_array_append(&b, &_16$$5, PH_SEPARATE, "tensor/matrix.zep", 1759);
-				continue;
-			}
-			ZVAL_LONG(&_18$$4, (xHat - 1));
-			ZEPHIR_CALL_METHOD(&_17$$4, &rowBuffer, "get", NULL, 0, &_18$$4);
-			zephir_check_call_status();
-			t =  (zephir_get_doubleval(&_17$$4));
-			ZVAL_LONG(&_18$$4, xHat);
-			ZEPHIR_CALL_METHOD(&_19$$4, &rowBuffer, "get", NULL, 0, &_18$$4);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&_20$$4);
-			ZVAL_DOUBLE(&_20$$4, (t + (remainder * (zephir_get_numberval(&_19$$4) - t))));
-			zephir_array_append(&b, &_20$$4, PH_SEPARATE, "tensor/matrix.zep", 1766);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_22 = 1;
-		while (1) {
-			if (_22) {
-				_22 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_21, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_21)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowBuffer, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_CALL_METHOD(NULL, &rowBuffer, "sort", NULL, 0);
-				zephir_check_call_status();
-				zephir_read_property_cached(&_23$$6, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-				if (ZEPHIR_LE_LONG(&_23$$6, xHat)) {
-					zephir_read_property_cached(&_25$$7, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-					ZVAL_LONG(&_26$$7, (zephir_get_numberval(&_25$$7) - 1));
-					ZEPHIR_CALL_METHOD(&_24$$7, &rowBuffer, "get", NULL, 0, &_26$$7);
-					zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&_27$$7);
-					ZVAL_DOUBLE(&_27$$7, zephir_get_doubleval(&_24$$7));
-					zephir_array_append(&b, &_27$$7, PH_SEPARATE, "tensor/matrix.zep", 1759);
-					continue;
-				}
-				ZVAL_LONG(&_29$$6, (xHat - 1));
-				ZEPHIR_CALL_METHOD(&_28$$6, &rowBuffer, "get", NULL, 0, &_29$$6);
-				zephir_check_call_status();
-				t =  (zephir_get_doubleval(&_28$$6));
-				ZVAL_LONG(&_29$$6, xHat);
-				ZEPHIR_CALL_METHOD(&_30$$6, &rowBuffer, "get", NULL, 0, &_29$$6);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_31$$6);
-				ZVAL_DOUBLE(&_31$$6, (t + (remainder * (zephir_get_numberval(&_30$$6) - t))));
-				zephir_array_append(&b, &_31$$6, PH_SEPARATE, "tensor/matrix.zep", 1766);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowBuffer);
-	ZVAL_BOOL(&_32, 0);
-	ZEPHIR_RETURN_CALL_CE_STATIC(tensor_columnvector_ce, "fromArray", NULL, 0, &b, &_32);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_INIT_VAR(&_5);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_8, q);
+	tensor_matrix_quantile(&_5, &_6, &_7, &_8);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5382,7 +4799,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1785);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1683);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5402,7 +4819,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 2, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1791);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1689);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5491,7 +4908,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 2, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1816);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1714);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5519,42 +4936,20 @@ PHP_METHOD(Tensor_Matrix, covariance)
  */
 PHP_METHOD(Tensor_Matrix, round)
 {
-	zend_bool _22;
-	zval b;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_17 = NULL, *_20 = NULL, *_25 = NULL, *_28 = NULL;
-	zval *precision_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4$$3, _5$$4, _6$$4, _7$$4, _8$$4, rowA, valueA, _9, _10, _11, *_12, _13, *_14, _21, _29, _30, _31, _15$$5, _16$$6, _18$$6, _19$$6, _23$$7, _24$$8, _26$$8, _27$$8;
-	zend_long precision, ZEPHIR_LAST_CALL_STATUS, i = 0;
+	zval *precision_param = NULL, _0$$3, _1$$3, _2$$3, _3$$3, _4, _5, _6, _7, _8;
+	zend_long precision, ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_6$$4);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&_9);
-	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_11);
-	ZVAL_UNDEF(&_13);
-	ZVAL_UNDEF(&_21);
-	ZVAL_UNDEF(&_29);
-	ZVAL_UNDEF(&_30);
-	ZVAL_UNDEF(&_31);
-	ZVAL_UNDEF(&_15$$5);
-	ZVAL_UNDEF(&_16$$6);
-	ZVAL_UNDEF(&_18$$6);
-	ZVAL_UNDEF(&_19$$6);
-	ZVAL_UNDEF(&_23$$7);
-	ZVAL_UNDEF(&_24$$8);
-	ZVAL_UNDEF(&_26$$8);
-	ZVAL_UNDEF(&_27$$8);
-	ZVAL_UNDEF(&b);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
@@ -5579,115 +4974,28 @@ PHP_METHOD(Tensor_Matrix, round)
 		precision = 0;
 	} else {
 		}
-	if (precision == 0) {
-		object_init_ex(return_value, tensor_matrix_ce);
-		ZEPHIR_INIT_VAR(&_0$$3);
-		zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-		ZVAL_LONG(&_2$$3, 0);
-		tensor_round(&_0$$3, &_1$$3, &_2$$3);
-		zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-		zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_0$$3, &_3$$3, &_4$$3);
-		zephir_check_call_status();
-		RETURN_MM();
-	}
 	if (UNEXPECTED(precision < 0)) {
-		ZEPHIR_INIT_VAR(&_5$$4);
-		object_init_ex(&_5$$4, tensor_exceptions_invalidargumentexception_ce);
-		ZVAL_LONG(&_6$$4, precision);
-		ZEPHIR_CALL_FUNCTION(&_7$$4, "strval", NULL, 3, &_6$$4);
+		ZEPHIR_INIT_VAR(&_0$$3);
+		object_init_ex(&_0$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZVAL_LONG(&_1$$3, precision);
+		ZEPHIR_CALL_FUNCTION(&_2$$3, "strval", NULL, 3, &_1$$3);
 		zephir_check_call_status();
-		ZEPHIR_INIT_VAR(&_8$$4);
-		ZEPHIR_CONCAT_SSVS(&_8$$4, "Decimal precision cannot", " be less than 0, ", &_7$$4, " given.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_8$$4);
+		ZEPHIR_INIT_VAR(&_3$$3);
+		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
+		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 1843);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1735);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&b);
-	array_init(&b);
-	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&_10, &_9, "split", NULL, 0, &_11);
-	zephir_check_call_status();
-	if (Z_TYPE_P(&_10) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_13);
-		zephir_string_to_char_array(&_13, &_10);
-		_12 = &_13;
-	} else {
-		_12 = &_10;
-	}
-	zephir_is_iterable(_12, 0, "tensor/matrix.zep", 1866);
-	if (Z_TYPE_P(_12) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_12), _14)
-		{
-			ZEPHIR_INIT_NVAR(&rowA);
-			ZVAL_COPY(&rowA, _14);
-			i = 0;
-			while (1) {
-				zephir_read_property_cached(&_15$$5, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-				if (!(ZEPHIR_GT_LONG(&_15$$5, i))) {
-					break;
-				}
-				ZVAL_LONG(&_16$$6, i);
-				ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_17, 0, &_16$$6);
-				zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_18$$6);
-				ZVAL_LONG(&_16$$6, precision);
-				zephir_round(&_18$$6, &valueA, &_16$$6, NULL);
-				ZVAL_LONG(&_19$$6, i);
-				ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_20, 0, &_19$$6, &_18$$6);
-				zephir_check_call_status();
-				i++;
-			}
-			zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1863);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _12, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_22 = 1;
-		while (1) {
-			if (_22) {
-				_22 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _12, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_21, _12, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_21)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowA, _12, "current", NULL, 0);
-			zephir_check_call_status();
-				i = 0;
-				while (1) {
-					zephir_read_property_cached(&_23$$7, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-					if (!(ZEPHIR_GT_LONG(&_23$$7, i))) {
-						break;
-					}
-					ZVAL_LONG(&_24$$8, i);
-					ZEPHIR_CALL_METHOD(&valueA, &rowA, "get", &_25, 0, &_24$$8);
-					zephir_check_call_status();
-					ZEPHIR_INIT_NVAR(&_26$$8);
-					ZVAL_LONG(&_24$$8, precision);
-					zephir_round(&_26$$8, &valueA, &_24$$8, NULL);
-					ZVAL_LONG(&_27$$8, i);
-					ZEPHIR_CALL_METHOD(NULL, &rowA, "set", &_28, 0, &_27$$8, &_26$$8);
-					zephir_check_call_status();
-					i++;
-				}
-				zephir_array_append(&b, &rowA, PH_SEPARATE, "tensor/matrix.zep", 1863);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowA);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_29, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &b);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_30, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_31, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_29, &_30, &_31);
+	ZEPHIR_INIT_VAR(&_4);
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_6, precision);
+	tensor_round(&_4, &_5, &_6);
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_4, &_7, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5831,7 +5139,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1902);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1774);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6108,7 +5416,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1968);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1840);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6206,7 +5514,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1988);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1860);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6316,7 +5624,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2008);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1880);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6359,7 +5667,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2022);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1894);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -6462,7 +5770,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 2040);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1912);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6505,7 +5813,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 2054);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1926);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -6532,44 +5840,40 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
  */
 PHP_METHOD(Tensor_Matrix, repeat)
 {
-	zend_bool _9$$3;
-	zval bigRows;
+	zval _4$$4;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zval *m_param = NULL, *n_param = NULL, rowA, _18, _19, _0$$3, _1$$3, _2$$3, *_3$$3, _4$$3, *_5$$3, _8$$3, _6$$4, _7$$4, _10$$5, _11$$5, flat$$6, _12$$6, _13$$6, _14$$6, _15$$6, _16$$6, _17$$6;
+	zval *m_param = NULL, *n_param = NULL, _0$$3, _1$$3, _2, _5, result, _8, _9, _10, _11, _12, _13, _14, _15, _3$$4, _6$$5, _7$$5;
 	zend_long m, n, ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&rowA);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&_1$$3);
-	ZVAL_UNDEF(&_2$$3);
-	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_8$$3);
-	ZVAL_UNDEF(&_6$$4);
-	ZVAL_UNDEF(&_7$$4);
-	ZVAL_UNDEF(&_10$$5);
-	ZVAL_UNDEF(&_11$$5);
-	ZVAL_UNDEF(&flat$$6);
-	ZVAL_UNDEF(&_12$$6);
-	ZVAL_UNDEF(&_13$$6);
-	ZVAL_UNDEF(&_14$$6);
-	ZVAL_UNDEF(&_15$$6);
-	ZVAL_UNDEF(&_16$$6);
-	ZVAL_UNDEF(&_17$$6);
-	ZVAL_UNDEF(&bigRows);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&result);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_12);
+	ZVAL_UNDEF(&_13);
+	ZVAL_UNDEF(&_14);
+	ZVAL_UNDEF(&_15);
+	ZVAL_UNDEF(&_3$$4);
+	ZVAL_UNDEF(&_6$$5);
+	ZVAL_UNDEF(&_7$$5);
+	ZVAL_UNDEF(&_4$$4);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_2)) {
-		_zephir_prop_2 = zend_string_init("m", 1, 1);
+		_zephir_prop_2 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(2, 2)
@@ -6579,83 +5883,47 @@ PHP_METHOD(Tensor_Matrix, repeat)
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 2, 0, &m_param, &n_param);
-	ZEPHIR_INIT_VAR(&bigRows);
-	array_init(&bigRows);
-	if (n > 0) {
-		zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-		zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-		ZEPHIR_CALL_METHOD(&_1$$3, &_0$$3, "split", NULL, 0, &_2$$3);
-		zephir_check_call_status();
-		if (Z_TYPE_P(&_1$$3) == IS_STRING) {
-			ZEPHIR_INIT_VAR(&_4$$3);
-			zephir_string_to_char_array(&_4$$3, &_1$$3);
-			_3$$3 = &_4$$3;
-		} else {
-			_3$$3 = &_1$$3;
-		}
-		zephir_is_iterable(_3$$3, 0, "tensor/matrix.zep", 2078);
-		if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$3), _5$$3)
-			{
-				ZEPHIR_INIT_NVAR(&rowA);
-				ZVAL_COPY(&rowA, _5$$3);
-				ZVAL_LONG(&_7$$4, (n + 1));
-				ZEPHIR_CALL_METHOD(&_6$$4, &rowA, "repeat", NULL, 0, &_7$$4);
-				zephir_check_call_status();
-				zephir_array_append(&bigRows, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 2076);
-			} ZEND_HASH_FOREACH_END();
-		} else {
-			ZEPHIR_CALL_METHOD(NULL, _3$$3, "rewind", NULL, 0);
-			zephir_check_call_status();
-			_9$$3 = 1;
-			while (1) {
-				if (_9$$3) {
-					_9$$3 = 0;
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _3$$3, "next", NULL, 0);
-					zephir_check_call_status();
-				}
-				ZEPHIR_CALL_METHOD(&_8$$3, _3$$3, "valid", NULL, 0);
-				zephir_check_call_status();
-				if (!zend_is_true(&_8$$3)) {
-					break;
-				}
-				ZEPHIR_CALL_METHOD(&rowA, _3$$3, "current", NULL, 0);
-				zephir_check_call_status();
-					ZVAL_LONG(&_11$$5, (n + 1));
-					ZEPHIR_CALL_METHOD(&_10$$5, &rowA, "repeat", NULL, 0, &_11$$5);
-					zephir_check_call_status();
-					zephir_array_append(&bigRows, &_10$$5, PH_SEPARATE, "tensor/matrix.zep", 2076);
-			}
-		}
-		ZEPHIR_INIT_NVAR(&rowA);
-	}
-	if (zephir_fast_count_int(&bigRows) > 0) {
-		zephir_memory_observe(&flat$$6);
-		zephir_array_fetch_long(&flat$$6, &bigRows, 0, PH_NOISY, "tensor/matrix.zep", 2081);
-		ZVAL_LONG(&_13$$6, 1);
-		ZEPHIR_CALL_FUNCTION(&_14$$6, "array_slice", NULL, 27, &bigRows, &_13$$6);
-		zephir_check_call_status();
-		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "concat", NULL, 0, &_14$$6);
+	if (UNEXPECTED(n < 1)) {
+		ZEPHIR_INIT_VAR(&_0$$3);
+		array_init(&_0$$3);
+		ZVAL_BOOL(&_1$$3, 0);
+		ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &_0$$3, &_1$$3);
 		zephir_check_call_status();
-		ZEPHIR_CPY_WRT(&flat$$6, &_12$$6);
-		ZVAL_LONG(&_13$$6, (m + 1));
-		ZEPHIR_CALL_METHOD(&_12$$6, &flat$$6, "repeat", NULL, 0, &_13$$6);
+		RETURN_MM();
+	}
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_2, 1))) {
+		ZEPHIR_INIT_VAR(&_3$$4);
+		object_init_ex(&_3$$4, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_4$$4);
+		ZEPHIR_CONCAT_SS(&_4$$4, "Chunk length must be", " greater than 0, 0 given.");
+		ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 2, &_4$$4);
 		zephir_check_call_status();
-		ZEPHIR_CPY_WRT(&flat$$6, &_12$$6);
-		object_init_ex(return_value, tensor_matrix_ce);
-		zephir_read_property_cached(&_13$$6, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
-		zephir_read_property_cached(&_15$$6, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-		ZVAL_LONG(&_16$$6, (zephir_get_numberval(&_13$$6) * ((m + 1))));
-		ZVAL_LONG(&_17$$6, (zephir_get_numberval(&_15$$6) * ((n + 1))));
-		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &flat$$6, &_16$$6, &_17$$6);
+		zephir_throw_exception_debug(&_3$$4, "tensor/matrix.zep", 1948);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_5, 1))) {
+		ZEPHIR_INIT_VAR(&_6$$5);
+		array_init(&_6$$5);
+		ZVAL_BOOL(&_7$$5, 0);
+		ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &_6$$5, &_7$$5);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	ZEPHIR_INIT_VAR(&_18);
-	array_init(&_18);
-	ZVAL_BOOL(&_19, 0);
-	ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &_18, &_19);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_10, m);
+	ZVAL_LONG(&_11, n);
+	tensor_matrix_repeat(&result, &_8, &_9, &_10, &_11);
+	object_init_ex(return_value, tensor_matrix_ce);
+	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_13, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_14, (zephir_get_numberval(&_12) * ((m + 1))));
+	ZVAL_LONG(&_15, (zephir_get_numberval(&_13) * ((n + 1))));
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_14, &_15);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6720,7 +5988,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2104);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1971);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6796,7 +6064,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2123);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1990);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6872,7 +6140,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2142);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2009);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6948,7 +6216,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2161);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2028);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7025,7 +6293,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2181);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2048);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7102,7 +6370,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2201);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2068);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7179,7 +6447,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2221);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2088);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7255,7 +6523,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2240);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2107);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7332,7 +6600,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2260);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2127);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7409,7 +6677,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2280);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2147);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7485,7 +6753,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2299);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2166);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7561,7 +6829,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2318);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2185);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7642,7 +6910,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2338);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2205);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7725,7 +6993,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2362);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2229);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7808,7 +7076,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2386);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2253);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7891,7 +7159,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2410);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2277);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7974,7 +7242,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2434);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2301);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8057,7 +7325,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2458);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2325);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8141,7 +7409,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2483);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2350);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8224,7 +7492,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2507);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2374);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8307,7 +7575,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2531);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2398);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8390,7 +7658,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2555);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2422);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8473,7 +7741,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2579);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2446);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8557,7 +7825,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2604);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2471);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8640,7 +7908,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2628);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2495);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8723,7 +7991,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2652);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2519);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8806,7 +8074,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2676);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2543);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8889,7 +8157,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2700);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2567);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8972,7 +8240,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2724);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2591);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9055,7 +8323,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2748);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2615);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9138,7 +8406,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2772);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2639);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9221,7 +8489,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2796);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2663);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9304,7 +8572,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2820);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2687);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9387,7 +8655,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2844);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2711);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9470,7 +8738,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2868);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2735);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9553,7 +8821,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2892);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2759);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10217,7 +9485,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3077);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2944);
 	return;
 }
 
@@ -10268,7 +9536,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 3101);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2968);
 	return;
 }
 
@@ -10328,7 +9596,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 3115);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 2982);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10345,7 +9613,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 3120);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 2987);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -10468,16 +9736,16 @@ PHP_METHOD(Tensor_Matrix, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3163);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3030);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_2, &rebuilt, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_2);
-	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3166);
+	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3033);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_3);
-	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3167);
+	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3034);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_4);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/optimizers/TensorMatrixArgmaxOptimizer.php b/optimizers/TensorMatrixArgmaxOptimizer.php
new file mode 100644
index 0000000..1a514db
--- /dev/null
+++ b/optimizers/TensorMatrixArgmaxOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixArgmaxOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor matrix argmax accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_argmax($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixArgminOptimizer.php b/optimizers/TensorMatrixArgminOptimizer.php
new file mode 100644
index 0000000..efd2298
--- /dev/null
+++ b/optimizers/TensorMatrixArgminOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixArgminOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor matrix argmin accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_argmin($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixMaxOptimizer.php b/optimizers/TensorMatrixMaxOptimizer.php
new file mode 100644
index 0000000..5940782
--- /dev/null
+++ b/optimizers/TensorMatrixMaxOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixMaxOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor matrix max accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_max($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixMedianOptimizer.php b/optimizers/TensorMatrixMedianOptimizer.php
new file mode 100644
index 0000000..d156812
--- /dev/null
+++ b/optimizers/TensorMatrixMedianOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixMedianOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor matrix median accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_median($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixMinOptimizer.php b/optimizers/TensorMatrixMinOptimizer.php
new file mode 100644
index 0000000..8355caa
--- /dev/null
+++ b/optimizers/TensorMatrixMinOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixMinOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor matrix min accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_min($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixProductOptimizer.php b/optimizers/TensorMatrixProductOptimizer.php
new file mode 100644
index 0000000..35d0885
--- /dev/null
+++ b/optimizers/TensorMatrixProductOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixProductOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor matrix product accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_product($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixQuantileOptimizer.php b/optimizers/TensorMatrixQuantileOptimizer.php
new file mode 100644
index 0000000..7ce438e
--- /dev/null
+++ b/optimizers/TensorMatrixQuantileOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixQuantileOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor matrix quantile accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_quantile($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixRepeatOptimizer.php b/optimizers/TensorMatrixRepeatOptimizer.php
new file mode 100644
index 0000000..6391538
--- /dev/null
+++ b/optimizers/TensorMatrixRepeatOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixRepeatOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 4) {
+            throw new CompilerException(
+                'Tensor matrix repeat accepts exactly four arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_repeat($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]}, {$resolvedParams[3]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixSumOptimizer.php b/optimizers/TensorMatrixSumOptimizer.php
new file mode 100644
index 0000000..1e72191
--- /dev/null
+++ b/optimizers/TensorMatrixSumOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixSumOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor matrix sum accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_sum($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixToArrayOptimizer.php b/optimizers/TensorMatrixToArrayOptimizer.php
new file mode 100644
index 0000000..fef4b82
--- /dev/null
+++ b/optimizers/TensorMatrixToArrayOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixToArrayOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor matrix to array accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_to_array($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 5d9899b..8055742 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -605,19 +605,11 @@ class Matrix implements Tensor
      */
     public function asArray() -> array
     {
-        var rowBuffer;
-
-        array b = [];
-
         if unlikely this->n < 1 {
             return [];
         }
 
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = rowBuffer->toArray();
-        }
-
-        return b;
+        return tensor_matrix_to_array(this->a, this->n);
     }
 
     /**
@@ -1585,15 +1577,7 @@ class Matrix implements Tensor
      */
     public function sum() -> <ColumnVector>
     {
-        var rowBuffer;
-
-        array b = [];
-
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = tensor_buffer_sum(rowBuffer);
-        }
-
-        return ColumnVector::fromArray(b, false);
+        return new ColumnVector(tensor_matrix_sum(this->a, this->n));
     }
 
     /**
@@ -1603,15 +1587,7 @@ class Matrix implements Tensor
      */
     public function product() -> <ColumnVector>
     {
-        var rowBuffer;
-
-        array b = [];
-
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = tensor_buffer_product(rowBuffer);
-        }
-
-        return ColumnVector::fromArray(b, false);
+        return new ColumnVector(tensor_matrix_product(this->a, this->n));
     }
 
     /**
@@ -1621,15 +1597,7 @@ class Matrix implements Tensor
      */
     public function min() -> <ColumnVector>
     {
-        var rowBuffer;
-
-        array b = [];
-
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = tensor_buffer_min(rowBuffer);
-        }
-
-        return ColumnVector::fromArray(b, false);
+        return new ColumnVector(tensor_matrix_min(this->a, this->n));
     }
 
     /**
@@ -1639,15 +1607,7 @@ class Matrix implements Tensor
      */
     public function max() -> <ColumnVector>
     {
-        var rowBuffer;
-
-        array b = [];
-
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = tensor_buffer_max(rowBuffer);
-        }
-
-        return ColumnVector::fromArray(b, false);
+        return new ColumnVector(tensor_matrix_max(this->a, this->n));
     }
 
     /**
@@ -1657,15 +1617,7 @@ class Matrix implements Tensor
      */
     public function argmin() -> <ColumnVector>
     {
-        var rowBuffer;
-
-        array b = [];
-
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = tensor_buffer_argmin(rowBuffer);
-        }
-
-        return ColumnVector::fromArray(b, false);
+        return new ColumnVector(tensor_matrix_argmin(this->a, this->n));
     }
 
     /**
@@ -1675,15 +1627,7 @@ class Matrix implements Tensor
      */
     public function argmax() -> <ColumnVector>
     {
-        var rowBuffer;
-
-        array b = [];
-
-        for rowBuffer in this->a->split(this->n) {
-            let b[] = tensor_buffer_argmax(rowBuffer);
-        }
-
-        return ColumnVector::fromArray(b, false);
+        return new ColumnVector(tensor_matrix_argmax(this->a, this->n));
     }
 
     /**
@@ -1703,27 +1647,7 @@ class Matrix implements Tensor
      */
     public function median() -> <ColumnVector>
     {
-        var rowBuffer, median;
-
-        array b = [];
-
-        int mid = (int) intdiv(this->n, 2);
-
-        bool odd = this->n % 2 === 1;
-
-        for rowBuffer in this->a->split(this->n) {
-            rowBuffer->sort();
-
-            if odd {
-                let median = rowBuffer->get(mid);
-            } else {
-                let median = (rowBuffer->get(mid - 1) + rowBuffer->get(mid)) / 2.0;
-            }
-
-            let b[] = median;
-        }
-
-        return ColumnVector::fromArray(b, false);
+        return new ColumnVector(tensor_matrix_median(this->a, this->n));
     }
 
     /**
@@ -1740,33 +1664,7 @@ class Matrix implements Tensor
                 . " 0 and 1, " . strval(q) . " given.");
         }
 
-        float t;
-
-        var rowBuffer;
-        
-        array b = [];
-
-        float x = q * (this->n - 1) + 1;
-
-        int xHat = (int) x;
-    
-        float remainder = x - xHat;
-
-        for rowBuffer in this->a->split(this->n) {
-            rowBuffer->sort();
-
-            if xHat >= this->n {
-                let b[] = (float) rowBuffer->get(this->n - 1);
-
-                continue;
-            }
-
-            let t = (float) rowBuffer->get(xHat - 1);
-
-            let b[] = t + remainder * (rowBuffer->get(xHat) - t);
-        }
-
-        return ColumnVector::fromArray(b, false);
+        return new ColumnVector(tensor_matrix_quantile(this->a, this->n, q));
     }
 
     /**
@@ -1832,38 +1730,12 @@ class Matrix implements Tensor
      */
     public function round(const int precision = 0) -> <Matrix>
     {
-        if precision === 0 {
-            return new self(
-                tensor_round(this->a, 0), this->m, this->n
-            );
-        }
-
         if unlikely precision < 0 {
             throw new InvalidArgumentException("Decimal precision cannot"
                 . " be less than 0, ". strval(precision) . " given.");
         }
 
-        var rowA, valueA;
-
-        int i;
-
-        array b = [];
-
-        for rowA in this->a->split(this->n) {
-            let i = 0;
-
-            while i < this->n {
-                let valueA = rowA->get(i);
-
-                rowA->set(i, round(valueA, precision));
-
-                let i++;
-            }
-
-            let b[] = rowA;
-        }
-
-        return new self(TensorBuffer::fromBuffers(b), this->m, this->n);
+        return new self(tensor_round(this->a, precision), this->m, this->n);
     }
 
     /**
@@ -2067,27 +1939,22 @@ class Matrix implements Tensor
      */
     public function repeat(const int m, const int n) -> <Matrix>
     {
-        var rowA;
-
-        array bigRows = [];
-
-        if n > 0 {
-            for rowA in this->a->split(this->n) {
-                let bigRows[] = rowA->repeat(n + 1);
-            }
+        if unlikely n < 1 {
+            return self::fromArray([], false);
         }
 
-        if count(bigRows) > 0 {
-            var flat = bigRows[0];
-
-            let flat = flat->concat(array_slice(bigRows, 1));
-
-            let flat = flat->repeat(m + 1);
+        if unlikely this->n < 1 {
+            throw new InvalidArgumentException("Chunk length must be"
+                . " greater than 0, 0 given.");
+        }
 
-            return new self(flat, this->m * (m + 1), this->n * (n + 1));
+        if unlikely this->m < 1 {
+            return self::fromArray([], false);
         }
 
-        return self::fromArray([], false);
+        var result = tensor_matrix_repeat(this->a, this->n, m, n);
+
+        return new self(result, this->m * (m + 1), this->n * (n + 1));
     }
 
     /**
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index fa501a9..4f1116c 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -2880,6 +2880,44 @@ public function round() : void
         $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
     }
 
+    /**
+     * @test
+     */
+    public function roundFractions() : void
+    {
+        $a = Matrix::fromArray([
+            [1.2345, 2.675, -0.125],
+            [0.125, 1.005, 12.345],
+            [-12.345, 2.5, -2.5],
+        ]);
+
+        $b = $a->round(2);
+
+        $expected = Matrix::fromArray([
+            [round(1.2345, 2), round(2.675, 2), round(-0.125, 2)],
+            [round(0.125, 2), round(1.005, 2), round(12.345, 2)],
+            [round(-12.345, 2), round(2.5, 2), round(-2.5, 2)],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $b->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function roundNegativePrecisionThrows() : void
+    {
+        $a = Matrix::fromArray([
+            [22.0, -17.0, 12.0],
+            [4.0, 11.0, -2.0],
+            [20.0, -6.0, -9.0],
+        ]);
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $a->round(-1);
+    }
+
     /**
      * @test
      */

From afdd763b1f7179c0ebefedfb4621fd070cc1cda6 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 22:15:44 -0500
Subject: [PATCH 41/51] Consolidate reducers

---
 CHANGELOG.md                                  |   3 +-
 ext/include/reductions.c                      | 573 +++++-------------
 ext/include/reductions.h                      |  18 +-
 ext/tensor/matrix.zep.c                       |  84 ++-
 ext/tensor/vector.zep.c                       | 386 +++++++++---
 optimizers/TensorBufferProductOptimizer.php   |  76 ---
 optimizers/TensorBufferSumOptimizer.php       |  76 ---
 optimizers/TensorMatrixArgmaxOptimizer.php    |  76 ---
 optimizers/TensorMatrixArgminOptimizer.php    |  76 ---
 optimizers/TensorMatrixMaxOptimizer.php       |  76 ---
 optimizers/TensorMatrixMinOptimizer.php       |  76 ---
 optimizers/TensorMatrixProductOptimizer.php   |  76 ---
 optimizers/TensorMatrixSumOptimizer.php       |  76 ---
 ...er.php => TensorReduceArgmaxOptimizer.php} |   8 +-
 optimizers/TensorReduceArgminOptimizer.php    |  76 +++
 ...mizer.php => TensorReduceMaxOptimizer.php} |   8 +-
 ...mizer.php => TensorReduceMinOptimizer.php} |   8 +-
 optimizers/TensorReduceProductOptimizer.php   |  76 +++
 ...mizer.php => TensorReduceSumOptimizer.php} |   8 +-
 tensor/matrix.zep                             |  12 +-
 tensor/vector.zep                             |  44 +-
 21 files changed, 710 insertions(+), 1202 deletions(-)
 delete mode 100644 optimizers/TensorBufferProductOptimizer.php
 delete mode 100644 optimizers/TensorBufferSumOptimizer.php
 delete mode 100644 optimizers/TensorMatrixArgmaxOptimizer.php
 delete mode 100644 optimizers/TensorMatrixArgminOptimizer.php
 delete mode 100644 optimizers/TensorMatrixMaxOptimizer.php
 delete mode 100644 optimizers/TensorMatrixMinOptimizer.php
 delete mode 100644 optimizers/TensorMatrixProductOptimizer.php
 delete mode 100644 optimizers/TensorMatrixSumOptimizer.php
 rename optimizers/{TensorBufferMinOptimizer.php => TensorReduceArgmaxOptimizer.php} (84%)
 create mode 100644 optimizers/TensorReduceArgminOptimizer.php
 rename optimizers/{TensorBufferArgmaxOptimizer.php => TensorReduceMaxOptimizer.php} (84%)
 rename optimizers/{TensorBufferArgminOptimizer.php => TensorReduceMinOptimizer.php} (84%)
 create mode 100644 optimizers/TensorReduceProductOptimizer.php
 rename optimizers/{TensorBufferMaxOptimizer.php => TensorReduceSumOptimizer.php} (84%)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 69e0f62..9641c1b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,8 @@
 # Change Log
 
 - 4.0.0
-    
+    - Consolidated the buffer and matrix reductions into a single shape-agnostic `tensor_reduce_*` family shared by Vector, ColumnVector, and Matrix
+
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
     - Implemented the Moore-Penrose pseudoinverse in the extension via SVD
diff --git a/ext/include/reductions.c b/ext/include/reductions.c
index 3275704..457f48c 100644
--- a/ext/include/reductions.c
+++ b/ext/include/reductions.c
@@ -54,53 +54,72 @@ static int tensor_resolve_underlying_buffer(zval * obj, zval * buf)
 	return 1;
 }
 
-static double tensor_buffer_sum_values(const uint8_t kind, const void * data, const zend_long len)
+/* The tensor_reduce_* operations reduce a flat buffer viewed as `groups`
+ * contiguous chunks of `length` elements, mirroring TensorBuffer::split(). A
+ * single group (groups == 1) reduces the whole buffer to a scalar, which is
+ * exactly the Vector and ColumnVector case, while multiple groups yield the
+ * per-row Matrix case. `mode` selects the reduction applied to each chunk. */
+
+typedef enum {
+	TENSOR_REDUCE_SUM = 0,
+	TENSOR_REDUCE_PRODUCT,
+	TENSOR_REDUCE_MIN,
+	TENSOR_REDUCE_MAX,
+	TENSOR_REDUCE_ARGMIN,
+	TENSOR_REDUCE_ARGMAX
+} tensor_reduce_mode;
+
+/* Reduce a single contiguous run of `len` elements down to a scalar. For the
+ * sum and product modes a zero-length run yields the identity, mirroring the
+ * previous whole-buffer behaviour on empty buffers. The arg- modes write the
+ * index of the extreme into `*index`; the min/max- modes do too, which is
+ * ignored by their callers. */
+static double tensor_group_reduce(const uint8_t kind, const void * data, const zend_long len, const int mode, zend_long * index)
 {
-	double acc = 0.0;
 	zend_long i;
+	zend_long best_index = 0;
 
-	if (kind == ZEPHIR_BUFFER_LONG) {
-		const zend_long * ptr = (const zend_long *) data;
+	if (mode == TENSOR_REDUCE_SUM) {
+		double acc = 0.0;
 
-		for (i = 0; i < len; ++i) {
-			acc += (double) ptr[i];
-		}
-	} else {
-		const double * ptr = (const double *) data;
+		if (kind == ZEPHIR_BUFFER_LONG) {
+			const zend_long * ptr = (const zend_long *) data;
 
-		for (i = 0; i < len; ++i) {
-			acc += ptr[i];
+			for (i = 0; i < len; ++i) {
+				acc += (double) ptr[i];
+			}
+		} else {
+			const double * ptr = (const double *) data;
+
+			for (i = 0; i < len; ++i) {
+				acc += ptr[i];
+			}
 		}
+
+		return acc;
 	}
 
-	return acc;
-}
+	if (mode == TENSOR_REDUCE_PRODUCT) {
+		double acc = 1.0;
 
-static double tensor_buffer_product_values(const uint8_t kind, const void * data, const zend_long len)
-{
-	double acc = 1.0;
-	zend_long i;
+		if (kind == ZEPHIR_BUFFER_LONG) {
+			const zend_long * ptr = (const zend_long *) data;
 
-	if (kind == ZEPHIR_BUFFER_LONG) {
-		const zend_long * ptr = (const zend_long *) data;
+			for (i = 0; i < len; ++i) {
+				acc *= (double) ptr[i];
+			}
+		} else {
+			const double * ptr = (const double *) data;
 
-		for (i = 0; i < len; ++i) {
-			acc *= (double) ptr[i];
+			for (i = 0; i < len; ++i) {
+				acc *= ptr[i];
+			}
 		}
-	} else {
-		const double * ptr = (const double *) data;
 
-		for (i = 0; i < len; ++i) {
-			acc *= ptr[i];
-		}
+		return acc;
 	}
 
-	return acc;
-}
-
-static void tensor_buffer_extreme(const uint8_t kind, const void * data, const zend_long len, const int find_min, double * value, zend_long * index)
-{
-	zend_long i;
+	int find_min = mode == TENSOR_REDUCE_MIN || mode == TENSOR_REDUCE_ARGMIN;
 
 	if (kind == ZEPHIR_BUFFER_LONG) {
 		const zend_long * ptr = (const zend_long *) data;
@@ -109,13 +128,15 @@ static void tensor_buffer_extreme(const uint8_t kind, const void * data, const z
 		for (i = 1; i < len; ++i) {
 			if (find_min ? ptr[i] < best : ptr[i] > best) {
 				best = ptr[i];
-				*index = i;
+				best_index = i;
 			}
 		}
 
-		if (value != NULL) {
-			*value = (double) best;
+		if (index != NULL) {
+			*index = best_index;
 		}
+
+		return (double) best;
 	} else {
 		const double * ptr = (const double *) data;
 		double best = ptr[0];
@@ -123,71 +144,33 @@ static void tensor_buffer_extreme(const uint8_t kind, const void * data, const z
 		for (i = 1; i < len; ++i) {
 			if (find_min ? ptr[i] < best : ptr[i] > best) {
 				best = ptr[i];
-				*index = i;
+				best_index = i;
 			}
 		}
 
-		if (value != NULL) {
-			*value = best;
+		if (index != NULL) {
+			*index = best_index;
 		}
-	}
-}
 
-/**
- * Return the sum of the elements of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_sum(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
+		return best;
 	}
-
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	if (len == 0) {
-		RETVAL_DOUBLE(0.0);
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	RETVAL_DOUBLE(tensor_buffer_sum_values(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len));
-	zval_ptr_dtor(&buffer);
 }
 
-/**
- * Return the product of the elements of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_product(zval * return_value, zval * obj)
+/* Shared implementation backing all tensor_reduce_* operations. Unwraps the
+ * underlying buffer and validates it against a `groups` x `length` logical
+ * shape before writing one reduced value per group into a new TensorBuffer. */
+static void tensor_reduce_apply(zval * return_value, zval * obj, zval * groups_zval, zval * length_zval, int mode)
 {
 	zval buffer;
 	uint8_t kind;
-	zend_long len;
+	zend_long total = 0, groupsHat = 0, lengthHat = 0, i;
 
 	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
 		return;
 	}
 
 	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
+	total = zephir_buffer_len(&buffer);
 
 	if (UNEXPECTED(kind == 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
@@ -196,187 +179,82 @@ void tensor_buffer_product(zval * return_value, zval * obj)
 		return;
 	}
 
-	if (len == 0) {
-		RETVAL_DOUBLE(1.0);
-		zval_ptr_dtor(&buffer);
-		return;
-	}
-
-	RETVAL_DOUBLE(tensor_buffer_product_values(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len));
-	zval_ptr_dtor(&buffer);
-}
-
-/**
- * Return the minimum element of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_min(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-	double value = 0.0;
-	zend_long index = 0;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
+	groupsHat = zephir_get_intval(groups_zval);
+	lengthHat = zephir_get_intval(length_zval);
 
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
+	if (UNEXPECTED(groupsHat < 1)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
+			SL("Number of groups must be greater than 0."));
 		zval_ptr_dtor(&buffer);
 		return;
 	}
 
-	if (UNEXPECTED(len == 0)) {
+	if (UNEXPECTED(lengthHat < 0)) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Cannot compute the minimum of an empty buffer."));
+			SL("Group length must be non-negative."));
 		zval_ptr_dtor(&buffer);
 		return;
 	}
 
-	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 1, &value, &index);
-
-	zval_ptr_dtor(&buffer);
-
-	RETVAL_DOUBLE(value);
-}
-
-/**
- * Return the maximum element of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_max(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-	double value = 0.0;
-	zend_long index = 0;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
-
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
+	if (lengthHat > 0) {
+		if (UNEXPECTED(total % lengthHat != 0 || groupsHat != total / lengthHat)) {
+			zephir_throw_exception_string(spl_ce_LengthException,
+				SL("Matrix and row dimensions must agree."));
+			zval_ptr_dtor(&buffer);
+			return;
+		}
+	} else if (UNEXPECTED(total != 0)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Group length must not be zero for a non-empty buffer."));
 		zval_ptr_dtor(&buffer);
 		return;
 	}
 
-	if (UNEXPECTED(len == 0)) {
+	/* Extrema need at least one element in every group. */
+	if (UNEXPECTED(lengthHat == 0 && (mode == TENSOR_REDUCE_MIN || mode == TENSOR_REDUCE_MAX
+		|| mode == TENSOR_REDUCE_ARGMIN || mode == TENSOR_REDUCE_ARGMAX))) {
 		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Cannot compute the maximum of an empty buffer."));
+			SL("Cannot compute the reduction of an empty group."));
 		zval_ptr_dtor(&buffer);
 		return;
 	}
 
-	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 0, &value, &index);
-
-	zval_ptr_dtor(&buffer);
-
-	RETVAL_DOUBLE(value);
-}
-
-/**
- * Return the index of the minimum element of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_argmin(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-	zend_long index = 0;
-
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
-
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
-
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
+	zval c;
 
-	if (UNEXPECTED(len == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Cannot compute the argmin of an empty buffer."));
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, groupsHat, &c) == FAILURE)) {
 		zval_ptr_dtor(&buffer);
 		return;
 	}
 
-	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 1, NULL, &index);
-
-	zval_ptr_dtor(&buffer);
-
-	RETVAL_LONG(index);
-}
+	double * vc = zephir_buffer_doubles(&c);
 
-/**
- * Return the index of the maximum element of a Buffer.
- *
- * @param return_value
- * @param obj
- */
-void tensor_buffer_argmax(zval * return_value, zval * obj)
-{
-	zval buffer;
-	uint8_t kind;
-	zend_long len;
-	zend_long index = 0;
+	if (kind == ZEPHIR_BUFFER_LONG) {
+		const zend_long * ptr = zephir_buffer_longs(&buffer);
 
-	if (!tensor_resolve_underlying_buffer(obj, &buffer)) {
-		return;
-	}
+		for (i = 0; i < groupsHat; ++i) {
+			zend_long index = 0;
+			double value = tensor_group_reduce(kind, ptr + i * lengthHat, lengthHat, mode, &index);
 
-	kind = zephir_buffer_kind(&buffer);
-	len = zephir_buffer_len(&buffer);
+			vc[i] = (mode == TENSOR_REDUCE_ARGMIN || mode == TENSOR_REDUCE_ARGMAX)
+				? (double) index : value;
+		}
+	} else {
+		const double * ptr = zephir_buffer_doubles(&buffer);
 
-	if (UNEXPECTED(kind == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Argument must be a Buffer object."));
-		zval_ptr_dtor(&buffer);
-		return;
-	}
+		for (i = 0; i < groupsHat; ++i) {
+			zend_long index = 0;
+			double value = tensor_group_reduce(kind, ptr + i * lengthHat, lengthHat, mode, &index);
 
-	if (UNEXPECTED(len == 0)) {
-		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
-			SL("Cannot compute the argmax of an empty buffer."));
-		zval_ptr_dtor(&buffer);
-		return;
+			vc[i] = (mode == TENSOR_REDUCE_ARGMIN || mode == TENSOR_REDUCE_ARGMAX)
+				? (double) index : value;
+		}
 	}
 
-	tensor_buffer_extreme(kind, kind == ZEPHIR_BUFFER_LONG
-		? (const void *) zephir_buffer_longs(&buffer) : (const void *) zephir_buffer_doubles(&buffer), len, 0, NULL, &index);
-
 	zval_ptr_dtor(&buffer);
-
-	RETVAL_LONG(index);
+	zval_ptr_dtor(&c);
 }
 
+
 /**
  * Row-wise operations work directly on the flat row-major buffer that backs a
  * Matrix (m * n doubles) instead of materializing per-row Buffers. This
@@ -427,250 +305,89 @@ static int tensor_matrix_double_cmp(const void * a, const void * b)
 }
 
 /**
- * Return the sum of each row of a matrix as a column buffer.
+ * Return the sum of each group of the buffer as a TensorBuffer. A single
+ * group covers the whole-buffer (Vector / ColumnVector) case.
  *
  * @param return_value
  * @param obj
- * @param n
+ * @param groups
+ * @param length
  */
-void tensor_matrix_sum(zval * return_value, zval * obj, zval * n)
+void tensor_reduce_sum(zval * return_value, zval * obj, zval * groups, zval * length)
 {
-	double * va = NULL;
-	zend_long m = 0, n_hat = 0;
-	zend_long i, j;
-
-	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
-		return;
-	}
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	for (i = 0; i < m; ++i) {
-		const double * row = va + i * n_hat;
-		double acc = 0.0;
-
-		for (j = 0; j < n_hat; ++j) {
-			acc += row[j];
-		}
-
-		vc[i] = acc;
-	}
-
-	zval_ptr_dtor(&c);
+	tensor_reduce_apply(return_value, obj, groups, length, TENSOR_REDUCE_SUM);
 }
 
 /**
- * Return the product of the elements of each row of a matrix as a column
- * buffer.
+ * Return the product of each group of the buffer as a TensorBuffer. A single
+ * group covers the whole-buffer (Vector / ColumnVector) case.
  *
  * @param return_value
  * @param obj
- * @param n
+ * @param groups
+ * @param length
  */
-void tensor_matrix_product(zval * return_value, zval * obj, zval * n)
+void tensor_reduce_product(zval * return_value, zval * obj, zval * groups, zval * length)
 {
-	double * va = NULL;
-	zend_long m = 0, n_hat = 0;
-	zend_long i, j;
-
-	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
-		return;
-	}
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	for (i = 0; i < m; ++i) {
-		const double * row = va + i * n_hat;
-		double acc = 1.0;
-
-		for (j = 0; j < n_hat; ++j) {
-			acc *= row[j];
-		}
-
-		vc[i] = acc;
-	}
-
-	zval_ptr_dtor(&c);
+	tensor_reduce_apply(return_value, obj, groups, length, TENSOR_REDUCE_PRODUCT);
 }
 
 /**
- * Return the minimum of each row of a matrix as a column buffer.
+ * Return the minimum of each group of the buffer as a TensorBuffer. A single
+ * group covers the whole-buffer (Vector / ColumnVector) case.
  *
  * @param return_value
  * @param obj
- * @param n
+ * @param groups
+ * @param length
  */
-void tensor_matrix_min(zval * return_value, zval * obj, zval * n)
+void tensor_reduce_min(zval * return_value, zval * obj, zval * groups, zval * length)
 {
-	double * va = NULL;
-	zend_long m = 0, n_hat = 0;
-	zend_long i, j;
-
-	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
-		return;
-	}
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	for (i = 0; i < m; ++i) {
-		const double * row = va + i * n_hat;
-		double best = row[0];
-
-		for (j = 1; j < n_hat; ++j) {
-			if (row[j] < best) {
-				best = row[j];
-			}
-		}
-
-		vc[i] = best;
-	}
-
-	zval_ptr_dtor(&c);
+	tensor_reduce_apply(return_value, obj, groups, length, TENSOR_REDUCE_MIN);
 }
 
 /**
- * Return the maximum of each row of a matrix as a column buffer.
+ * Return the maximum of each group of the buffer as a TensorBuffer. A single
+ * group covers the whole-buffer (Vector / ColumnVector) case.
  *
  * @param return_value
  * @param obj
- * @param n
+ * @param groups
+ * @param length
  */
-void tensor_matrix_max(zval * return_value, zval * obj, zval * n)
+void tensor_reduce_max(zval * return_value, zval * obj, zval * groups, zval * length)
 {
-	double * va = NULL;
-	zend_long m = 0, n_hat = 0;
-	zend_long i, j;
-
-	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
-		return;
-	}
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	for (i = 0; i < m; ++i) {
-		const double * row = va + i * n_hat;
-		double best = row[0];
-
-		for (j = 1; j < n_hat; ++j) {
-			if (row[j] > best) {
-				best = row[j];
-			}
-		}
-
-		vc[i] = best;
-	}
-
-	zval_ptr_dtor(&c);
+	tensor_reduce_apply(return_value, obj, groups, length, TENSOR_REDUCE_MAX);
 }
 
 /**
- * Return the index of the minimum of each row of a matrix as a column buffer.
+ * Return the index of the minimum of each group of the buffer as a
+ * TensorBuffer. A single group covers the whole-buffer (Vector /
+ * ColumnVector) case.
  *
  * @param return_value
  * @param obj
- * @param n
+ * @param groups
+ * @param length
  */
-void tensor_matrix_argmin(zval * return_value, zval * obj, zval * n)
+void tensor_reduce_argmin(zval * return_value, zval * obj, zval * groups, zval * length)
 {
-	double * va = NULL;
-	zend_long m = 0, n_hat = 0;
-	zend_long i, j;
-
-	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
-		return;
-	}
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	for (i = 0; i < m; ++i) {
-		const double * row = va + i * n_hat;
-		double best = row[0];
-		zend_long index = 0;
-
-		for (j = 1; j < n_hat; ++j) {
-			if (row[j] < best) {
-				best = row[j];
-				index = j;
-			}
-		}
-
-		vc[i] = (double) index;
-	}
-
-	zval_ptr_dtor(&c);
+	tensor_reduce_apply(return_value, obj, groups, length, TENSOR_REDUCE_ARGMIN);
 }
 
 /**
- * Return the index of the maximum of each row of a matrix as a column buffer.
+ * Return the index of the maximum of each group of the buffer as a
+ * TensorBuffer. A single group covers the whole-buffer (Vector /
+ * ColumnVector) case.
  *
  * @param return_value
  * @param obj
- * @param n
+ * @param groups
+ * @param length
  */
-void tensor_matrix_argmax(zval * return_value, zval * obj, zval * n)
+void tensor_reduce_argmax(zval * return_value, zval * obj, zval * groups, zval * length)
 {
-	double * va = NULL;
-	zend_long m = 0, n_hat = 0;
-	zend_long i, j;
-
-	if (UNEXPECTED(!tensor_matrix_doubles(obj, n, &va, &m, &n_hat))) {
-		return;
-	}
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, m, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	for (i = 0; i < m; ++i) {
-		const double * row = va + i * n_hat;
-		double best = row[0];
-		zend_long index = 0;
-
-		for (j = 1; j < n_hat; ++j) {
-			if (row[j] > best) {
-				best = row[j];
-				index = j;
-			}
-		}
-
-		vc[i] = (double) index;
-	}
-
-	zval_ptr_dtor(&c);
+	tensor_reduce_apply(return_value, obj, groups, length, TENSOR_REDUCE_ARGMAX);
 }
 
 /**
diff --git a/ext/include/reductions.h b/ext/include/reductions.h
index b0ec39c..20a15fb 100644
--- a/ext/include/reductions.h
+++ b/ext/include/reductions.h
@@ -3,19 +3,13 @@
 
 #include <Zend/zend.h>
 
-void tensor_buffer_sum(zval * return_value, zval * obj);
-void tensor_buffer_product(zval * return_value, zval * obj);
-void tensor_buffer_min(zval * return_value, zval * obj);
-void tensor_buffer_max(zval * return_value, zval * obj);
-void tensor_buffer_argmin(zval * return_value, zval * obj);
-void tensor_buffer_argmax(zval * return_value, zval * obj);
+void tensor_reduce_sum(zval * return_value, zval * obj, zval * groups, zval * length);
+void tensor_reduce_product(zval * return_value, zval * obj, zval * groups, zval * length);
+void tensor_reduce_min(zval * return_value, zval * obj, zval * groups, zval * length);
+void tensor_reduce_max(zval * return_value, zval * obj, zval * groups, zval * length);
+void tensor_reduce_argmin(zval * return_value, zval * obj, zval * groups, zval * length);
+void tensor_reduce_argmax(zval * return_value, zval * obj, zval * groups, zval * length);
 
-void tensor_matrix_sum(zval * return_value, zval * obj, zval * n);
-void tensor_matrix_product(zval * return_value, zval * obj, zval * n);
-void tensor_matrix_min(zval * return_value, zval * obj, zval * n);
-void tensor_matrix_max(zval * return_value, zval * obj, zval * n);
-void tensor_matrix_argmin(zval * return_value, zval * obj, zval * n);
-void tensor_matrix_argmax(zval * return_value, zval * obj, zval * n);
 void tensor_matrix_median(zval * return_value, zval * obj, zval * n);
 void tensor_matrix_quantile(zval * return_value, zval * obj, zval * n, zval * q);
 void tensor_matrix_repeat(zval * return_value, zval * obj, zval * n, zval * times_m, zval * times_n);
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 19bbd3e..7b3cd5d 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -4390,7 +4390,7 @@ PHP_METHOD(Tensor_Matrix, deg2rad)
  */
 PHP_METHOD(Tensor_Matrix, sum)
 {
-	zval _0, _1, _2;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4398,13 +4398,18 @@ PHP_METHOD(Tensor_Matrix, sum)
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4412,8 +4417,9 @@ PHP_METHOD(Tensor_Matrix, sum)
 	object_init_ex(return_value, tensor_columnvector_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	tensor_matrix_sum(&_0, &_1, &_2);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_reduce_sum(&_0, &_1, &_2, &_3);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -4426,7 +4432,7 @@ PHP_METHOD(Tensor_Matrix, sum)
  */
 PHP_METHOD(Tensor_Matrix, product)
 {
-	zval _0, _1, _2;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4434,13 +4440,18 @@ PHP_METHOD(Tensor_Matrix, product)
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4448,8 +4459,9 @@ PHP_METHOD(Tensor_Matrix, product)
 	object_init_ex(return_value, tensor_columnvector_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	tensor_matrix_product(&_0, &_1, &_2);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_reduce_product(&_0, &_1, &_2, &_3);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -4462,7 +4474,7 @@ PHP_METHOD(Tensor_Matrix, product)
  */
 PHP_METHOD(Tensor_Matrix, min)
 {
-	zval _0, _1, _2;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4470,13 +4482,18 @@ PHP_METHOD(Tensor_Matrix, min)
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4484,8 +4501,9 @@ PHP_METHOD(Tensor_Matrix, min)
 	object_init_ex(return_value, tensor_columnvector_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	tensor_matrix_min(&_0, &_1, &_2);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_reduce_min(&_0, &_1, &_2, &_3);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -4498,7 +4516,7 @@ PHP_METHOD(Tensor_Matrix, min)
  */
 PHP_METHOD(Tensor_Matrix, max)
 {
-	zval _0, _1, _2;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4506,13 +4524,18 @@ PHP_METHOD(Tensor_Matrix, max)
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4520,8 +4543,9 @@ PHP_METHOD(Tensor_Matrix, max)
 	object_init_ex(return_value, tensor_columnvector_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	tensor_matrix_max(&_0, &_1, &_2);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_reduce_max(&_0, &_1, &_2, &_3);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -4534,7 +4558,7 @@ PHP_METHOD(Tensor_Matrix, max)
  */
 PHP_METHOD(Tensor_Matrix, argmin)
 {
-	zval _0, _1, _2;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4542,13 +4566,18 @@ PHP_METHOD(Tensor_Matrix, argmin)
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4556,8 +4585,9 @@ PHP_METHOD(Tensor_Matrix, argmin)
 	object_init_ex(return_value, tensor_columnvector_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	tensor_matrix_argmin(&_0, &_1, &_2);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_reduce_argmin(&_0, &_1, &_2, &_3);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -4570,7 +4600,7 @@ PHP_METHOD(Tensor_Matrix, argmin)
  */
 PHP_METHOD(Tensor_Matrix, argmax)
 {
-	zval _0, _1, _2;
+	zval _0, _1, _2, _3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
@@ -4578,13 +4608,18 @@ PHP_METHOD(Tensor_Matrix, argmax)
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
 	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("m", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("n", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
@@ -4592,8 +4627,9 @@ PHP_METHOD(Tensor_Matrix, argmax)
 	object_init_ex(return_value, tensor_columnvector_ce);
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	tensor_matrix_argmax(&_0, &_1, &_2);
+	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_reduce_argmax(&_0, &_1, &_2, &_3);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 51ecd2a..3cd5216 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -2936,17 +2936,37 @@ PHP_METHOD(Tensor_Vector, deg2rad)
  */
 PHP_METHOD(Tensor_Vector, sum)
 {
-	zval _0;
+	zval result, _0, _1, _2, _3, _4;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_sum(return_value, &_0);
-	return;
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_2, 1);
+	tensor_reduce_sum(&result, &_0, &_2, &_1);
+	ZVAL_LONG(&_4, 0);
+	ZEPHIR_CALL_METHOD(&_3, &result, "get", NULL, 0, &_4);
+	zephir_check_call_status();
+	RETURN_MM_DOUBLE(zephir_get_doubleval(&_3));
 }
 
 /**
@@ -2956,17 +2976,37 @@ PHP_METHOD(Tensor_Vector, sum)
  */
 PHP_METHOD(Tensor_Vector, product)
 {
-	zval _0;
+	zval result, _0, _1, _2, _3, _4;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&_1);
+	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("a", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("n", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	ZEPHIR_INIT_VAR(&result);
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_product(return_value, &_0);
-	return;
+	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_2, 1);
+	tensor_reduce_product(&result, &_0, &_2, &_1);
+	ZVAL_LONG(&_4, 0);
+	ZEPHIR_CALL_METHOD(&_3, &result, "get", NULL, 0, &_4);
+	zephir_check_call_status();
+	RETURN_MM_DOUBLE(zephir_get_doubleval(&_3));
 }
 
 /**
@@ -2976,17 +3016,53 @@ PHP_METHOD(Tensor_Vector, product)
  */
 PHP_METHOD(Tensor_Vector, min)
 {
-	zval _0;
+	zval _2$$3;
+	zval _0, result, _3, _4, _5, _6, _7, _1$$3;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&result);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_min(return_value, &_0);
-	return;
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_2$$3);
+		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the minimum of an empty vector.");
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1153);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_5, 1);
+	tensor_reduce_min(&result, &_3, &_5, &_4);
+	ZVAL_LONG(&_7, 0);
+	ZEPHIR_CALL_METHOD(&_6, &result, "get", NULL, 0, &_7);
+	zephir_check_call_status();
+	RETURN_MM_DOUBLE(zephir_get_doubleval(&_6));
 }
 
 /**
@@ -2996,17 +3072,53 @@ PHP_METHOD(Tensor_Vector, min)
  */
 PHP_METHOD(Tensor_Vector, max)
 {
-	zval _0;
+	zval _2$$3;
+	zval _0, result, _3, _4, _5, _6, _7, _1$$3;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&result);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_max(return_value, &_0);
-	return;
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_2$$3);
+		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the maximum of an empty vector.");
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1170);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_5, 1);
+	tensor_reduce_max(&result, &_3, &_5, &_4);
+	ZVAL_LONG(&_7, 0);
+	ZEPHIR_CALL_METHOD(&_6, &result, "get", NULL, 0, &_7);
+	zephir_check_call_status();
+	RETURN_MM_DOUBLE(zephir_get_doubleval(&_6));
 }
 
 /**
@@ -3016,17 +3128,53 @@ PHP_METHOD(Tensor_Vector, max)
  */
 PHP_METHOD(Tensor_Vector, argmin)
 {
-	zval _0;
+	zval _2$$3;
+	zval _0, result, _3, _4, _5, _6, _7, _1$$3;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&result);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_argmin(return_value, &_0);
-	return;
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_2$$3);
+		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the argmin of an empty vector.");
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1187);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_5, 1);
+	tensor_reduce_argmin(&result, &_3, &_5, &_4);
+	ZVAL_LONG(&_7, 0);
+	ZEPHIR_CALL_METHOD(&_6, &result, "get", NULL, 0, &_7);
+	zephir_check_call_status();
+	RETURN_MM_LONG(zephir_get_intval(&_6));
 }
 
 /**
@@ -3036,17 +3184,53 @@ PHP_METHOD(Tensor_Vector, argmin)
  */
 PHP_METHOD(Tensor_Vector, argmax)
 {
-	zval _0;
+	zval _2$$3;
+	zval _0, result, _3, _4, _5, _6, _7, _1$$3;
+	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&result);
+	ZVAL_UNDEF(&_3);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	tensor_buffer_argmax(return_value, &_0);
-	return;
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
+	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
+
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_2$$3);
+		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the argmax of an empty vector.");
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1204);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	ZVAL_LONG(&_5, 1);
+	tensor_reduce_argmax(&result, &_3, &_5, &_4);
+	ZVAL_LONG(&_7, 0);
+	ZEPHIR_CALL_METHOD(&_6, &result, "get", NULL, 0, &_7);
+	zephir_check_call_status();
+	RETURN_MM_LONG(zephir_get_intval(&_6));
 }
 
 /**
@@ -3124,12 +3308,12 @@ PHP_METHOD(Tensor_Vector, median)
 	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
 	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
 		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1206);
+		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1238);
 	} else {
 		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1208);
+		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1240);
 		zephir_memory_observe(&_5$$4);
-		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1208);
+		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1240);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
 		ZEPHIR_INIT_NVAR(&median);
@@ -3196,7 +3380,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1225);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1257);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3214,15 +3398,15 @@ PHP_METHOD(Tensor_Vector, quantile)
 	if (ZEPHIR_LE_LONG(&_7, xHat)) {
 		zephir_memory_observe(&_8$$4);
 		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1237);
+		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1269);
 		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
 	}
 	remainder =  ((x -  (double) xHat));
 	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1242);
+	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1274);
 	t =  (zephir_get_doubleval(&_10));
 	zephir_memory_observe(&_11);
-	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1244);
+	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1276);
 	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
 }
 
@@ -3281,7 +3465,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 2, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1259);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1291);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3347,7 +3531,7 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1283);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1315);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3466,7 +3650,7 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1322);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1354);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3688,7 +3872,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1382);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1414);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3703,7 +3887,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1393);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1425);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3712,7 +3896,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1390);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1422);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3735,7 +3919,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1390);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1422);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3820,7 +4004,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1408);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1440);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3835,7 +4019,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1419);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1451);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3844,7 +4028,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1416);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1448);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3867,7 +4051,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1416);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1448);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -3952,7 +4136,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1434);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1466);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3967,7 +4151,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1445);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1477);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -3976,7 +4160,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1442);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1474);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -3999,7 +4183,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1442);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1474);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4084,7 +4268,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1460);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1492);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4099,7 +4283,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1471);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1503);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4108,7 +4292,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1468);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1500);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4131,7 +4315,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1468);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1500);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4216,7 +4400,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1486);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1518);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4231,7 +4415,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1497);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1529);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4240,7 +4424,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1494);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1526);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4263,7 +4447,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1494);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1526);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4348,7 +4532,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1512);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1544);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4363,7 +4547,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1523);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1555);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4372,7 +4556,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1520);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1552);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4395,7 +4579,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1520);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1552);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4480,7 +4664,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1538);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1570);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4495,7 +4679,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1549);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1581);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4504,7 +4688,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1546);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1578);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4527,7 +4711,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1546);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1578);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4612,7 +4796,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1564);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1596);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4627,7 +4811,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1575);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1607);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4636,7 +4820,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1572);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1604);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4659,7 +4843,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1572);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1604);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4744,7 +4928,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1590);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1622);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4759,7 +4943,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1601);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1633);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4768,7 +4952,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1598);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1630);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4791,7 +4975,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1598);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1630);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -4876,7 +5060,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1616);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1648);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4891,7 +5075,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1627);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1659);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -4900,7 +5084,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1624);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1656);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -4923,7 +5107,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1624);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1656);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5008,7 +5192,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1642);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1674);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5023,7 +5207,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1653);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1685);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5032,7 +5216,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1650);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1682);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5055,7 +5239,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1650);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1682);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5140,7 +5324,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1668);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1700);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5155,7 +5339,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	} else {
 		_9 = &_8;
 	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1679);
+	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1711);
 	if (Z_TYPE_P(_9) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
 		{
@@ -5164,7 +5348,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 			ZEPHIR_INIT_NVAR(&_12$$4);
 			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1676);
+			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1708);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
@@ -5187,7 +5371,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 				ZEPHIR_INIT_NVAR(&_16$$5);
 				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
 				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1676);
+				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1708);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowB);
@@ -5261,7 +5445,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1694);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1726);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5333,7 +5517,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1712);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1744);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5405,7 +5589,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1730);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1762);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5477,7 +5661,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1748);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1780);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5549,7 +5733,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1766);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1798);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5621,7 +5805,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1784);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1816);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5694,7 +5878,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1803);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1835);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5766,7 +5950,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1821);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1853);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5838,7 +6022,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1839);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1871);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5910,7 +6094,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1857);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1889);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5982,7 +6166,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1875);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1907);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6054,7 +6238,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1893);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1925);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6565,7 +6749,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2050);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2082);
 	return;
 }
 
@@ -6616,7 +6800,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2074);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2106);
 	return;
 }
 
@@ -6674,7 +6858,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2088);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2120);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6782,13 +6966,13 @@ PHP_METHOD(Tensor_Vector, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2129);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2161);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, &_1);
-	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2132);
+	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2164);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_2);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/optimizers/TensorBufferProductOptimizer.php b/optimizers/TensorBufferProductOptimizer.php
deleted file mode 100644
index 8d8f8f7..0000000
--- a/optimizers/TensorBufferProductOptimizer.php
+++ /dev/null
@@ -1,76 +0,0 @@
-<?php
-
-namespace Zephir\Optimizers\FunctionCall;
-
-use Zephir\Call;
-use Zephir\CompilationContext;
-use Zephir\CompiledExpression;
-use Zephir\HeadersManager;
-use Zephir\Exception\CompilerException;
-use Zephir\Optimizers\OptimizerAbstract;
-
-class TensorBufferProductOptimizer extends OptimizerAbstract
-{
-    /**
-     * @param mixed[] $expression
-     * @param Call $call
-     * @param CompilationContext $context
-     * @throws CompilerException
-     * @return CompiledExpression|bool
-     */
-    public function optimize(array $expression, Call $call, CompilationContext $context)
-    {
-        if (!isset($expression['parameters'])) {
-            return false;
-        }
-
-        if (count($expression['parameters']) !== 1) {
-            throw new CompilerException(
-                'Tensor buffer product accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
-                $expression
-            );
-        }
-
-        $call->processExpectedReturn($context);
-
-        $symbolVariable = $call->getSymbolVariable();
-
-        if (empty($symbolVariable)) {
-            throw new CompilerException('Missing symbol variable.');
-        }
-
-        if ($symbolVariable->getType() !== 'variable') {
-            throw new CompilerException(
-                'Return value must only be assigned to a dynamic variable.',
-                $expression
-            );
-        }
-
-        if ($call->mustInitSymbolVariable()) {
-            $symbolVariable->initVariant($context);
-        }
-
-        $context->headersManager->add(
-            'include/reductions',
-            HeadersManager::POSITION_LAST
-        );
-
-        $resolvedParams = $call->getResolvedParams(
-            $expression['parameters'],
-            $context,
-            $expression
-        );
-
-        $symbol = $context->backend->getVariableCode($symbolVariable);
-
-        $context->codePrinter->output(
-            "tensor_buffer_product($symbol, {$resolvedParams[0]});"
-        );
-
-        return new CompiledExpression(
-            'variable',
-            $symbolVariable->getRealName(),
-            $expression
-        );
-    }
-}
diff --git a/optimizers/TensorBufferSumOptimizer.php b/optimizers/TensorBufferSumOptimizer.php
deleted file mode 100644
index b6335c6..0000000
--- a/optimizers/TensorBufferSumOptimizer.php
+++ /dev/null
@@ -1,76 +0,0 @@
-<?php
-
-namespace Zephir\Optimizers\FunctionCall;
-
-use Zephir\Call;
-use Zephir\CompilationContext;
-use Zephir\CompiledExpression;
-use Zephir\HeadersManager;
-use Zephir\Exception\CompilerException;
-use Zephir\Optimizers\OptimizerAbstract;
-
-class TensorBufferSumOptimizer extends OptimizerAbstract
-{
-    /**
-     * @param mixed[] $expression
-     * @param Call $call
-     * @param CompilationContext $context
-     * @throws CompilerException
-     * @return CompiledExpression|bool
-     */
-    public function optimize(array $expression, Call $call, CompilationContext $context)
-    {
-        if (!isset($expression['parameters'])) {
-            return false;
-        }
-
-        if (count($expression['parameters']) !== 1) {
-            throw new CompilerException(
-                'Tensor buffer sum accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
-                $expression
-            );
-        }
-
-        $call->processExpectedReturn($context);
-
-        $symbolVariable = $call->getSymbolVariable();
-
-        if (empty($symbolVariable)) {
-            throw new CompilerException('Missing symbol variable.');
-        }
-
-        if ($symbolVariable->getType() !== 'variable') {
-            throw new CompilerException(
-                'Return value must only be assigned to a dynamic variable.',
-                $expression
-            );
-        }
-
-        if ($call->mustInitSymbolVariable()) {
-            $symbolVariable->initVariant($context);
-        }
-
-        $context->headersManager->add(
-            'include/reductions',
-            HeadersManager::POSITION_LAST
-        );
-
-        $resolvedParams = $call->getResolvedParams(
-            $expression['parameters'],
-            $context,
-            $expression
-        );
-
-        $symbol = $context->backend->getVariableCode($symbolVariable);
-
-        $context->codePrinter->output(
-            "tensor_buffer_sum($symbol, {$resolvedParams[0]});"
-        );
-
-        return new CompiledExpression(
-            'variable',
-            $symbolVariable->getRealName(),
-            $expression
-        );
-    }
-}
diff --git a/optimizers/TensorMatrixArgmaxOptimizer.php b/optimizers/TensorMatrixArgmaxOptimizer.php
deleted file mode 100644
index 1a514db..0000000
--- a/optimizers/TensorMatrixArgmaxOptimizer.php
+++ /dev/null
@@ -1,76 +0,0 @@
-<?php
-
-namespace Zephir\Optimizers\FunctionCall;
-
-use Zephir\Call;
-use Zephir\CompilationContext;
-use Zephir\CompiledExpression;
-use Zephir\HeadersManager;
-use Zephir\Exception\CompilerException;
-use Zephir\Optimizers\OptimizerAbstract;
-
-class TensorMatrixArgmaxOptimizer extends OptimizerAbstract
-{
-    /**
-     * @param mixed[] $expression
-     * @param Call $call
-     * @param CompilationContext $context
-     * @throws CompilerException
-     * @return CompiledExpression|bool
-     */
-    public function optimize(array $expression, Call $call, CompilationContext $context)
-    {
-        if (!isset($expression['parameters'])) {
-            return false;
-        }
-
-        if (count($expression['parameters']) !== 2) {
-            throw new CompilerException(
-                'Tensor matrix argmax accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
-                $expression
-            );
-        }
-
-        $call->processExpectedReturn($context);
-
-        $symbolVariable = $call->getSymbolVariable();
-
-        if (empty($symbolVariable)) {
-            throw new CompilerException('Missing symbol variable.');
-        }
-
-        if ($symbolVariable->getType() !== 'variable') {
-            throw new CompilerException(
-                'Return value must only be assigned to a dynamic variable.',
-                $expression
-            );
-        }
-
-        if ($call->mustInitSymbolVariable()) {
-            $symbolVariable->initVariant($context);
-        }
-
-        $context->headersManager->add(
-            'include/reductions',
-            HeadersManager::POSITION_LAST
-        );
-
-        $resolvedParams = $call->getResolvedParams(
-            $expression['parameters'],
-            $context,
-            $expression
-        );
-
-        $symbol = $context->backend->getVariableCode($symbolVariable);
-
-        $context->codePrinter->output(
-            "tensor_matrix_argmax($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
-        );
-
-        return new CompiledExpression(
-            'variable',
-            $symbolVariable->getRealName(),
-            $expression
-        );
-    }
-}
diff --git a/optimizers/TensorMatrixArgminOptimizer.php b/optimizers/TensorMatrixArgminOptimizer.php
deleted file mode 100644
index efd2298..0000000
--- a/optimizers/TensorMatrixArgminOptimizer.php
+++ /dev/null
@@ -1,76 +0,0 @@
-<?php
-
-namespace Zephir\Optimizers\FunctionCall;
-
-use Zephir\Call;
-use Zephir\CompilationContext;
-use Zephir\CompiledExpression;
-use Zephir\HeadersManager;
-use Zephir\Exception\CompilerException;
-use Zephir\Optimizers\OptimizerAbstract;
-
-class TensorMatrixArgminOptimizer extends OptimizerAbstract
-{
-    /**
-     * @param mixed[] $expression
-     * @param Call $call
-     * @param CompilationContext $context
-     * @throws CompilerException
-     * @return CompiledExpression|bool
-     */
-    public function optimize(array $expression, Call $call, CompilationContext $context)
-    {
-        if (!isset($expression['parameters'])) {
-            return false;
-        }
-
-        if (count($expression['parameters']) !== 2) {
-            throw new CompilerException(
-                'Tensor matrix argmin accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
-                $expression
-            );
-        }
-
-        $call->processExpectedReturn($context);
-
-        $symbolVariable = $call->getSymbolVariable();
-
-        if (empty($symbolVariable)) {
-            throw new CompilerException('Missing symbol variable.');
-        }
-
-        if ($symbolVariable->getType() !== 'variable') {
-            throw new CompilerException(
-                'Return value must only be assigned to a dynamic variable.',
-                $expression
-            );
-        }
-
-        if ($call->mustInitSymbolVariable()) {
-            $symbolVariable->initVariant($context);
-        }
-
-        $context->headersManager->add(
-            'include/reductions',
-            HeadersManager::POSITION_LAST
-        );
-
-        $resolvedParams = $call->getResolvedParams(
-            $expression['parameters'],
-            $context,
-            $expression
-        );
-
-        $symbol = $context->backend->getVariableCode($symbolVariable);
-
-        $context->codePrinter->output(
-            "tensor_matrix_argmin($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
-        );
-
-        return new CompiledExpression(
-            'variable',
-            $symbolVariable->getRealName(),
-            $expression
-        );
-    }
-}
diff --git a/optimizers/TensorMatrixMaxOptimizer.php b/optimizers/TensorMatrixMaxOptimizer.php
deleted file mode 100644
index 5940782..0000000
--- a/optimizers/TensorMatrixMaxOptimizer.php
+++ /dev/null
@@ -1,76 +0,0 @@
-<?php
-
-namespace Zephir\Optimizers\FunctionCall;
-
-use Zephir\Call;
-use Zephir\CompilationContext;
-use Zephir\CompiledExpression;
-use Zephir\HeadersManager;
-use Zephir\Exception\CompilerException;
-use Zephir\Optimizers\OptimizerAbstract;
-
-class TensorMatrixMaxOptimizer extends OptimizerAbstract
-{
-    /**
-     * @param mixed[] $expression
-     * @param Call $call
-     * @param CompilationContext $context
-     * @throws CompilerException
-     * @return CompiledExpression|bool
-     */
-    public function optimize(array $expression, Call $call, CompilationContext $context)
-    {
-        if (!isset($expression['parameters'])) {
-            return false;
-        }
-
-        if (count($expression['parameters']) !== 2) {
-            throw new CompilerException(
-                'Tensor matrix max accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
-                $expression
-            );
-        }
-
-        $call->processExpectedReturn($context);
-
-        $symbolVariable = $call->getSymbolVariable();
-
-        if (empty($symbolVariable)) {
-            throw new CompilerException('Missing symbol variable.');
-        }
-
-        if ($symbolVariable->getType() !== 'variable') {
-            throw new CompilerException(
-                'Return value must only be assigned to a dynamic variable.',
-                $expression
-            );
-        }
-
-        if ($call->mustInitSymbolVariable()) {
-            $symbolVariable->initVariant($context);
-        }
-
-        $context->headersManager->add(
-            'include/reductions',
-            HeadersManager::POSITION_LAST
-        );
-
-        $resolvedParams = $call->getResolvedParams(
-            $expression['parameters'],
-            $context,
-            $expression
-        );
-
-        $symbol = $context->backend->getVariableCode($symbolVariable);
-
-        $context->codePrinter->output(
-            "tensor_matrix_max($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
-        );
-
-        return new CompiledExpression(
-            'variable',
-            $symbolVariable->getRealName(),
-            $expression
-        );
-    }
-}
diff --git a/optimizers/TensorMatrixMinOptimizer.php b/optimizers/TensorMatrixMinOptimizer.php
deleted file mode 100644
index 8355caa..0000000
--- a/optimizers/TensorMatrixMinOptimizer.php
+++ /dev/null
@@ -1,76 +0,0 @@
-<?php
-
-namespace Zephir\Optimizers\FunctionCall;
-
-use Zephir\Call;
-use Zephir\CompilationContext;
-use Zephir\CompiledExpression;
-use Zephir\HeadersManager;
-use Zephir\Exception\CompilerException;
-use Zephir\Optimizers\OptimizerAbstract;
-
-class TensorMatrixMinOptimizer extends OptimizerAbstract
-{
-    /**
-     * @param mixed[] $expression
-     * @param Call $call
-     * @param CompilationContext $context
-     * @throws CompilerException
-     * @return CompiledExpression|bool
-     */
-    public function optimize(array $expression, Call $call, CompilationContext $context)
-    {
-        if (!isset($expression['parameters'])) {
-            return false;
-        }
-
-        if (count($expression['parameters']) !== 2) {
-            throw new CompilerException(
-                'Tensor matrix min accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
-                $expression
-            );
-        }
-
-        $call->processExpectedReturn($context);
-
-        $symbolVariable = $call->getSymbolVariable();
-
-        if (empty($symbolVariable)) {
-            throw new CompilerException('Missing symbol variable.');
-        }
-
-        if ($symbolVariable->getType() !== 'variable') {
-            throw new CompilerException(
-                'Return value must only be assigned to a dynamic variable.',
-                $expression
-            );
-        }
-
-        if ($call->mustInitSymbolVariable()) {
-            $symbolVariable->initVariant($context);
-        }
-
-        $context->headersManager->add(
-            'include/reductions',
-            HeadersManager::POSITION_LAST
-        );
-
-        $resolvedParams = $call->getResolvedParams(
-            $expression['parameters'],
-            $context,
-            $expression
-        );
-
-        $symbol = $context->backend->getVariableCode($symbolVariable);
-
-        $context->codePrinter->output(
-            "tensor_matrix_min($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
-        );
-
-        return new CompiledExpression(
-            'variable',
-            $symbolVariable->getRealName(),
-            $expression
-        );
-    }
-}
diff --git a/optimizers/TensorMatrixProductOptimizer.php b/optimizers/TensorMatrixProductOptimizer.php
deleted file mode 100644
index 35d0885..0000000
--- a/optimizers/TensorMatrixProductOptimizer.php
+++ /dev/null
@@ -1,76 +0,0 @@
-<?php
-
-namespace Zephir\Optimizers\FunctionCall;
-
-use Zephir\Call;
-use Zephir\CompilationContext;
-use Zephir\CompiledExpression;
-use Zephir\HeadersManager;
-use Zephir\Exception\CompilerException;
-use Zephir\Optimizers\OptimizerAbstract;
-
-class TensorMatrixProductOptimizer extends OptimizerAbstract
-{
-    /**
-     * @param mixed[] $expression
-     * @param Call $call
-     * @param CompilationContext $context
-     * @throws CompilerException
-     * @return CompiledExpression|bool
-     */
-    public function optimize(array $expression, Call $call, CompilationContext $context)
-    {
-        if (!isset($expression['parameters'])) {
-            return false;
-        }
-
-        if (count($expression['parameters']) !== 2) {
-            throw new CompilerException(
-                'Tensor matrix product accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
-                $expression
-            );
-        }
-
-        $call->processExpectedReturn($context);
-
-        $symbolVariable = $call->getSymbolVariable();
-
-        if (empty($symbolVariable)) {
-            throw new CompilerException('Missing symbol variable.');
-        }
-
-        if ($symbolVariable->getType() !== 'variable') {
-            throw new CompilerException(
-                'Return value must only be assigned to a dynamic variable.',
-                $expression
-            );
-        }
-
-        if ($call->mustInitSymbolVariable()) {
-            $symbolVariable->initVariant($context);
-        }
-
-        $context->headersManager->add(
-            'include/reductions',
-            HeadersManager::POSITION_LAST
-        );
-
-        $resolvedParams = $call->getResolvedParams(
-            $expression['parameters'],
-            $context,
-            $expression
-        );
-
-        $symbol = $context->backend->getVariableCode($symbolVariable);
-
-        $context->codePrinter->output(
-            "tensor_matrix_product($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
-        );
-
-        return new CompiledExpression(
-            'variable',
-            $symbolVariable->getRealName(),
-            $expression
-        );
-    }
-}
diff --git a/optimizers/TensorMatrixSumOptimizer.php b/optimizers/TensorMatrixSumOptimizer.php
deleted file mode 100644
index 1e72191..0000000
--- a/optimizers/TensorMatrixSumOptimizer.php
+++ /dev/null
@@ -1,76 +0,0 @@
-<?php
-
-namespace Zephir\Optimizers\FunctionCall;
-
-use Zephir\Call;
-use Zephir\CompilationContext;
-use Zephir\CompiledExpression;
-use Zephir\HeadersManager;
-use Zephir\Exception\CompilerException;
-use Zephir\Optimizers\OptimizerAbstract;
-
-class TensorMatrixSumOptimizer extends OptimizerAbstract
-{
-    /**
-     * @param mixed[] $expression
-     * @param Call $call
-     * @param CompilationContext $context
-     * @throws CompilerException
-     * @return CompiledExpression|bool
-     */
-    public function optimize(array $expression, Call $call, CompilationContext $context)
-    {
-        if (!isset($expression['parameters'])) {
-            return false;
-        }
-
-        if (count($expression['parameters']) !== 2) {
-            throw new CompilerException(
-                'Tensor matrix sum accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
-                $expression
-            );
-        }
-
-        $call->processExpectedReturn($context);
-
-        $symbolVariable = $call->getSymbolVariable();
-
-        if (empty($symbolVariable)) {
-            throw new CompilerException('Missing symbol variable.');
-        }
-
-        if ($symbolVariable->getType() !== 'variable') {
-            throw new CompilerException(
-                'Return value must only be assigned to a dynamic variable.',
-                $expression
-            );
-        }
-
-        if ($call->mustInitSymbolVariable()) {
-            $symbolVariable->initVariant($context);
-        }
-
-        $context->headersManager->add(
-            'include/reductions',
-            HeadersManager::POSITION_LAST
-        );
-
-        $resolvedParams = $call->getResolvedParams(
-            $expression['parameters'],
-            $context,
-            $expression
-        );
-
-        $symbol = $context->backend->getVariableCode($symbolVariable);
-
-        $context->codePrinter->output(
-            "tensor_matrix_sum($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
-        );
-
-        return new CompiledExpression(
-            'variable',
-            $symbolVariable->getRealName(),
-            $expression
-        );
-    }
-}
diff --git a/optimizers/TensorBufferMinOptimizer.php b/optimizers/TensorReduceArgmaxOptimizer.php
similarity index 84%
rename from optimizers/TensorBufferMinOptimizer.php
rename to optimizers/TensorReduceArgmaxOptimizer.php
index b5b603c..d8dacce 100644
--- a/optimizers/TensorBufferMinOptimizer.php
+++ b/optimizers/TensorReduceArgmaxOptimizer.php
@@ -9,7 +9,7 @@
 use Zephir\Exception\CompilerException;
 use Zephir\Optimizers\OptimizerAbstract;
 
-class TensorBufferMinOptimizer extends OptimizerAbstract
+class TensorReduceArgmaxOptimizer extends OptimizerAbstract
 {
     /**
      * @param mixed[] $expression
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 3) {
             throw new CompilerException(
-                'Tensor buffer min accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Tensor reduce argmax accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_buffer_min($symbol, {$resolvedParams[0]});"
+            "tensor_reduce_argmax($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorReduceArgminOptimizer.php b/optimizers/TensorReduceArgminOptimizer.php
new file mode 100644
index 0000000..07c0e2f
--- /dev/null
+++ b/optimizers/TensorReduceArgminOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorReduceArgminOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor reduce argmin accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_reduce_argmin($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferArgmaxOptimizer.php b/optimizers/TensorReduceMaxOptimizer.php
similarity index 84%
rename from optimizers/TensorBufferArgmaxOptimizer.php
rename to optimizers/TensorReduceMaxOptimizer.php
index 90fb4f8..6f0976a 100644
--- a/optimizers/TensorBufferArgmaxOptimizer.php
+++ b/optimizers/TensorReduceMaxOptimizer.php
@@ -9,7 +9,7 @@
 use Zephir\Exception\CompilerException;
 use Zephir\Optimizers\OptimizerAbstract;
 
-class TensorBufferArgmaxOptimizer extends OptimizerAbstract
+class TensorReduceMaxOptimizer extends OptimizerAbstract
 {
     /**
      * @param mixed[] $expression
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 3) {
             throw new CompilerException(
-                'Tensor buffer argmax accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Tensor reduce max accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_buffer_argmax($symbol, {$resolvedParams[0]});"
+            "tensor_reduce_max($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorBufferArgminOptimizer.php b/optimizers/TensorReduceMinOptimizer.php
similarity index 84%
rename from optimizers/TensorBufferArgminOptimizer.php
rename to optimizers/TensorReduceMinOptimizer.php
index fc5c658..8beb832 100644
--- a/optimizers/TensorBufferArgminOptimizer.php
+++ b/optimizers/TensorReduceMinOptimizer.php
@@ -9,7 +9,7 @@
 use Zephir\Exception\CompilerException;
 use Zephir\Optimizers\OptimizerAbstract;
 
-class TensorBufferArgminOptimizer extends OptimizerAbstract
+class TensorReduceMinOptimizer extends OptimizerAbstract
 {
     /**
      * @param mixed[] $expression
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 3) {
             throw new CompilerException(
-                'Tensor buffer argmin accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Tensor reduce min accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_buffer_argmin($symbol, {$resolvedParams[0]});"
+            "tensor_reduce_min($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorReduceProductOptimizer.php b/optimizers/TensorReduceProductOptimizer.php
new file mode 100644
index 0000000..86398d0
--- /dev/null
+++ b/optimizers/TensorReduceProductOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorReduceProductOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor reduce product accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_reduce_product($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorBufferMaxOptimizer.php b/optimizers/TensorReduceSumOptimizer.php
similarity index 84%
rename from optimizers/TensorBufferMaxOptimizer.php
rename to optimizers/TensorReduceSumOptimizer.php
index 6c7cf6e..01db3ad 100644
--- a/optimizers/TensorBufferMaxOptimizer.php
+++ b/optimizers/TensorReduceSumOptimizer.php
@@ -9,7 +9,7 @@
 use Zephir\Exception\CompilerException;
 use Zephir\Optimizers\OptimizerAbstract;
 
-class TensorBufferMaxOptimizer extends OptimizerAbstract
+class TensorReduceSumOptimizer extends OptimizerAbstract
 {
     /**
      * @param mixed[] $expression
@@ -24,9 +24,9 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
             return false;
         }
 
-        if (count($expression['parameters']) !== 1) {
+        if (count($expression['parameters']) !== 3) {
             throw new CompilerException(
-                'Tensor buffer max accepts exactly one argument, ' . count($expression['parameters']) . 'given.',
+                'Tensor reduce sum accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_buffer_max($symbol, {$resolvedParams[0]});"
+            "tensor_reduce_sum($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
         );
 
         return new CompiledExpression(
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 8055742..f92a58e 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -1577,7 +1577,7 @@ class Matrix implements Tensor
      */
     public function sum() -> <ColumnVector>
     {
-        return new ColumnVector(tensor_matrix_sum(this->a, this->n));
+        return new ColumnVector(tensor_reduce_sum(this->a, this->m, this->n));
     }
 
     /**
@@ -1587,7 +1587,7 @@ class Matrix implements Tensor
      */
     public function product() -> <ColumnVector>
     {
-        return new ColumnVector(tensor_matrix_product(this->a, this->n));
+        return new ColumnVector(tensor_reduce_product(this->a, this->m, this->n));
     }
 
     /**
@@ -1597,7 +1597,7 @@ class Matrix implements Tensor
      */
     public function min() -> <ColumnVector>
     {
-        return new ColumnVector(tensor_matrix_min(this->a, this->n));
+        return new ColumnVector(tensor_reduce_min(this->a, this->m, this->n));
     }
 
     /**
@@ -1607,7 +1607,7 @@ class Matrix implements Tensor
      */
     public function max() -> <ColumnVector>
     {
-        return new ColumnVector(tensor_matrix_max(this->a, this->n));
+        return new ColumnVector(tensor_reduce_max(this->a, this->m, this->n));
     }
 
     /**
@@ -1617,7 +1617,7 @@ class Matrix implements Tensor
      */
     public function argmin() -> <ColumnVector>
     {
-        return new ColumnVector(tensor_matrix_argmin(this->a, this->n));
+        return new ColumnVector(tensor_reduce_argmin(this->a, this->m, this->n));
     }
 
     /**
@@ -1627,7 +1627,7 @@ class Matrix implements Tensor
      */
     public function argmax() -> <ColumnVector>
     {
-        return new ColumnVector(tensor_matrix_argmax(this->a, this->n));
+        return new ColumnVector(tensor_reduce_argmax(this->a, this->m, this->n));
     }
 
     /**
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 4d595dc..f63e4b4 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -1124,7 +1124,9 @@ class Vector implements Tensor
      */
     public function sum() -> float
     {
-        return tensor_buffer_sum(this->a);
+        var result = tensor_reduce_sum(this->a, 1, this->n);
+
+        return (double) result->get(0);
     }
 
     /**
@@ -1134,7 +1136,9 @@ class Vector implements Tensor
      */
     public function product() -> float
     {
-        return tensor_buffer_product(this->a);
+        var result = tensor_reduce_product(this->a, 1, this->n);
+
+        return (double) result->get(0);
     }
 
     /**
@@ -1144,7 +1148,14 @@ class Vector implements Tensor
      */
     public function min() -> float
     {
-        return tensor_buffer_min(this->a);
+        if unlikely this->n < 1 {
+            throw new InvalidArgumentException("Cannot compute"
+                . " the minimum of an empty vector.");
+        }
+
+        var result = tensor_reduce_min(this->a, 1, this->n);
+
+        return (double) result->get(0);
     }
 
     /**
@@ -1154,7 +1165,14 @@ class Vector implements Tensor
      */
     public function max() -> float
     {
-        return tensor_buffer_max(this->a);
+        if unlikely this->n < 1 {
+            throw new InvalidArgumentException("Cannot compute"
+                . " the maximum of an empty vector.");
+        }
+
+        var result = tensor_reduce_max(this->a, 1, this->n);
+
+        return (double) result->get(0);
     }
 
     /**
@@ -1164,7 +1182,14 @@ class Vector implements Tensor
      */
     public function argmin() -> int
     {
-        return tensor_buffer_argmin(this->a);
+        if unlikely this->n < 1 {
+            throw new InvalidArgumentException("Cannot compute"
+                . " the argmin of an empty vector.");
+        }
+
+        var result = tensor_reduce_argmin(this->a, 1, this->n);
+
+        return (int) result->get(0);
     }
 
     /**
@@ -1174,7 +1199,14 @@ class Vector implements Tensor
      */
     public function argmax() -> int
     {
-        return tensor_buffer_argmax(this->a);
+        if unlikely this->n < 1 {
+            throw new InvalidArgumentException("Cannot compute"
+                . " the argmax of an empty vector.");
+        }
+
+        var result = tensor_reduce_argmax(this->a, 1, this->n);
+
+        return (int) result->get(0);
     }
 
     /**

From 67eb12aa7ee552b1f7f41f64f9a7daf306b9fef1 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 22:20:26 -0500
Subject: [PATCH 42/51] Remove bootstrap

---
 phpunit.xml         | 2 +-
 tests/bootstrap.php | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)
 delete mode 100644 tests/bootstrap.php

diff --git a/phpunit.xml b/phpunit.xml
index 781a583..b20fb1b 100644
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" backupGlobals="false" backupStaticAttributes="false" bootstrap="tests/bootstrap.php" colors="true" convertErrorsToExceptions="true" convertNoticesToExceptions="true" convertWarningsToExceptions="true" forceCoversAnnotation="true" processIsolation="false" stopOnFailure="false" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd">
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" backupGlobals="false" backupStaticAttributes="false" colors="true" convertErrorsToExceptions="true" convertNoticesToExceptions="true" convertWarningsToExceptions="true" forceCoversAnnotation="true" processIsolation="false" stopOnFailure="false" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd">
   <testsuites>
     <testsuite name="Base">
       <directory>tests</directory>
diff --git a/tests/bootstrap.php b/tests/bootstrap.php
deleted file mode 100644
index d21c14d..0000000
--- a/tests/bootstrap.php
+++ /dev/null
@@ -1,3 +0,0 @@
-<?php
-
-require __DIR__ . '/../vendor/autoload.php';

From 0ec0bef63979c072877aeb6c1af051c01ae26b5b Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Wed, 23 Sep 2026 23:11:39 -0500
Subject: [PATCH 43/51] Optimize dot

---
 ext/include/linear_algebra.c | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/ext/include/linear_algebra.c b/ext/include/linear_algebra.c
index 49828c0..20fb6fc 100644
--- a/ext/include/linear_algebra.c
+++ b/ext/include/linear_algebra.c
@@ -65,7 +65,6 @@ void tensor_matmul(zval * return_value, zval * a, zval * b, zval * m, zval * p,
  */
 void tensor_dot(zval * return_value, zval * a, zval * b)
 {
-	zend_long i;
 	zend_long na = 0, nb = 0;
 	int ok_a = 0, ok_b = 0;
 
@@ -82,13 +81,7 @@ void tensor_dot(zval * return_value, zval * a, zval * b)
 		return;
 	}
 
-	double sigma = 0.0;
-
-	for (i = 0; i < na; ++i) {
-		sigma += va[i] * vb[i];
-	}
-
-	RETVAL_DOUBLE(sigma);
+	RETVAL_DOUBLE(cblas_ddot((blasint) na, va, 1, vb, 1));
 }
 
 /**

From e4f84b9ee024bc0cd752a48a19ff5143e4a764dd Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Thu, 24 Sep 2026 00:26:44 -0500
Subject: [PATCH 44/51] Optimize

---
 AGENTS.md                                     |   2 +-
 .../Arithmetic/VectorMatrixMultiplyBench.php  |  40 +
 ext/include/arithmetic.c                      |  42 +-
 ext/include/arithmetic.h                      |   4 +
 ext/include/comparison.c                      |  42 +-
 ext/include/comparison.h                      |   4 +
 ext/tensor/vector.zep.c                       | 985 +++---------------
 .../TensorDivideRowReverseOptimizer.php       |  76 ++
 .../TensorGreaterEqualRowReverseOptimizer.php |  76 ++
 .../TensorGreaterRowReverseOptimizer.php      |  76 ++
 .../TensorLessEqualRowReverseOptimizer.php    |  76 ++
 optimizers/TensorLessRowReverseOptimizer.php  |  76 ++
 optimizers/TensorModRowReverseOptimizer.php   |  76 ++
 optimizers/TensorPowRowReverseOptimizer.php   |  76 ++
 .../TensorSubtractRowReverseOptimizer.php     |  76 ++
 tensor/vector.zep                             | 194 ++--
 tests/MatrixTest.php                          |   4 -
 tests/VectorTest.php                          | 288 +++++
 18 files changed, 1276 insertions(+), 937 deletions(-)
 create mode 100644 benchmarks/Arithmetic/VectorMatrixMultiplyBench.php
 create mode 100644 optimizers/TensorDivideRowReverseOptimizer.php
 create mode 100644 optimizers/TensorGreaterEqualRowReverseOptimizer.php
 create mode 100644 optimizers/TensorGreaterRowReverseOptimizer.php
 create mode 100644 optimizers/TensorLessEqualRowReverseOptimizer.php
 create mode 100644 optimizers/TensorLessRowReverseOptimizer.php
 create mode 100644 optimizers/TensorModRowReverseOptimizer.php
 create mode 100644 optimizers/TensorPowRowReverseOptimizer.php
 create mode 100644 optimizers/TensorSubtractRowReverseOptimizer.php

diff --git a/AGENTS.md b/AGENTS.md
index 7615e54..65a608d 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -54,7 +54,7 @@ composer fix
   - New functionality ships with a matching unit test in `tests/`.
   - Bug fixes ship with a passing test that would have reproduced the bug beforehand.
   - Tests target public methods and cover edge cases / invalid input.
-- **Documentation & changelog:** update docs if behavior changes, and add a `CHANGELOG.md` entry for user-facing changes.
+- **Documentation & changelog:** update docs if behavior changes.
 - **PHPDoc:** classes use `@category` / `@package` / `@author` blocks; methods carry param and return annotations. Use `@var list<float>` for element arrays.
 - **Exceptions** are typed under `Tensor\Exceptions` (e.g. `InvalidArgumentException`, `DimensionalityMismatch`, `RuntimeException`). Use the existing ones rather than `Exception`.
 - **Math is float-only.** Values stored/computed as `float`; don't introduce integer-only branches. When adding a new operation, mirror it across the `Tensor` sub-interfaces (`Arithmetic`, `Comparable`, `Algebraic`, `Trigonometric`, `Statistical`, `Special`).
diff --git a/benchmarks/Arithmetic/VectorMatrixMultiplyBench.php b/benchmarks/Arithmetic/VectorMatrixMultiplyBench.php
new file mode 100644
index 0000000..082ccdf
--- /dev/null
+++ b/benchmarks/Arithmetic/VectorMatrixMultiplyBench.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tensor\Benchmarks\Arithmetic;
+
+use Tensor\Matrix;
+use Tensor\Vector;
+
+/**
+ * @Groups({"Arithmetic"})
+ * @BeforeMethods({"setUp"})
+ */
+class VectorMatrixMultiplyBench
+{
+    /**
+     * @var Vector
+     */
+    protected $a;
+
+    /**
+     * @var Matrix
+     */
+    protected $b;
+
+    public function setUp() : void
+    {
+        $this->a = Vector::uniform(1000);
+
+        $this->b = Matrix::uniform(1000, 1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function multiply() : void
+    {
+        $this->a->multiplyMatrix($this->b);
+    }
+}
diff --git a/ext/include/arithmetic.c b/ext/include/arithmetic.c
index 4861ccc..58d8517 100644
--- a/ext/include/arithmetic.c
+++ b/ext/include/arithmetic.c
@@ -519,7 +519,9 @@ void tensor_mod_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
 /* Binary operation applied to every element of a matrix using a shared
  * row vector. The matrix is wrapped up in `a` (m * n doubles in row-major
  * order) and the row vector in `b` (n doubles) so that element (i, j) of the
- * result is op(a[i * n + j], b[j]). */
+ * result is op(a[i * n + j], b[j]). `reverse` swaps the operands so that the
+ * same value function can serve both the matrix and the row vector as the
+ * left-hand side. */
 
 typedef double (*tensor_row_op)(double x, double y);
 
@@ -553,7 +555,7 @@ static double tensor_row_mod_value(double x, double y)
 	return fmod(x, y);
 }
 
-static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_row_op fn)
+static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_row_op fn, int reverse)
 {
 	zend_long nHat = 0, m = 0, total = 0, nb = 0;
 	int ok_a = 0, ok_b = 0;
@@ -587,7 +589,9 @@ static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_z
 
 	for (i = 0; i < m; ++i) {
 		for (j = 0; j < nHat; ++j) {
-			vc[i * nHat + j] = fn(va[i * nHat + j], vb[j]);
+			vc[i * nHat + j] = reverse
+				? fn(vb[j], va[i * nHat + j])
+				: fn(va[i * nHat + j], vb[j]);
 		}
 	}
 
@@ -596,30 +600,50 @@ static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_z
 
 void tensor_multiply_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_multiply_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_multiply_value, 0);
 }
 
 void tensor_add_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_add_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_add_value, 0);
 }
 
 void tensor_divide_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_divide_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_divide_value, 0);
+}
+
+void tensor_divide_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_divide_value, 1);
 }
 
 void tensor_subtract_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_subtract_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_subtract_value, 0);
+}
+
+void tensor_subtract_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_subtract_value, 1);
 }
 
 void tensor_pow_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_pow_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_pow_value, 0);
+}
+
+void tensor_pow_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_pow_value, 1);
 }
 
 void tensor_mod_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_mod_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_mod_value, 0);
+}
+
+void tensor_mod_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_mod_value, 1);
 }
\ No newline at end of file
diff --git a/ext/include/arithmetic.h b/ext/include/arithmetic.h
index 01a7784..c504320 100644
--- a/ext/include/arithmetic.h
+++ b/ext/include/arithmetic.h
@@ -31,8 +31,12 @@ void tensor_mod_col_reverse(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_multiply_row(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_add_row(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_divide_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_divide_row_reverse(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_subtract_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_subtract_row_reverse(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_pow_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_pow_row_reverse(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_mod_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_mod_row_reverse(zval * return_value, zval * a, zval * b, zval * n);
 
 #endif
diff --git a/ext/include/comparison.c b/ext/include/comparison.c
index e5e7440..1b797d1 100644
--- a/ext/include/comparison.c
+++ b/ext/include/comparison.c
@@ -519,7 +519,9 @@ void tensor_less_equal_col_reverse(zval * return_value, zval * a, zval * b, zval
 /* Comparison applied to every element of a matrix using a shared row vector.
  * The matrix is wrapped up in `a` (m * n doubles in row-major order) and the
  * row vector in `b` (n doubles) so that element (i, j) of the result is 1.0
- * when the comparison op(a[i * n + j], b[j]) holds and 0.0 otherwise. */
+ * when the comparison op(a[i * n + j], b[j]) holds and 0.0 otherwise.
+ * `reverse` swaps the operands so that the same value function can serve
+ * both the matrix and the row vector as the left-hand side. */
 
 typedef double (*tensor_row_op)(double x, double y);
 
@@ -553,7 +555,7 @@ static double tensor_row_less_equal_value(double x, double y)
 	return x <= y ? 1.0 : 0.0;
 }
 
-static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_row_op fn)
+static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_row_op fn, int reverse)
 {
 	zend_long nHat = 0, m = 0, total = 0, nb = 0;
 	int ok_a = 0, ok_b = 0;
@@ -587,7 +589,9 @@ static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_z
 
 	for (i = 0; i < m; ++i) {
 		for (j = 0; j < nHat; ++j) {
-			vc[i * nHat + j] = fn(va[i * nHat + j], vb[j]);
+			vc[i * nHat + j] = reverse
+				? fn(vb[j], va[i * nHat + j])
+				: fn(va[i * nHat + j], vb[j]);
 		}
 	}
 
@@ -596,30 +600,50 @@ static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_z
 
 void tensor_equal_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_equal_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_equal_value, 0);
 }
 
 void tensor_not_equal_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_not_equal_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_not_equal_value, 0);
 }
 
 void tensor_greater_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_greater_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_greater_value, 0);
+}
+
+void tensor_greater_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_greater_value, 1);
 }
 
 void tensor_greater_equal_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_greater_equal_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_greater_equal_value, 0);
+}
+
+void tensor_greater_equal_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_greater_equal_value, 1);
 }
 
 void tensor_less_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_less_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_less_value, 0);
+}
+
+void tensor_less_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_less_value, 1);
 }
 
 void tensor_less_equal_row(zval * return_value, zval * a, zval * b, zval * n)
 {
-	tensor_row_apply(return_value, a, b, n, tensor_row_less_equal_value);
+	tensor_row_apply(return_value, a, b, n, tensor_row_less_equal_value, 0);
+}
+
+void tensor_less_equal_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
+{
+	tensor_row_apply(return_value, a, b, n, tensor_row_less_equal_value, 1);
 }
\ No newline at end of file
diff --git a/ext/include/comparison.h b/ext/include/comparison.h
index 485bef3..7fd1e06 100644
--- a/ext/include/comparison.h
+++ b/ext/include/comparison.h
@@ -31,8 +31,12 @@ void tensor_less_equal_col_reverse(zval * return_value, zval * a, zval * b, zval
 void tensor_equal_row(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_not_equal_row(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_greater_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_greater_row_reverse(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_greater_equal_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_greater_equal_row_reverse(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_less_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_less_row_reverse(zval * return_value, zval * a, zval * b, zval * n);
 void tensor_less_equal_row(zval * return_value, zval * a, zval * b, zval * n);
+void tensor_less_equal_row_reverse(zval * return_value, zval * a, zval * b, zval * n);
 
 #endif
\ No newline at end of file
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 3cd5216..7dd6cc0 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -21,7 +21,6 @@
 #include "kernel/array.h"
 #include "math.h"
 #include "kernel/math.h"
-#include "kernel/string.h"
 #include "ext/spl/spl_array.h"
 #include "include/buffer.h"
 #include "include/linear_algebra.h"
@@ -3813,42 +3812,30 @@ PHP_METHOD(Tensor_Vector, negate)
 PHP_METHOD(Tensor_Vector, multiplyMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -3876,61 +3863,19 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1425);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_multiply(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1422);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_multiply(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1422);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_multiply_row(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3945,42 +3890,30 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 PHP_METHOD(Tensor_Vector, divideMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4008,61 +3941,19 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1451);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_divide(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1448);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_divide(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1448);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_divide_row_reverse(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4077,42 +3968,30 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 PHP_METHOD(Tensor_Vector, addMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4140,61 +4019,19 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1477);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_add(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1474);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_add(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1474);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_add_row(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4209,42 +4046,30 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 PHP_METHOD(Tensor_Vector, subtractMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4272,61 +4097,19 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1503);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_subtract(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1500);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_subtract(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1500);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_subtract_row_reverse(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4341,42 +4124,30 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 PHP_METHOD(Tensor_Vector, powMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4404,61 +4175,19 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1529);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_pow(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1526);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_pow(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1526);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_pow_row_reverse(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4473,42 +4202,30 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 PHP_METHOD(Tensor_Vector, modMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4536,61 +4253,19 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1555);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_mod(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1552);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_mod(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1552);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_mod_row_reverse(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4605,42 +4280,30 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 PHP_METHOD(Tensor_Vector, equalMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4668,61 +4331,19 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1581);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1578);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1578);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_equal_row(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4737,42 +4358,30 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 PHP_METHOD(Tensor_Vector, notEqualMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4800,61 +4409,19 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1607);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_not_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1604);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_not_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1604);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_not_equal_row(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4869,42 +4436,30 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 PHP_METHOD(Tensor_Vector, greaterMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4932,61 +4487,19 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1633);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_greater(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1630);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_greater(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1630);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_greater_row_reverse(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5001,42 +4514,30 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -5064,61 +4565,19 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1659);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_greater_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1656);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_greater_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1656);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_greater_equal_row_reverse(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5133,42 +4592,30 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 PHP_METHOD(Tensor_Vector, lessMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -5196,61 +4643,19 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1685);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_less(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1682);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_less(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1682);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_less_row_reverse(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -5265,42 +4670,30 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 {
 	zval _4$$3, _6$$3, _7$$3;
-	zend_bool _15;
-	zval c;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, rowB, _8, *_9, _10, *_11, _14, _18, _19, _20, _2$$3, _3$$3, _5$$3, _12$$4, _13$$4, _16$$5, _17$$5;
+	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&rowB);
+	ZVAL_UNDEF(&aHat);
+	ZVAL_UNDEF(&bHat);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
-	ZVAL_UNDEF(&_14);
-	ZVAL_UNDEF(&_18);
-	ZVAL_UNDEF(&_19);
-	ZVAL_UNDEF(&_20);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
-	ZVAL_UNDEF(&_12$$4);
-	ZVAL_UNDEF(&_13$$4);
-	ZVAL_UNDEF(&_16$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&c);
 	ZVAL_UNDEF(&_4$$3);
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
-	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
-	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("a", 1, 1);
-	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -5328,61 +4721,19 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_INIT_VAR(&c);
-	array_init(&c);
-	ZEPHIR_CALL_METHOD(&_8, b, "asRowBuffers", NULL, 0);
+	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	if (Z_TYPE_P(&_8) == IS_STRING) {
-		ZEPHIR_INIT_VAR(&_10);
-		zephir_string_to_char_array(&_10, &_8);
-		_9 = &_10;
-	} else {
-		_9 = &_8;
-	}
-	zephir_is_iterable(_9, 0, "tensor/vector.zep", 1711);
-	if (Z_TYPE_P(_9) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_9), _11)
-		{
-			ZEPHIR_INIT_NVAR(&rowB);
-			ZVAL_COPY(&rowB, _11);
-			ZEPHIR_INIT_NVAR(&_12$$4);
-			zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-			tensor_less_equal(&_12$$4, &_13$$4, &rowB);
-			zephir_array_append(&c, &_12$$4, PH_SEPARATE, "tensor/vector.zep", 1708);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, _9, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_15 = 1;
-		while (1) {
-			if (_15) {
-				_15 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, _9, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_14, _9, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_14)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&rowB, _9, "current", NULL, 0);
-			zephir_check_call_status();
-				ZEPHIR_INIT_NVAR(&_16$$5);
-				zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-				tensor_less_equal(&_16$$5, &_17$$5, &rowB);
-				zephir_array_append(&c, &_16$$5, PH_SEPARATE, "tensor/vector.zep", 1708);
-		}
-	}
-	ZEPHIR_INIT_NVAR(&rowB);
-	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_CE_STATIC(&_18, tensor_tensorbuffer_ce, "fromBuffers", NULL, 0, &c);
+	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_19, b, "m", NULL, 0);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_less_equal_row_reverse(&result, &bHat, &aHat, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_20, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &_18, &_19, &_20);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/optimizers/TensorDivideRowReverseOptimizer.php b/optimizers/TensorDivideRowReverseOptimizer.php
new file mode 100644
index 0000000..db3d290
--- /dev/null
+++ b/optimizers/TensorDivideRowReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorDivideRowReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor divide row reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_divide_row_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorGreaterEqualRowReverseOptimizer.php b/optimizers/TensorGreaterEqualRowReverseOptimizer.php
new file mode 100644
index 0000000..8bf5e48
--- /dev/null
+++ b/optimizers/TensorGreaterEqualRowReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorGreaterEqualRowReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor greater equal row reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_greater_equal_row_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorGreaterRowReverseOptimizer.php b/optimizers/TensorGreaterRowReverseOptimizer.php
new file mode 100644
index 0000000..5006a52
--- /dev/null
+++ b/optimizers/TensorGreaterRowReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorGreaterRowReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor greater row reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_greater_row_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLessEqualRowReverseOptimizer.php b/optimizers/TensorLessEqualRowReverseOptimizer.php
new file mode 100644
index 0000000..71e36f7
--- /dev/null
+++ b/optimizers/TensorLessEqualRowReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLessEqualRowReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor less equal row reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_less_equal_row_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorLessRowReverseOptimizer.php b/optimizers/TensorLessRowReverseOptimizer.php
new file mode 100644
index 0000000..ca2f45a
--- /dev/null
+++ b/optimizers/TensorLessRowReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorLessRowReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor less row reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/comparison',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_less_row_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorModRowReverseOptimizer.php b/optimizers/TensorModRowReverseOptimizer.php
new file mode 100644
index 0000000..44ea67d
--- /dev/null
+++ b/optimizers/TensorModRowReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorModRowReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor mod row reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_mod_row_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorPowRowReverseOptimizer.php b/optimizers/TensorPowRowReverseOptimizer.php
new file mode 100644
index 0000000..b2bd104
--- /dev/null
+++ b/optimizers/TensorPowRowReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorPowRowReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor pow row reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_pow_row_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorSubtractRowReverseOptimizer.php b/optimizers/TensorSubtractRowReverseOptimizer.php
new file mode 100644
index 0000000..06b35bf
--- /dev/null
+++ b/optimizers/TensorSubtractRowReverseOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorSubtractRowReverseOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor subtract row reverse accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/arithmetic',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_subtract_row_reverse($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/tensor/vector.zep b/tensor/vector.zep
index f63e4b4..578cfce 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -1413,16 +1413,16 @@ class Vector implements Tensor
                 . (string) this->n . " columns but Matrix B has "
                 . (string) b->n() . ".");
         }
- 
-        var rowB;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_multiply(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        var aHat, bHat, result;
+
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_multiply_row(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1440,15 +1440,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_divide(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_divide_row_reverse(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1466,15 +1466,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_add(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_add_row(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1492,15 +1492,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_subtract(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_subtract_row_reverse(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1518,15 +1518,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_pow(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_pow_row_reverse(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1544,15 +1544,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_mod(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_mod_row_reverse(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1570,15 +1570,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_equal(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_equal_row(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1596,15 +1596,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_not_equal(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_not_equal_row(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1622,15 +1622,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_greater(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_greater_row_reverse(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1648,15 +1648,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_greater_equal(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_greater_equal_row_reverse(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1674,15 +1674,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_less(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_less_row_reverse(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
@@ -1700,15 +1700,15 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var rowB;
+        var aHat, bHat, result;
 
-        array c = [];
- 
-        for rowB in b->asRowBuffers() {
-            let c[] = tensor_less_equal(this->a, rowB);
-        }
- 
-        return new Matrix(TensorBuffer::fromBuffers(c), b->m(), b->n());
+        let aHat = this->asTensorBuffer();
+
+        let bHat = b->asTensorBuffer();
+
+        let result = tensor_less_equal_row_reverse(bHat, aHat, this->n);
+
+        return new Matrix(result, b->m(), b->n());
     }
 
     /**
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index 4f1116c..ebf92dc 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -651,7 +651,6 @@ public function inverseSingularThrows() : void
 
     /**
      * @test
-     * @requires extension tensor
      */
     public function pseudoinverse() : void
     {
@@ -1076,7 +1075,6 @@ public function cholesky() : void
 
     /**
      * @test
-     * @requires extension tensor
      * @dataProvider eigProvider
      *
      * @param Matrix $matrix
@@ -1116,7 +1114,6 @@ public function eigProvider() : Generator
 
     /**
      * @test
-     * @requires extension tensor
      */
     public function eigSymmetric() : void
     {
@@ -1144,7 +1141,6 @@ public function eigSymmetric() : void
 
     /**
      * @test
-     * @requires extension tensor
      */
     public function svd() : void
     {
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index 6df4451..c899768 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -1000,6 +1000,294 @@ public function notEqualMatrixDimensionMismatch() : void
         $a->notEqualMatrix($b);
     }
 
+    /**
+     * @test
+     */
+    public function multiplyMatrix() : void
+    {
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+
+        $b = Matrix::fromArray([
+            [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
+            [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
+            [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
+        ]);
+
+        $c = $a->multiplyMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [16.0, -6.5, 0.087, -0.2, -1.3, 23.8],
+            [0.04, 13.065, 2.9, 400.0, 0.13, -11.9],
+            [4.4, 32.5, -14.5, 600.0, -0.013, 141.61],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function divideMatrix() : void
+    {
+        $a = Vector::fromArray([10.0, 20.0, 30.0]);
+
+        $b = Matrix::fromArray([
+            [2.0, 4.0, 5.0],
+            [5.0, 10.0, 3.0],
+            [3.0, 2.0, 1.0],
+        ]);
+
+        $c = $a->divideMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [5.0, 5.0, 6.0],
+            [2.0, 2.0, 10.0],
+            [3.3333333333333335, 10.0, 30.0],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function addMatrix() : void
+    {
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+
+        $b = Matrix::fromArray([
+            [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
+            [0.01, 2.01, 1.0, 20.0, 0.05, -1.0],
+            [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
+        ]);
+
+        $c = $a->addMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [8.0, 5.5, 2.93, 19.99, 2.1, 13.9],
+            [4.01, 8.51, 3.9, 40.0, 2.65, 10.9],
+            [5.1, 11.5, -2.1, 50.0, 2.595, 23.8],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function subtractMatrix() : void
+    {
+        $a = Vector::fromArray([10.0, 20.0, 30.0]);
+
+        $b = Matrix::fromArray([
+            [4.0, 15.0, 12.0],
+            [4.0, 15.0, 12.0],
+            [4.0, 15.0, 12.0],
+        ]);
+
+        $c = $a->subtractMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [6.0, 5.0, 18.0],
+            [6.0, 5.0, 18.0],
+            [6.0, 5.0, 18.0],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function powMatrix() : void
+    {
+        $a = Vector::fromArray([2.0, 10.0, 2.0]);
+
+        $b = Matrix::fromArray([
+            [1.0, 1.0, 1.5],
+            [2.0, 0.0, 1.0],
+            [3.0, 2.0, 0.5],
+        ]);
+
+        $c = $a->powMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [2.0, 10.0, 2.8284271247461903],
+            [4.0, 1.0, 2.0],
+            [8.0, 100.0, 1.4142135623730951],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function modMatrix() : void
+    {
+        $a = Vector::fromArray([1.0, 20.0, 7.5]);
+
+        $b = Matrix::fromArray([
+            [0.5, 5.0, 3.0],
+            [0.5, 10.0, 3.0],
+            [0.5, 7.5, 3.0],
+        ]);
+
+        $c = $a->modMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [0.0, 0.0, 1.5],
+            [0.0, 0.0, 1.5],
+            [0.0, 5.0, 1.5],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function equalMatrix() : void
+    {
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+
+        $b = Matrix::fromArray([
+            [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
+            [0.01, 6.5, 2.9, 20.0, 2.6, 11.9],
+            [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
+        ]);
+
+        $c = $a->equalMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            [0.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            [0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function notEqualMatrix() : void
+    {
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+
+        $b = Matrix::fromArray([
+            [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
+            [0.01, 6.5, 2.9, 20.0, 2.6, 11.9],
+            [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
+        ]);
+
+        $c = $a->notEqualMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [0.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            [1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            [1.0, 1.0, 1.0, 1.0, 1.0, 0.0],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function greaterMatrix() : void
+    {
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+
+        $b = Matrix::fromArray([
+            [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
+            [0.01, 6.5, 2.9, 20.0, 0.05, -1.0],
+            [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
+        ]);
+
+        $c = $a->greaterMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [0.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            [1.0, 0.0, 0.0, 0.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0, 0.0, 1.0, 0.0],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function greaterEqualMatrix() : void
+    {
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+
+        $b = Matrix::fromArray([
+            [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
+            [0.01, 6.5, 2.9, 20.0, 0.05, -1.0],
+            [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
+        ]);
+
+        $c = $a->greaterEqualMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0, 0.0, 1.0, 1.0],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function lessMatrix() : void
+    {
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+
+        $b = Matrix::fromArray([
+            [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
+            [0.01, 6.5, 2.9, 20.0, 0.05, -1.0],
+            [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
+        ]);
+
+        $c = $a->lessMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
+    /**
+     * @test
+     */
+    public function lessEqualMatrix() : void
+    {
+        $a = Vector::fromArray([4.0, 6.5, 2.9, 20.0, 2.6, 11.9]);
+
+        $b = Matrix::fromArray([
+            [4.0, -1.0, 0.03, -0.01, -0.5, 2.0],
+            [0.01, 6.5, 2.9, 20.0, 0.05, -1.0],
+            [1.1, 5.0, -5.0, 30.0, -0.005, 11.9],
+        ]);
+
+        $c = $a->lessEqualMatrix($b);
+
+        $expected = Matrix::fromArray([
+            [1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            [0.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0, 0.0, 1.0],
+        ]);
+
+        $this->assertEqualsWithDelta($expected->asArray(), $c->asArray(), self::MAX_DELTA);
+    }
+
     /**
      * @test
      * @dataProvider greaterProvider

From 01655da39aca7e926c20db8686bb6d26d0ab91b8 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Thu, 24 Sep 2026 00:56:43 -0500
Subject: [PATCH 45/51] More vectorization

---
 AGENTS.md                                     |   6 +-
 CHANGELOG.md                                  |   1 -
 .../MatrixColumnVectorDivideBench.php         |  40 ++
 .../MatrixColumnVectorSubtractBench.php       |  40 ++
 .../Arithmetic/MatrixVectorAddBench.php       |  40 ++
 .../Arithmetic/MatrixVectorDivideBench.php    |  40 ++
 .../MatrixColumnVectorEqualBench.php          |  40 ++
 .../Comparison/MatrixVectorGreaterBench.php   |  40 ++
 benchmarks/Functions/NegateMatrixBench.php    |  32 ++
 benchmarks/Functions/Rad2DegMatrixBench.php   |  32 ++
 ext/include/arithmetic.c                      | 368 ++++++-----------
 ext/include/buffer.c                          |   1 +
 ext/include/comparison.c                      | 370 ++++++------------
 ext/include/linear_algebra.c                  |   1 +
 ext/include/reductions.c                      |   2 +
 ext/include/signal_processing.c               |   1 +
 ext/include/unary.c                           | 189 +++------
 17 files changed, 595 insertions(+), 648 deletions(-)
 create mode 100644 benchmarks/Arithmetic/MatrixColumnVectorDivideBench.php
 create mode 100644 benchmarks/Arithmetic/MatrixColumnVectorSubtractBench.php
 create mode 100644 benchmarks/Arithmetic/MatrixVectorAddBench.php
 create mode 100644 benchmarks/Arithmetic/MatrixVectorDivideBench.php
 create mode 100644 benchmarks/Comparison/MatrixColumnVectorEqualBench.php
 create mode 100644 benchmarks/Comparison/MatrixVectorGreaterBench.php
 create mode 100644 benchmarks/Functions/NegateMatrixBench.php
 create mode 100644 benchmarks/Functions/Rad2DegMatrixBench.php

diff --git a/AGENTS.md b/AGENTS.md
index 65a608d..f2d78b8 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -34,7 +34,7 @@ All are Composer scripts (see `composer.json`):
 | Fix style | `composer fix` |
 | Full build | `composer build` = validate → install → analyze → test → check |
 | Benchmarks | `composer benchmark` (requires the extension to be loaded) |
-| Compile extension | `composer compile` = zephir generate → `php build-ext` → zephir compile |
+| Compile extension | `composer compile` = zephir generate → zephir compile |
 | Clean generated extension | `composer clean` (zephir fullclean) |
 
 **Recommended loop before submitting a change:**
@@ -73,10 +73,10 @@ Do **not** hand-edit the generated C in `ext/` (files like `*.dep`, `*.lo`, `*.o
 
 ## Working verification paths
 
-To run the tests against the locally compiled extension, load the built shared object. For example:
+An installed TEnsor extension will override any new changes. To run the tests against the locally compiled extension, load the built shared object. For example:
 
 ```sh
-php -n -d extension=$PWD/ext/modules/tensor.so vendor/bin/phpunit ...
+php -n -d extension=$PWD/ext/modules/tensor.so extension=iconv -d extension=mbstring -d extension=tokenizer -d extension=dom -d extension=xml -d extension=ctype vendor/bin/phpunit ...
 ```
 
 If a system-installed `tensor` extension is already enabled, you can rely on it instead of building locally.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9641c1b..cb9c05d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,6 @@
 # Change Log
 
 - 4.0.0
-    - Consolidated the buffer and matrix reductions into a single shape-agnostic `tensor_reduce_*` family shared by Vector, ColumnVector, and Matrix
 
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
diff --git a/benchmarks/Arithmetic/MatrixColumnVectorDivideBench.php b/benchmarks/Arithmetic/MatrixColumnVectorDivideBench.php
new file mode 100644
index 0000000..6c2dc2b
--- /dev/null
+++ b/benchmarks/Arithmetic/MatrixColumnVectorDivideBench.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tensor\Benchmarks\Arithmetic;
+
+use Tensor\Matrix;
+use Tensor\ColumnVector;
+
+/**
+ * @Groups({"Arithmetic"})
+ * @BeforeMethods({"setUp"})
+ */
+class MatrixColumnVectorDivideBench
+{
+    /**
+     * @var Matrix
+     */
+    protected $a;
+
+    /**
+     * @var ColumnVector
+     */
+    protected $b;
+
+    public function setUp() : void
+    {
+        $this->a = Matrix::uniform(1000, 1000);
+
+        $this->b = ColumnVector::uniform(1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function divide() : void
+    {
+        $this->a->divide($this->b);
+    }
+}
diff --git a/benchmarks/Arithmetic/MatrixColumnVectorSubtractBench.php b/benchmarks/Arithmetic/MatrixColumnVectorSubtractBench.php
new file mode 100644
index 0000000..21e3b13
--- /dev/null
+++ b/benchmarks/Arithmetic/MatrixColumnVectorSubtractBench.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tensor\Benchmarks\Arithmetic;
+
+use Tensor\Matrix;
+use Tensor\ColumnVector;
+
+/**
+ * @Groups({"Arithmetic"})
+ * @BeforeMethods({"setUp"})
+ */
+class MatrixColumnVectorSubtractBench
+{
+    /**
+     * @var Matrix
+     */
+    protected $a;
+
+    /**
+     * @var ColumnVector
+     */
+    protected $b;
+
+    public function setUp() : void
+    {
+        $this->a = Matrix::uniform(1000, 1000);
+
+        $this->b = ColumnVector::uniform(1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function subtract() : void
+    {
+        $this->a->subtract($this->b);
+    }
+}
diff --git a/benchmarks/Arithmetic/MatrixVectorAddBench.php b/benchmarks/Arithmetic/MatrixVectorAddBench.php
new file mode 100644
index 0000000..21db41b
--- /dev/null
+++ b/benchmarks/Arithmetic/MatrixVectorAddBench.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tensor\Benchmarks\Arithmetic;
+
+use Tensor\Matrix;
+use Tensor\Vector;
+
+/**
+ * @Groups({"Arithmetic"})
+ * @BeforeMethods({"setUp"})
+ */
+class MatrixVectorAddBench
+{
+    /**
+     * @var Matrix
+     */
+    protected $a;
+
+    /**
+     * @var Vector
+     */
+    protected $b;
+
+    public function setUp() : void
+    {
+        $this->a = Matrix::uniform(1000, 1000);
+
+        $this->b = Vector::uniform(1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function add() : void
+    {
+        $this->a->add($this->b);
+    }
+}
diff --git a/benchmarks/Arithmetic/MatrixVectorDivideBench.php b/benchmarks/Arithmetic/MatrixVectorDivideBench.php
new file mode 100644
index 0000000..9d8e4dc
--- /dev/null
+++ b/benchmarks/Arithmetic/MatrixVectorDivideBench.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tensor\Benchmarks\Arithmetic;
+
+use Tensor\Matrix;
+use Tensor\Vector;
+
+/**
+ * @Groups({"Arithmetic"})
+ * @BeforeMethods({"setUp"})
+ */
+class MatrixVectorDivideBench
+{
+    /**
+     * @var Matrix
+     */
+    protected $a;
+
+    /**
+     * @var Vector
+     */
+    protected $b;
+
+    public function setUp() : void
+    {
+        $this->a = Matrix::uniform(1000, 1000);
+
+        $this->b = Vector::uniform(1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function divide() : void
+    {
+        $this->a->divide($this->b);
+    }
+}
diff --git a/benchmarks/Comparison/MatrixColumnVectorEqualBench.php b/benchmarks/Comparison/MatrixColumnVectorEqualBench.php
new file mode 100644
index 0000000..1a0d3d6
--- /dev/null
+++ b/benchmarks/Comparison/MatrixColumnVectorEqualBench.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tensor\Benchmarks\Comparison;
+
+use Tensor\Matrix;
+use Tensor\ColumnVector;
+
+/**
+ * @Groups({"Comparison"})
+ * @BeforeMethods({"setUp"})
+ */
+class MatrixColumnVectorEqualBench
+{
+    /**
+     * @var Matrix
+     */
+    protected $a;
+
+    /**
+     * @var ColumnVector
+     */
+    protected $b;
+
+    public function setUp() : void
+    {
+        $this->a = Matrix::uniform(1000, 1000);
+
+        $this->b = ColumnVector::uniform(1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function equal() : void
+    {
+        $this->a->equal($this->b);
+    }
+}
diff --git a/benchmarks/Comparison/MatrixVectorGreaterBench.php b/benchmarks/Comparison/MatrixVectorGreaterBench.php
new file mode 100644
index 0000000..61b2d2c
--- /dev/null
+++ b/benchmarks/Comparison/MatrixVectorGreaterBench.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tensor\Benchmarks\Comparison;
+
+use Tensor\Matrix;
+use Tensor\Vector;
+
+/**
+ * @Groups({"Comparison"})
+ * @BeforeMethods({"setUp"})
+ */
+class MatrixVectorGreaterBench
+{
+    /**
+     * @var Matrix
+     */
+    protected $a;
+
+    /**
+     * @var Vector
+     */
+    protected $b;
+
+    public function setUp() : void
+    {
+        $this->a = Matrix::uniform(1000, 1000);
+
+        $this->b = Vector::uniform(1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function greater() : void
+    {
+        $this->a->greater($this->b);
+    }
+}
diff --git a/benchmarks/Functions/NegateMatrixBench.php b/benchmarks/Functions/NegateMatrixBench.php
new file mode 100644
index 0000000..8c5515b
--- /dev/null
+++ b/benchmarks/Functions/NegateMatrixBench.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Tensor\Benchmarks\Functions;
+
+use Tensor\Matrix;
+
+/**
+ * @Groups({"Functions"})
+ * @BeforeMethods({"setUp"})
+ */
+class NegateMatrixBench
+{
+    /**
+     * @var Matrix
+     */
+    protected $a;
+
+    public function setUp() : void
+    {
+        $this->a = Matrix::uniform(1000, 1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function negate() : void
+    {
+        $this->a->negate();
+    }
+}
diff --git a/benchmarks/Functions/Rad2DegMatrixBench.php b/benchmarks/Functions/Rad2DegMatrixBench.php
new file mode 100644
index 0000000..e8e09d0
--- /dev/null
+++ b/benchmarks/Functions/Rad2DegMatrixBench.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Tensor\Benchmarks\Functions;
+
+use Tensor\Matrix;
+
+/**
+ * @Groups({"Functions"})
+ * @BeforeMethods({"setUp"})
+ */
+class Rad2DegMatrixBench
+{
+    /**
+     * @var Matrix
+     */
+    protected $a;
+
+    public function setUp() : void
+    {
+        $this->a = Matrix::uniform(1000, 1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function rad2deg() : void
+    {
+        $this->a->rad2deg();
+    }
+}
diff --git a/ext/include/arithmetic.c b/ext/include/arithmetic.c
index 58d8517..38eda28 100644
--- a/ext/include/arithmetic.c
+++ b/ext/include/arithmetic.c
@@ -6,6 +6,7 @@
 #include <math.h>
 #include <ext/spl/spl_exceptions.h>
 #include "kernel/operators.h"
+#include "php_ext.h"
 #include "kernel/buffer.h"
 #include "include/buffer.h"
 
@@ -390,260 +391,121 @@ void tensor_mod_scalar(zval * return_value, zval * a, zval * b)
 /* Scalar operation applied to every element of a matrix row. The matrix is
  * wrapped up in `a` (m * n doubles in row-major order) and the column vector
  * in `b` (m doubles) so that element (i, j) of the result is op(a[i * n + j],
- * b[i]). `reverse` swaps the operands so that the same value function can
- * serve both the matrix and the column vector as the left-hand side. */
-
-typedef double (*tensor_col_op)(double x, double y);
-
-static double tensor_col_multiply_value(double x, double y)
-{
-	return x * y;
-}
-
-static double tensor_col_divide_value(double x, double y)
-{
-	return x / y;
-}
-
-static double tensor_col_add_value(double x, double y)
-{
-	return x + y;
-}
-
-static double tensor_col_subtract_value(double x, double y)
-{
-	return x - y;
-}
-
-static double tensor_col_pow_value(double x, double y)
-{
-	return pow(x, y);
-}
-
-static double tensor_col_mod_value(double x, double y)
-{
-	return fmod(x, y);
-}
-
-static void tensor_col_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_col_op fn, int reverse)
-{
-	zend_long n = 0, m = 0, total = 0;
-	int ok_a = 0, ok_b = 0;
-
-	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);
-	double * vb = tensor_tensorbuffer_doubles(b, &m, &ok_b);
-
-	if (UNEXPECTED(!ok_a || !ok_b)) {
-		return;
-	}
-
-	zend_long nHat = zephir_get_intval(n_zval);
-
-	if (UNEXPECTED(nHat < 1 || total != m * nHat)) {
-		zephir_throw_exception_string(spl_ce_LengthException,
-			SL("Matrix and vector dimensions must agree."));
-		return;
-	}
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	zend_long i, j;
-
-	for (i = 0; i < m; ++i) {
-		for (j = 0; j < nHat; ++j) {
-			vc[i * nHat + j] = reverse
-				? fn(vb[i], va[i * nHat + j])
-				: fn(va[i * nHat + j], vb[i]);
-		}
-	}
-
-	zval_ptr_dtor(&c);
-}
-
-void tensor_multiply_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_multiply_value, 0);
-}
-
-void tensor_add_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_add_value, 0);
-}
-
-void tensor_divide_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_divide_value, 0);
-}
-
-void tensor_divide_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_divide_value, 1);
-}
-
-void tensor_subtract_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_subtract_value, 0);
-}
-
-void tensor_subtract_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_subtract_value, 1);
-}
-
-void tensor_pow_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_pow_value, 0);
-}
-
-void tensor_pow_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_pow_value, 1);
-}
-
-void tensor_mod_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_mod_value, 0);
-}
-
-void tensor_mod_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_mod_value, 1);
-}
+ * b[i]).  Each operation expands into its own dedicated pair of loops so that
+ * the optimizer can vectorize the elementwise mapping instead of being blocked
+ * by an indirect call. */
+
+#define TENSOR_COL_APPLY(name, expr)                                             \
+void tensor_##name(zval * return_value, zval * a, zval * b, zval * n_zval)      \
+{                                                                                \
+	zend_long n = 0, m = 0, total = 0;                                           \
+	int ok_a = 0, ok_b = 0;                                                      \
+	                                                                             \
+	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);                 \
+	double * vb = tensor_tensorbuffer_doubles(b, &m, &ok_b);                     \
+	                                                                             \
+	if (UNEXPECTED(!ok_a || !ok_b)) {                                            \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	zend_long nHat = zephir_get_intval(n_zval);                                  \
+	                                                                             \
+	if (UNEXPECTED(nHat < 1 || total != m * nHat)) {                             \
+		zephir_throw_exception_string(spl_ce_LengthException,                    \
+			SL("Matrix and vector dimensions must agree."));                     \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	zval c;                                                                      \
+	                                                                             \
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) { \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	double * vc = zephir_buffer_doubles(&c);                                     \
+	                                                                             \
+	zend_long i, j;                                                              \
+	                                                                             \
+	for (i = 0; i < m; ++i) {                                                    \
+		for (j = 0; j < nHat; ++j) {                                             \
+			vc[i * nHat + j] = expr;                                             \
+		}                                                                        \
+	}                                                                            \
+	                                                                             \
+	zval_ptr_dtor(&c);                                                           \
+}
+
+TENSOR_COL_APPLY(multiply_col, va[i * nHat + j] * vb[i])
+TENSOR_COL_APPLY(add_col, va[i * nHat + j] + vb[i])
+TENSOR_COL_APPLY(divide_col, va[i * nHat + j] / vb[i])
+TENSOR_COL_APPLY(divide_col_reverse, vb[i] / va[i * nHat + j])
+TENSOR_COL_APPLY(subtract_col, va[i * nHat + j] - vb[i])
+TENSOR_COL_APPLY(subtract_col_reverse, vb[i] - va[i * nHat + j])
+TENSOR_COL_APPLY(pow_col, pow(va[i * nHat + j], vb[i]))
+TENSOR_COL_APPLY(pow_col_reverse, pow(vb[i], va[i * nHat + j]))
+TENSOR_COL_APPLY(mod_col, fmod(va[i * nHat + j], vb[i]))
+TENSOR_COL_APPLY(mod_col_reverse, fmod(vb[i], va[i * nHat + j]))
+
+#undef TENSOR_COL_APPLY
 
 /* Binary operation applied to every element of a matrix using a shared
  * row vector. The matrix is wrapped up in `a` (m * n doubles in row-major
  * order) and the row vector in `b` (n doubles) so that element (i, j) of the
- * result is op(a[i * n + j], b[j]). `reverse` swaps the operands so that the
- * same value function can serve both the matrix and the row vector as the
- * left-hand side. */
-
-typedef double (*tensor_row_op)(double x, double y);
-
-static double tensor_row_multiply_value(double x, double y)
-{
-	return x * y;
-}
-
-static double tensor_row_add_value(double x, double y)
-{
-	return x + y;
-}
-
-static double tensor_row_divide_value(double x, double y)
-{
-	return x / y;
-}
-
-static double tensor_row_subtract_value(double x, double y)
-{
-	return x - y;
-}
-
-static double tensor_row_pow_value(double x, double y)
-{
-	return pow(x, y);
-}
-
-static double tensor_row_mod_value(double x, double y)
-{
-	return fmod(x, y);
-}
-
-static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_row_op fn, int reverse)
-{
-	zend_long nHat = 0, m = 0, total = 0, nb = 0;
-	int ok_a = 0, ok_b = 0;
-
-	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);
-	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
-
-	if (UNEXPECTED(!ok_a || !ok_b)) {
-		return;
-	}
-
-	nHat = zephir_get_intval(n_zval);
-
-	if (UNEXPECTED(nHat < 1 || nb != nHat || total < nHat || total % nHat != 0)) {
-		zephir_throw_exception_string(spl_ce_LengthException,
-			SL("Matrix and vector dimensions must agree."));
-		return;
-	}
-
-	m = total / nHat;
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	zend_long i, j;
-
-	for (i = 0; i < m; ++i) {
-		for (j = 0; j < nHat; ++j) {
-			vc[i * nHat + j] = reverse
-				? fn(vb[j], va[i * nHat + j])
-				: fn(va[i * nHat + j], vb[j]);
-		}
-	}
-
-	zval_ptr_dtor(&c);
-}
-
-void tensor_multiply_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_multiply_value, 0);
-}
-
-void tensor_add_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_add_value, 0);
-}
-
-void tensor_divide_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_divide_value, 0);
-}
-
-void tensor_divide_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_divide_value, 1);
-}
-
-void tensor_subtract_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_subtract_value, 0);
-}
-
-void tensor_subtract_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_subtract_value, 1);
-}
-
-void tensor_pow_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_pow_value, 0);
-}
-
-void tensor_pow_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_pow_value, 1);
-}
-
-void tensor_mod_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_mod_value, 0);
-}
-
-void tensor_mod_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_mod_value, 1);
-}
\ No newline at end of file
+ * result is op(a[i * n + j], b[j]).  Each operation expands into its own
+ * dedicated pair of loops so that the optimizer can vectorize the elementwise
+ * mapping instead of being blocked by an indirect call. */
+
+#define TENSOR_ROW_APPLY(name, expr)                                             \
+void tensor_##name(zval * return_value, zval * a, zval * b, zval * n_zval)      \
+{                                                                                \
+	zend_long nHat = 0, m = 0, total = 0, nb = 0;                                \
+	int ok_a = 0, ok_b = 0;                                                      \
+	                                                                             \
+	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);                 \
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);                    \
+	                                                                             \
+	if (UNEXPECTED(!ok_a || !ok_b)) {                                            \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	nHat = zephir_get_intval(n_zval);                                            \
+	                                                                             \
+	if (UNEXPECTED(nHat < 1 || nb != nHat || total < nHat || total % nHat != 0)) { \
+		zephir_throw_exception_string(spl_ce_LengthException,                    \
+			SL("Matrix and vector dimensions must agree."));                     \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	m = total / nHat;                                                            \
+	                                                                             \
+	zval c;                                                                      \
+	                                                                             \
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) { \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	double * vc = zephir_buffer_doubles(&c);                                     \
+	                                                                             \
+	zend_long i, j;                                                              \
+	                                                                             \
+	for (i = 0; i < m; ++i) {                                                    \
+		for (j = 0; j < nHat; ++j) {                                             \
+			vc[i * nHat + j] = expr;                                             \
+		}                                                                        \
+	}                                                                            \
+	                                                                             \
+	zval_ptr_dtor(&c);                                                           \
+}
+
+TENSOR_ROW_APPLY(multiply_row, va[i * nHat + j] * vb[j])
+TENSOR_ROW_APPLY(add_row, va[i * nHat + j] + vb[j])
+TENSOR_ROW_APPLY(divide_row, va[i * nHat + j] / vb[j])
+TENSOR_ROW_APPLY(divide_row_reverse, vb[j] / va[i * nHat + j])
+TENSOR_ROW_APPLY(subtract_row, va[i * nHat + j] - vb[j])
+TENSOR_ROW_APPLY(subtract_row_reverse, vb[j] - va[i * nHat + j])
+TENSOR_ROW_APPLY(pow_row, pow(va[i * nHat + j], vb[j]))
+TENSOR_ROW_APPLY(pow_row_reverse, pow(vb[j], va[i * nHat + j]))
+TENSOR_ROW_APPLY(mod_row, fmod(va[i * nHat + j], vb[j]))
+TENSOR_ROW_APPLY(mod_row_reverse, fmod(vb[j], va[i * nHat + j]))
+
+#undef TENSOR_ROW_APPLY
\ No newline at end of file
diff --git a/ext/include/buffer.c b/ext/include/buffer.c
index d9f8920..1fb61d7 100644
--- a/ext/include/buffer.c
+++ b/ext/include/buffer.c
@@ -6,6 +6,7 @@
 #include <stdlib.h>
 #include <ext/spl/spl_exceptions.h>
 #include "kernel/main.h"
+#include "php_ext.h"
 #include "kernel/buffer.h"
 #include "kernel/exception.h"
 #include "kernel/operators.h"
diff --git a/ext/include/comparison.c b/ext/include/comparison.c
index 1b797d1..2de0d76 100644
--- a/ext/include/comparison.c
+++ b/ext/include/comparison.c
@@ -5,6 +5,7 @@
 #include <php.h>
 #include <ext/spl/spl_exceptions.h>
 #include "kernel/operators.h"
+#include "php_ext.h"
 #include "kernel/buffer.h"
 #include "include/buffer.h"
 
@@ -389,261 +390,122 @@ void tensor_less_equal_scalar(zval * return_value, zval * a, zval * b)
 /* Comparison applied to every element of a matrix row. The matrix is wrapped
  * up in `a` (m * n doubles in row-major order) and the column vector in `b`
  * (m doubles) so that element (i, j) of the result is 1.0 when the comparison
- * op(a[i * n + j], b[i]) holds and 0.0 otherwise. `reverse` swaps the operands
- * so that the same predicate can serve both the matrix and the column vector
- * as the left-hand side. */
-
-typedef double (*tensor_col_op)(double x, double y);
-
-static double tensor_col_equal_value(double x, double y)
-{
-	return x == y ? 1.0 : 0.0;
-}
-
-static double tensor_col_not_equal_value(double x, double y)
-{
-	return x != y ? 1.0 : 0.0;
-}
-
-static double tensor_col_greater_value(double x, double y)
-{
-	return x > y ? 1.0 : 0.0;
-}
-
-static double tensor_col_greater_equal_value(double x, double y)
-{
-	return x >= y ? 1.0 : 0.0;
-}
-
-static double tensor_col_less_value(double x, double y)
-{
-	return x < y ? 1.0 : 0.0;
-}
-
-static double tensor_col_less_equal_value(double x, double y)
-{
-	return x <= y ? 1.0 : 0.0;
-}
-
-static void tensor_col_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_col_op fn, int reverse)
-{
-	zend_long n = 0, m = 0, total = 0;
-	int ok_a = 0, ok_b = 0;
-
-	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);
-	double * vb = tensor_tensorbuffer_doubles(b, &m, &ok_b);
-
-	if (UNEXPECTED(!ok_a || !ok_b)) {
-		return;
-	}
-
-	zend_long nHat = zephir_get_intval(n_zval);
-
-	if (UNEXPECTED(nHat < 1 || total != m * nHat)) {
-		zephir_throw_exception_string(spl_ce_LengthException,
-			SL("Matrix and vector dimensions must agree."));
-		return;
-	}
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	zend_long i, j;
-
-	for (i = 0; i < m; ++i) {
-		for (j = 0; j < nHat; ++j) {
-			vc[i * nHat + j] = reverse
-				? fn(vb[i], va[i * nHat + j])
-				: fn(va[i * nHat + j], vb[i]);
-		}
-	}
-
-	zval_ptr_dtor(&c);
-}
-
-void tensor_equal_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_equal_value, 0);
-}
-
-void tensor_not_equal_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_not_equal_value, 0);
-}
-
-void tensor_greater_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_greater_value, 0);
-}
-
-void tensor_greater_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_greater_value, 1);
-}
-
-void tensor_greater_equal_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_greater_equal_value, 0);
-}
-
-void tensor_greater_equal_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_greater_equal_value, 1);
-}
-
-void tensor_less_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_less_value, 0);
-}
-
-void tensor_less_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_less_value, 1);
-}
-
-void tensor_less_equal_col(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_less_equal_value, 0);
-}
-
-void tensor_less_equal_col_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_col_apply(return_value, a, b, n, tensor_col_less_equal_value, 1);
-}
+ * op(a[i * n + j], b[i]) holds and 0.0 otherwise.  Each operation expands into
+ * its own dedicated pair of loops so that the optimizer can vectorize the
+ * elementwise mapping instead of being blocked by an indirect call. */
+
+#define TENSOR_COL_APPLY(name, expr)                                             \
+void tensor_##name(zval * return_value, zval * a, zval * b, zval * n_zval)      \
+{                                                                                \
+	zend_long n = 0, m = 0, total = 0;                                           \
+	int ok_a = 0, ok_b = 0;                                                      \
+	                                                                             \
+	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);                 \
+	double * vb = tensor_tensorbuffer_doubles(b, &m, &ok_b);                     \
+	                                                                             \
+	if (UNEXPECTED(!ok_a || !ok_b)) {                                            \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	zend_long nHat = zephir_get_intval(n_zval);                                  \
+	                                                                             \
+	if (UNEXPECTED(nHat < 1 || total != m * nHat)) {                             \
+		zephir_throw_exception_string(spl_ce_LengthException,                    \
+			SL("Matrix and vector dimensions must agree."));                     \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	zval c;                                                                      \
+	                                                                             \
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) { \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	double * vc = zephir_buffer_doubles(&c);                                     \
+	                                                                             \
+	zend_long i, j;                                                              \
+	                                                                             \
+	for (i = 0; i < m; ++i) {                                                    \
+		for (j = 0; j < nHat; ++j) {                                             \
+			vc[i * nHat + j] = expr;                                             \
+		}                                                                        \
+	}                                                                            \
+	                                                                             \
+	zval_ptr_dtor(&c);                                                           \
+}
+
+TENSOR_COL_APPLY(equal_col, va[i * nHat + j] == vb[i] ? 1.0 : 0.0)
+TENSOR_COL_APPLY(not_equal_col, va[i * nHat + j] != vb[i] ? 1.0 : 0.0)
+TENSOR_COL_APPLY(greater_col, va[i * nHat + j] > vb[i] ? 1.0 : 0.0)
+TENSOR_COL_APPLY(greater_col_reverse, vb[i] > va[i * nHat + j] ? 1.0 : 0.0)
+TENSOR_COL_APPLY(greater_equal_col, va[i * nHat + j] >= vb[i] ? 1.0 : 0.0)
+TENSOR_COL_APPLY(greater_equal_col_reverse, vb[i] >= va[i * nHat + j] ? 1.0 : 0.0)
+TENSOR_COL_APPLY(less_col, va[i * nHat + j] < vb[i] ? 1.0 : 0.0)
+TENSOR_COL_APPLY(less_col_reverse, vb[i] < va[i * nHat + j] ? 1.0 : 0.0)
+TENSOR_COL_APPLY(less_equal_col, va[i * nHat + j] <= vb[i] ? 1.0 : 0.0)
+TENSOR_COL_APPLY(less_equal_col_reverse, vb[i] <= va[i * nHat + j] ? 1.0 : 0.0)
+
+#undef TENSOR_COL_APPLY
 
 /* Comparison applied to every element of a matrix using a shared row vector.
  * The matrix is wrapped up in `a` (m * n doubles in row-major order) and the
  * row vector in `b` (n doubles) so that element (i, j) of the result is 1.0
- * when the comparison op(a[i * n + j], b[j]) holds and 0.0 otherwise.
- * `reverse` swaps the operands so that the same value function can serve
- * both the matrix and the row vector as the left-hand side. */
-
-typedef double (*tensor_row_op)(double x, double y);
-
-static double tensor_row_equal_value(double x, double y)
-{
-	return x == y ? 1.0 : 0.0;
-}
-
-static double tensor_row_not_equal_value(double x, double y)
-{
-	return x != y ? 1.0 : 0.0;
-}
-
-static double tensor_row_greater_value(double x, double y)
-{
-	return x > y ? 1.0 : 0.0;
-}
-
-static double tensor_row_greater_equal_value(double x, double y)
-{
-	return x >= y ? 1.0 : 0.0;
-}
-
-static double tensor_row_less_value(double x, double y)
-{
-	return x < y ? 1.0 : 0.0;
-}
-
-static double tensor_row_less_equal_value(double x, double y)
-{
-	return x <= y ? 1.0 : 0.0;
-}
-
-static void tensor_row_apply(zval * return_value, zval * a, zval * b, zval * n_zval, tensor_row_op fn, int reverse)
-{
-	zend_long nHat = 0, m = 0, total = 0, nb = 0;
-	int ok_a = 0, ok_b = 0;
-
-	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);
-	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
-
-	if (UNEXPECTED(!ok_a || !ok_b)) {
-		return;
-	}
-
-	nHat = zephir_get_intval(n_zval);
-
-	if (UNEXPECTED(nHat < 1 || nb != nHat || total < nHat || total % nHat != 0)) {
-		zephir_throw_exception_string(spl_ce_LengthException,
-			SL("Matrix and vector dimensions must agree."));
-		return;
-	}
-
-	m = total / nHat;
-
-	zval c;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) {
-		return;
-	}
-
-	double * vc = zephir_buffer_doubles(&c);
-
-	zend_long i, j;
-
-	for (i = 0; i < m; ++i) {
-		for (j = 0; j < nHat; ++j) {
-			vc[i * nHat + j] = reverse
-				? fn(vb[j], va[i * nHat + j])
-				: fn(va[i * nHat + j], vb[j]);
-		}
-	}
-
-	zval_ptr_dtor(&c);
-}
-
-void tensor_equal_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_equal_value, 0);
-}
-
-void tensor_not_equal_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_not_equal_value, 0);
-}
-
-void tensor_greater_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_greater_value, 0);
-}
-
-void tensor_greater_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_greater_value, 1);
-}
-
-void tensor_greater_equal_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_greater_equal_value, 0);
-}
-
-void tensor_greater_equal_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_greater_equal_value, 1);
-}
-
-void tensor_less_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_less_value, 0);
-}
-
-void tensor_less_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_less_value, 1);
-}
-
-void tensor_less_equal_row(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_less_equal_value, 0);
-}
-
-void tensor_less_equal_row_reverse(zval * return_value, zval * a, zval * b, zval * n)
-{
-	tensor_row_apply(return_value, a, b, n, tensor_row_less_equal_value, 1);
-}
\ No newline at end of file
+ * when the comparison op(a[i * n + j], b[j]) holds and 0.0 otherwise.  Each
+ * operation expands into its own dedicated pair of loops so that the optimizer
+ * can vectorize the elementwise mapping instead of being blocked by an
+ * indirect call. */
+
+#define TENSOR_ROW_APPLY(name, expr)                                             \
+void tensor_##name(zval * return_value, zval * a, zval * b, zval * n_zval)      \
+{                                                                                \
+	zend_long nHat = 0, m = 0, total = 0, nb = 0;                                \
+	int ok_a = 0, ok_b = 0;                                                      \
+	                                                                             \
+	double * va = tensor_tensorbuffer_doubles(a, &total, &ok_a);                 \
+	double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);                    \
+	                                                                             \
+	if (UNEXPECTED(!ok_a || !ok_b)) {                                            \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	nHat = zephir_get_intval(n_zval);                                            \
+	                                                                             \
+	if (UNEXPECTED(nHat < 1 || nb != nHat || total < nHat || total % nHat != 0)) { \
+		zephir_throw_exception_string(spl_ce_LengthException,                    \
+			SL("Matrix and vector dimensions must agree."));                     \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	m = total / nHat;                                                            \
+	                                                                             \
+	zval c;                                                                      \
+	                                                                             \
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) { \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	double * vc = zephir_buffer_doubles(&c);                                     \
+	                                                                             \
+	zend_long i, j;                                                              \
+	                                                                             \
+	for (i = 0; i < m; ++i) {                                                    \
+		for (j = 0; j < nHat; ++j) {                                             \
+			vc[i * nHat + j] = expr;                                             \
+		}                                                                        \
+	}                                                                            \
+	                                                                             \
+	zval_ptr_dtor(&c);                                                           \
+}
+
+TENSOR_ROW_APPLY(equal_row, va[i * nHat + j] == vb[j] ? 1.0 : 0.0)
+TENSOR_ROW_APPLY(not_equal_row, va[i * nHat + j] != vb[j] ? 1.0 : 0.0)
+TENSOR_ROW_APPLY(greater_row, va[i * nHat + j] > vb[j] ? 1.0 : 0.0)
+TENSOR_ROW_APPLY(greater_row_reverse, vb[j] > va[i * nHat + j] ? 1.0 : 0.0)
+TENSOR_ROW_APPLY(greater_equal_row, va[i * nHat + j] >= vb[j] ? 1.0 : 0.0)
+TENSOR_ROW_APPLY(greater_equal_row_reverse, vb[j] >= va[i * nHat + j] ? 1.0 : 0.0)
+TENSOR_ROW_APPLY(less_row, va[i * nHat + j] < vb[j] ? 1.0 : 0.0)
+TENSOR_ROW_APPLY(less_row_reverse, vb[j] < va[i * nHat + j] ? 1.0 : 0.0)
+TENSOR_ROW_APPLY(less_equal_row, va[i * nHat + j] <= vb[j] ? 1.0 : 0.0)
+TENSOR_ROW_APPLY(less_equal_row_reverse, vb[j] <= va[i * nHat + j] ? 1.0 : 0.0)
+
+#undef TENSOR_ROW_APPLY
\ No newline at end of file
diff --git a/ext/include/linear_algebra.c b/ext/include/linear_algebra.c
index 20fb6fc..c150a2c 100644
--- a/ext/include/linear_algebra.c
+++ b/ext/include/linear_algebra.c
@@ -8,6 +8,7 @@
 #include <cblas.h>
 #include <lapacke.h>
 #include "kernel/operators.h"
+#include "php_ext.h"
 #include "kernel/buffer.h"
 #include "include/buffer.h"
 
diff --git a/ext/include/reductions.c b/ext/include/reductions.c
index 457f48c..4d51a20 100644
--- a/ext/include/reductions.c
+++ b/ext/include/reductions.c
@@ -6,8 +6,10 @@
 #include <stdlib.h>
 #include <ext/spl/spl_exceptions.h>
 #include "kernel/main.h"
+#include "php_ext.h"
 #include "kernel/buffer.h"
 #include "kernel/exception.h"
+#include "kernel/operators.h"
 #include "include/buffer.h"
 #include "include/reductions.h"
 
diff --git a/ext/include/signal_processing.c b/ext/include/signal_processing.c
index ac4920f..59c592c 100644
--- a/ext/include/signal_processing.c
+++ b/ext/include/signal_processing.c
@@ -5,6 +5,7 @@
 #include <php.h>
 #include <ext/spl/spl_exceptions.h>
 #include "kernel/operators.h"
+#include "php_ext.h"
 #include "kernel/buffer.h"
 #include "include/buffer.h"
 
diff --git a/ext/include/unary.c b/ext/include/unary.c
index 77917c7..99a6871 100644
--- a/ext/include/unary.c
+++ b/ext/include/unary.c
@@ -8,150 +8,65 @@
 #include <stdio.h>
 #include <ext/spl/spl_exceptions.h>
 #include "kernel/operators.h"
+#include "php_ext.h"
 #include "kernel/buffer.h"
 #include "include/buffer.h"
 
 /* Values wrapped up by the kernel Buffer used in the unary operations below.
  * Returns a reference to a newly created `Tensor\TensorBuffer` holding the
- * mapped doubles. */
-
-static void tensor_elementwise_unary(zval * return_value, zval * a, double (* fn)(double))
-{
-	zend_long n = 0;
-	int ok = 0;
-
-	double * va = tensor_tensorbuffer_doubles(a, &n, &ok);
-
-	if (UNEXPECTED(!ok)) {
-		return;
-	}
-
-	zval b;
-
-	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, n, &b) == FAILURE)) {
-		return;
-	}
-
-	double * vb = zephir_buffer_doubles(&b);
-
-	zend_long i;
-
-	for (i = 0; i < n; ++i) {
-		vb[i] = fn(va[i]);
-	}
-
-	zval_ptr_dtor(&b);
-}
-
-static double tensor_rad2deg_value(double v)
-{
-	return (v / M_PI) * 180;
-}
-
-static double tensor_deg2rad_value(double v)
-{
-	return (v / 180.0) * M_PI;
-}
-
-static double tensor_negate_value(double v)
-{
-	return -v;
-}
-
-static double tensor_sign_value(double v)
-{
-	return v > 0.0 ? 1.0 : (v < 0.0 ? -1.0 : 0.0);
-}
-
-void tensor_abs(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, fabs);
-}
-
-void tensor_sqrt(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, sqrt);
-}
-
-void tensor_exp(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, exp);
-}
-
-void tensor_expm1(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, expm1);
-}
-
-void tensor_log(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, log);
-}
-
-void tensor_log1p(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, log1p);
-}
-
-void tensor_sin(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, sin);
+ * mapped doubles.  Each operation expands into its own dedicated loop so the
+ * optimizer can vectorize the elementwise mapping instead of being blocked by
+ * an indirect call. */
+
+#define TENSOR_UNARY(name, expr)                                                 \
+void tensor_##name(zval * return_value, zval * a)                               \
+{                                                                                \
+	zend_long n = 0;                                                             \
+	int ok = 0;                                                                  \
+	                                                                             \
+	double * va = tensor_tensorbuffer_doubles(a, &n, &ok);                       \
+	                                                                             \
+	if (UNEXPECTED(!ok)) {                                                       \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	zval b;                                                                      \
+	                                                                             \
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, n, &b) == FAILURE)) { \
+		return;                                                                  \
+	}                                                                            \
+	                                                                             \
+	double * vb = zephir_buffer_doubles(&b);                                     \
+	                                                                             \
+	zend_long i;                                                                 \
+	                                                                             \
+	for (i = 0; i < n; ++i) {                                                    \
+		vb[i] = expr;                                                            \
+	}                                                                            \
+	                                                                             \
+	zval_ptr_dtor(&b);                                                           \
 }
 
-void tensor_asin(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, asin);
-}
-
-void tensor_cos(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, cos);
-}
-
-void tensor_acos(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, acos);
-}
-
-void tensor_tan(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, tan);
-}
-
-void tensor_atan(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, atan);
-}
-
-void tensor_rad2deg(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, tensor_rad2deg_value);
-}
-
-void tensor_deg2rad(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, tensor_deg2rad_value);
-}
-
-void tensor_floor(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, floor);
-}
-
-void tensor_ceil(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, ceil);
-}
-
-void tensor_negate(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, tensor_negate_value);
-}
-
-void tensor_sign(zval * return_value, zval * a)
-{
-	tensor_elementwise_unary(return_value, a, tensor_sign_value);
-}
+TENSOR_UNARY(abs, fabs(va[i]))
+TENSOR_UNARY(sqrt, sqrt(va[i]))
+TENSOR_UNARY(exp, exp(va[i]))
+TENSOR_UNARY(expm1, expm1(va[i]))
+TENSOR_UNARY(log, log(va[i]))
+TENSOR_UNARY(log1p, log1p(va[i]))
+TENSOR_UNARY(sin, sin(va[i]))
+TENSOR_UNARY(asin, asin(va[i]))
+TENSOR_UNARY(cos, cos(va[i]))
+TENSOR_UNARY(acos, acos(va[i]))
+TENSOR_UNARY(tan, tan(va[i]))
+TENSOR_UNARY(atan, atan(va[i]))
+TENSOR_UNARY(rad2deg, (va[i] / M_PI) * 180)
+TENSOR_UNARY(deg2rad, (va[i] / 180.0) * M_PI)
+TENSOR_UNARY(floor, floor(va[i]))
+TENSOR_UNARY(ceil, ceil(va[i]))
+TENSOR_UNARY(negate, -va[i])
+TENSOR_UNARY(sign, va[i] > 0.0 ? 1.0 : (va[i] < 0.0 ? -1.0 : 0.0))
+
+#undef TENSOR_UNARY
 
 void tensor_log_base(zval * return_value, zval * a, zval * b)
 {

From 3061438f44aa04611a9e36c22394814a1ceee821 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Thu, 24 Sep 2026 01:16:55 -0500
Subject: [PATCH 46/51] Optimize median and quantiles

---
 AGENTS.md                                     |   2 +-
 benchmarks/Statistical/VectorMedianBench.php  |  32 +++
 .../Statistical/VectorQuantileBench.php       |  32 +++
 ext/include/reductions.c                      |  14 +-
 ext/include/reductions.h                      |   4 +-
 ext/tensor/decompositions/cholesky.zep.c      |   2 +-
 ext/tensor/decompositions/eigen.zep.c         |   4 +-
 ext/tensor/decompositions/lu.zep.c            |   2 +-
 ext/tensor/decompositions/svd.zep.c           |   2 +-
 ext/tensor/matrix.zep.c                       |  24 +--
 ext/tensor/reductions/ref.zep.c               |   2 +-
 ext/tensor/reductions/rref.zep.c              |   2 +-
 ext/tensor/tensorbuffer.zep.c                 |  14 +-
 ext/tensor/vector.zep.c                       | 196 +++++++++---------
 ...ptimizer.php => TensorMedianOptimizer.php} |   6 +-
 ...imizer.php => TensorQuantileOptimizer.php} |   6 +-
 tensor/matrix.zep                             |   4 +-
 tensor/vector.zep                             |  38 +---
 tests/VectorTest.php                          |  24 +++
 19 files changed, 238 insertions(+), 172 deletions(-)
 create mode 100644 benchmarks/Statistical/VectorMedianBench.php
 create mode 100644 benchmarks/Statistical/VectorQuantileBench.php
 rename optimizers/{TensorMatrixMedianOptimizer.php => TensorMedianOptimizer.php} (87%)
 rename optimizers/{TensorMatrixQuantileOptimizer.php => TensorQuantileOptimizer.php} (86%)

diff --git a/AGENTS.md b/AGENTS.md
index f2d78b8..5cdae9b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -76,7 +76,7 @@ Do **not** hand-edit the generated C in `ext/` (files like `*.dep`, `*.lo`, `*.o
 An installed TEnsor extension will override any new changes. To run the tests against the locally compiled extension, load the built shared object. For example:
 
 ```sh
-php -n -d extension=$PWD/ext/modules/tensor.so extension=iconv -d extension=mbstring -d extension=tokenizer -d extension=dom -d extension=xml -d extension=ctype vendor/bin/phpunit ...
+php -n -d extension=$PWD/ext/modules/tensor_ext.so extension=iconv -d extension=mbstring -d extension=tokenizer -d extension=dom -d extension=xml -d extension=ctype -d extension=xmlwriter vendor/bin/phpunit ...
 ```
 
 If a system-installed `tensor` extension is already enabled, you can rely on it instead of building locally.
diff --git a/benchmarks/Statistical/VectorMedianBench.php b/benchmarks/Statistical/VectorMedianBench.php
new file mode 100644
index 0000000..c0fd2ae
--- /dev/null
+++ b/benchmarks/Statistical/VectorMedianBench.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Tensor\Benchmarks\Statistical;
+
+use Tensor\Vector;
+
+/**
+ * @Groups({"Statistical"})
+ * @BeforeMethods({"setUp"})
+ */
+class VectorMedianBench
+{
+    /**
+     * @var Vector
+     */
+    protected $a;
+
+    public function setUp() : void
+    {
+        $this->a = Vector::uniform(100000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function median() : void
+    {
+        $this->a->median();
+    }
+}
diff --git a/benchmarks/Statistical/VectorQuantileBench.php b/benchmarks/Statistical/VectorQuantileBench.php
new file mode 100644
index 0000000..4852f88
--- /dev/null
+++ b/benchmarks/Statistical/VectorQuantileBench.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Tensor\Benchmarks\Statistical;
+
+use Tensor\Vector;
+
+/**
+ * @Groups({"Statistical"})
+ * @BeforeMethods({"setUp"})
+ */
+class VectorQuantileBench
+{
+    /**
+     * @var Vector
+     */
+    protected $a;
+
+    public function setUp() : void
+    {
+        $this->a = Vector::uniform(100000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function quantile() : void
+    {
+        $this->a->quantile(0.5);
+    }
+}
diff --git a/ext/include/reductions.c b/ext/include/reductions.c
index 4d51a20..5e3ad4f 100644
--- a/ext/include/reductions.c
+++ b/ext/include/reductions.c
@@ -393,14 +393,15 @@ void tensor_reduce_argmax(zval * return_value, zval * obj, zval * groups, zval *
 }
 
 /**
- * Return the median of each row of a matrix as a column buffer. The matrix
- * buffer itself is never modified; the rows are copied once and sorted.
+ * Return the median of each row of a matrix as a column buffer, or of a
+ * vector as a single element. The buffer itself is never modified; the rows
+ * are copied once and sorted. A Vector is simply a 1 x n matrix.
  *
  * @param return_value
  * @param obj
  * @param n
  */
-void tensor_matrix_median(zval * return_value, zval * obj, zval * n)
+void tensor_median(zval * return_value, zval * obj, zval * n)
 {
 	double * va = NULL;
 	zend_long m = 0, n_hat = 0;
@@ -449,15 +450,16 @@ void tensor_matrix_median(zval * return_value, zval * obj, zval * n)
 }
 
 /**
- * Return the q'th quantile of each row of a matrix as a column buffer. The
- * matrix buffer itself is never modified; the rows are copied once and sorted.
+ * Return the q'th quantile of each row of a matrix as a column buffer, or of
+ * a vector as a single element. The buffer itself is never modified; the rows
+ * are copied once and sorted. A Vector is simply a 1 x n matrix.
  *
  * @param return_value
  * @param obj
  * @param n
  * @param q
  */
-void tensor_matrix_quantile(zval * return_value, zval * obj, zval * n, zval * q)
+void tensor_quantile(zval * return_value, zval * obj, zval * n, zval * q)
 {
 	double * va = NULL;
 	zend_long m = 0, n_hat = 0;
diff --git a/ext/include/reductions.h b/ext/include/reductions.h
index 20a15fb..521469f 100644
--- a/ext/include/reductions.h
+++ b/ext/include/reductions.h
@@ -10,8 +10,8 @@ void tensor_reduce_max(zval * return_value, zval * obj, zval * groups, zval * le
 void tensor_reduce_argmin(zval * return_value, zval * obj, zval * groups, zval * length);
 void tensor_reduce_argmax(zval * return_value, zval * obj, zval * groups, zval * length);
 
-void tensor_matrix_median(zval * return_value, zval * obj, zval * n);
-void tensor_matrix_quantile(zval * return_value, zval * obj, zval * n, zval * q);
+void tensor_median(zval * return_value, zval * obj, zval * n);
+void tensor_quantile(zval * return_value, zval * obj, zval * n, zval * q);
 void tensor_matrix_repeat(zval * return_value, zval * obj, zval * n, zval * times_m, zval * times_n);
 void tensor_matrix_to_array(zval * return_value, zval * obj, zval * n);
 
diff --git a/ext/tensor/decompositions/cholesky.zep.c b/ext/tensor/decompositions/cholesky.zep.c
index 42d1c40..8c962ed 100644
--- a/ext/tensor/decompositions/cholesky.zep.c
+++ b/ext/tensor/decompositions/cholesky.zep.c
@@ -108,7 +108,7 @@ PHP_METHOD(Tensor_Decompositions_Cholesky, decompose)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 14, &l, &_7, &_8);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &_6);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 19, &_6);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/eigen.zep.c b/ext/tensor/decompositions/eigen.zep.c
index ff5bce4..f36739d 100644
--- a/ext/tensor/decompositions/eigen.zep.c
+++ b/ext/tensor/decompositions/eigen.zep.c
@@ -153,10 +153,10 @@ PHP_METHOD(Tensor_Decompositions_Eigen, decompose)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(NULL, &_12, "__construct", NULL, 14, &_13, &_14, &_15);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&eigenvectors, &_12, "transpose", NULL, 22);
+	ZEPHIR_CALL_METHOD(&eigenvectors, &_12, "transpose", NULL, 20);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_eigen_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &eigenvalues, &eigenvectors);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 21, &eigenvalues, &eigenvectors);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/lu.zep.c b/ext/tensor/decompositions/lu.zep.c
index 9adc3d7..f5607ef 100644
--- a/ext/tensor/decompositions/lu.zep.c
+++ b/ext/tensor/decompositions/lu.zep.c
@@ -159,7 +159,7 @@ PHP_METHOD(Tensor_Decompositions_Lu, decompose)
 	ZEPHIR_CALL_METHOD(NULL, &p, "__construct", NULL, 14, &_14, &_15, &_16);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_lu_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 24, &l, &u, &p);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 22, &l, &u, &p);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/decompositions/svd.zep.c b/ext/tensor/decompositions/svd.zep.c
index 2636dff..0e58c42 100644
--- a/ext/tensor/decompositions/svd.zep.c
+++ b/ext/tensor/decompositions/svd.zep.c
@@ -132,7 +132,7 @@ PHP_METHOD(Tensor_Decompositions_Svd, decompose)
 	ZEPHIR_CALL_METHOD(NULL, &vT, "__construct", NULL, 14, &_10, &_11, &_12);
 	zephir_check_call_status();
 	object_init_ex(return_value, tensor_decompositions_svd_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 25, &u, &singularValues, &vT);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 23, &u, &singularValues, &vT);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 7b3cd5d..caff54f 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -257,7 +257,7 @@ PHP_METHOD(Tensor_Matrix, diagonal)
 	zephir_fetch_params(1, 1, 0, &elements_param);
 	zephir_get_arrval(&elements, elements_param);
 	n = zephir_fast_count_int(&elements);
-	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 26, &elements);
+	ZEPHIR_CALL_FUNCTION(&_0, "array_values", NULL, 24, &elements);
 	zephir_check_call_status();
 	ZEPHIR_CPY_WRT(&elements, &_0);
 	ZEPHIR_INIT_VAR(&a);
@@ -942,7 +942,7 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	ZEPHIR_CALL_FUNCTION(&aList, "array_values", NULL, 26, &a);
+	ZEPHIR_CALL_FUNCTION(&aList, "array_values", NULL, 24, &a);
 	zephir_check_call_status();
 	zephir_memory_observe(&firstRow);
 	zephir_array_fetch_long(&firstRow, &aList, 0, PH_NOISY, "tensor/matrix.zep", 377);
@@ -1983,7 +1983,7 @@ PHP_METHOD(Tensor_Matrix, transpose)
 	zephir_memory_observe(&col);
 	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 713);
 	ZVAL_LONG(&_3, 1);
-	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 27, &cols, &_3);
+	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 25, &cols, &_3);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_2, &col, "concat", NULL, 0, &_4);
 	zephir_check_call_status();
@@ -2057,7 +2057,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_5$$4, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 28, &_6$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 26, &_6$$4);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 735);
 		ZEPHIR_MM_RESTORE();
@@ -2072,7 +2072,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_9$$5, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_10$$5);
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 28, &_10$$5);
+		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 26, &_10$$5);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 742);
 		ZEPHIR_MM_RESTORE();
@@ -2132,7 +2132,7 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		object_init_ex(&_3$$3, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 28, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 26, &_4$$3);
 		zephir_check_call_status();
 		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 759);
 		ZEPHIR_MM_RESTORE();
@@ -2284,7 +2284,7 @@ PHP_METHOD(Tensor_Matrix, fullRank)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_1, this_ptr, "shape", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 29, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 27, &_1);
 	zephir_check_call_status();
 	RETURN_MM_BOOL(ZEPHIR_IS_IDENTICAL(&_0, &_2));
 }
@@ -2598,13 +2598,13 @@ PHP_METHOD(Tensor_Matrix, convolve)
 	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_19, ((zephir_get_numberval(&_18) + stride) - 1));
 	ZVAL_LONG(&_20, stride);
-	ZEPHIR_CALL_FUNCTION(&_21, "intdiv", NULL, 18, &_19, &_20);
+	ZEPHIR_CALL_FUNCTION(&_21, "intdiv", NULL, 28, &_19, &_20);
 	zephir_check_call_status();
 	outM = zephir_get_intval(&_21);
 	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_20, ((zephir_get_numberval(&_19) + stride) - 1));
 	ZVAL_LONG(&_22, stride);
-	ZEPHIR_CALL_FUNCTION(&_23, "intdiv", NULL, 18, &_20, &_22);
+	ZEPHIR_CALL_FUNCTION(&_23, "intdiv", NULL, 28, &_20, &_22);
 	zephir_check_call_status();
 	outN = zephir_get_intval(&_23);
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -4694,7 +4694,7 @@ PHP_METHOD(Tensor_Matrix, median)
 	ZEPHIR_INIT_VAR(&_0);
 	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
-	tensor_matrix_median(&_0, &_1, &_2);
+	tensor_median(&_0, &_1, &_2);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -4763,7 +4763,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 14, PH_NOISY_CC | PH_READONLY);
 	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_DOUBLE(&_8, q);
-	tensor_matrix_quantile(&_5, &_6, &_7, &_8);
+	tensor_quantile(&_5, &_6, &_7, &_8);
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_5);
 	zephir_check_call_status();
 	RETURN_MM();
@@ -9685,7 +9685,7 @@ PHP_METHOD(Tensor_Matrix, getIterator)
 	object_init_ex(return_value, spl_ce_ArrayIterator);
 	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asVectors", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 20, &_0);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 18, &_0);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index b45afed..ba4fdb3 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -115,7 +115,7 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	swaps = zephir_get_intval(&_8);
 	object_init_ex(return_value, tensor_reductions_ref_ce);
 	ZVAL_LONG(&_9, swaps);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 30, &b, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 29, &b, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index ae98634..edd602e 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -88,7 +88,7 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 14, &result, &_4, &_5);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 30, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index 06cf1f3..b7b7181 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -91,7 +91,7 @@ PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
 	zephir_memory_observe(&_2);
 	zephir_array_fetch_long(&_2, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 46);
 	ZVAL_LONG(&_3, 1);
-	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 27, &buffers, &_3);
+	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 25, &buffers, &_3);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_METHOD(&_2, "concat", NULL, 0, &_4);
 	zephir_check_call_status();
@@ -314,7 +314,7 @@ PHP_METHOD(Tensor_TensorBuffer, slice)
 	ZVAL_LONG(&_8, length);
 	tensor_buffer_slice(&b, &_6, &_7, &_8);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -433,7 +433,7 @@ PHP_METHOD(Tensor_TensorBuffer, sliceStrided)
 	ZVAL_LONG(&_12, stride);
 	tensor_buffer_slice_strided(&b, &_9, &_10, &_11, &_12);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -514,7 +514,7 @@ PHP_METHOD(Tensor_TensorBuffer, concat)
 	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 20, PH_NOISY_CC | PH_READONLY);
 	tensor_buffer_concat(&b, &_5, &unwrapped);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -596,7 +596,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			ZVAL_COPY(&buffer, _8);
 			ZEPHIR_INIT_NVAR(&_9$$4);
 			object_init_ex(&_9$$4, tensor_tensorbuffer_ce);
-			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 32, &buffer);
+			ZEPHIR_CALL_METHOD(NULL, &_9$$4, "__construct", &_10, 31, &buffer);
 			zephir_check_call_status();
 			zephir_array_append(&tensorBuffers, &_9$$4, PH_SEPARATE, "tensor/tensorbuffer.zep", 228);
 		} ZEND_HASH_FOREACH_END();
@@ -620,7 +620,7 @@ PHP_METHOD(Tensor_TensorBuffer, split)
 			zephir_check_call_status();
 				ZEPHIR_INIT_NVAR(&_13$$5);
 				object_init_ex(&_13$$5, tensor_tensorbuffer_ce);
-				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 32, &buffer);
+				ZEPHIR_CALL_METHOD(NULL, &_13$$5, "__construct", &_10, 31, &buffer);
 				zephir_check_call_status();
 				zephir_array_append(&tensorBuffers, &_13$$5, PH_SEPARATE, "tensor/tensorbuffer.zep", 228);
 		}
@@ -681,7 +681,7 @@ PHP_METHOD(Tensor_TensorBuffer, repeat)
 	ZVAL_LONG(&_5, times);
 	tensor_buffer_repeat(&b, &_4, &_5);
 	object_init_ex(return_value, tensor_tensorbuffer_ce);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 32, &b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 31, &b);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 7dd6cc0..21a835f 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -3267,20 +3267,20 @@ PHP_METHOD(Tensor_Vector, mean)
  */
 PHP_METHOD(Tensor_Vector, median)
 {
-	zval median, _0, _1, _2, a, _3, _4$$4, _5$$4, _6$$4;
+	zval _2$$3;
+	zval _0, result, _3, _4, _5, _6, _1$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, mid;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&median);
 	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&_2);
-	ZVAL_UNDEF(&a);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_3);
-	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_4);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
@@ -3293,32 +3293,25 @@ PHP_METHOD(Tensor_Vector, median)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	ZVAL_LONG(&_1, 2);
-	ZEPHIR_CALL_FUNCTION(&_2, "intdiv", NULL, 18, &_0, &_1);
-	zephir_check_call_status();
-	mid = zephir_get_intval(&_2);
-	zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_1, "toArray", NULL, 0);
-	zephir_check_call_status();
-	ZEPHIR_MAKE_REF(&a);
-	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 19, &a);
-	ZEPHIR_UNREF(&a);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	if (zephir_safe_mod_zval_long(&_3, 2) == 1) {
-		zephir_memory_observe(&median);
-		zephir_array_fetch_long(&median, &a, mid, PH_NOISY, "tensor/vector.zep", 1238);
-	} else {
-		zephir_memory_observe(&_4$$4);
-		zephir_array_fetch_long(&_4$$4, &a, (mid - 1), PH_NOISY, "tensor/vector.zep", 1240);
-		zephir_memory_observe(&_5$$4);
-		zephir_array_fetch_long(&_5$$4, &a, mid, PH_NOISY, "tensor/vector.zep", 1240);
-		ZEPHIR_INIT_VAR(&_6$$4);
-		zephir_add_function(&_6$$4, &_4$$4, &_5$$4);
-		ZEPHIR_INIT_NVAR(&median);
-		ZVAL_DOUBLE(&median, zephir_safe_div_zval_double(&_6$$4, 2.0));
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_2$$3);
+		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the median of an empty vector.");
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1231);
+		ZEPHIR_MM_RESTORE();
+		return;
 	}
-	RETURN_CCTOR(&median);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_median(&result, &_3, &_4);
+	ZVAL_LONG(&_6, 0);
+	ZEPHIR_CALL_METHOD(&_5, &result, "get", NULL, 0, &_6);
+	zephir_check_call_status();
+	RETURN_MM_DOUBLE(zephir_get_doubleval(&_5));
 }
 
 /**
@@ -3330,32 +3323,34 @@ PHP_METHOD(Tensor_Vector, median)
  */
 PHP_METHOD(Tensor_Vector, quantile)
 {
+	zval _7$$4;
 	zend_bool _0;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, xHat;
-	zval *q_param = NULL, a, _5, _6, _7, _10, _11, _1$$3, _2$$3, _3$$3, _4$$3, _8$$4, _9$$4;
-	double q, x, remainder, t;
+	zend_long ZEPHIR_LAST_CALL_STATUS;
+	zval *q_param = NULL, _5, result, _8, _9, _10, _11, _12, _1$$3, _2$$3, _3$$3, _4$$3, _6$$4;
+	double q;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_6);
-	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&result);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
 	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_12);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_4$$3);
-	ZVAL_UNDEF(&_8$$4);
-	ZVAL_UNDEF(&_9$$4);
+	ZVAL_UNDEF(&_6$$4);
+	ZVAL_UNDEF(&_7$$4);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
-		_zephir_prop_0 = zend_string_init("a", 1, 1);
+		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("n", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
 	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -3379,34 +3374,31 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1257);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1250);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(&a, &_5, "toArray", NULL, 0);
-	zephir_check_call_status();
-	ZEPHIR_MAKE_REF(&a);
-	ZEPHIR_CALL_FUNCTION(NULL, "sort", NULL, 19, &a);
-	ZEPHIR_UNREF(&a);
-	zephir_check_call_status();
-	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-	x =  (((q * (double) ((zephir_get_numberval(&_6) - 1))) + (double) (1)));
-	xHat = (int) x;
-	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-	if (ZEPHIR_LE_LONG(&_7, xHat)) {
-		zephir_memory_observe(&_8$$4);
-		zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_1, 2, PH_NOISY_CC | PH_READONLY);
-		zephir_array_fetch_long(&_8$$4, &a, (zephir_get_numberval(&_9$$4) - 1), PH_NOISY, "tensor/vector.zep", 1269);
-		RETURN_MM_DOUBLE(zephir_get_doubleval(&_8$$4));
-	}
-	remainder =  ((x -  (double) xHat));
-	zephir_memory_observe(&_10);
-	zephir_array_fetch_long(&_10, &a, (xHat - 1), PH_NOISY, "tensor/vector.zep", 1274);
-	t =  (zephir_get_doubleval(&_10));
-	zephir_memory_observe(&_11);
-	zephir_array_fetch_long(&_11, &a, xHat, PH_NOISY, "tensor/vector.zep", 1276);
-	RETURN_MM_DOUBLE((t + (remainder * (zephir_get_numberval(&_11) - t))));
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_5, 1))) {
+		ZEPHIR_INIT_VAR(&_6$$4);
+		object_init_ex(&_6$$4, tensor_exceptions_invalidargumentexception_ce);
+		ZEPHIR_INIT_VAR(&_7$$4);
+		ZEPHIR_CONCAT_SS(&_7$$4, "Cannot compute", " the quantile of an empty vector.");
+		ZEPHIR_CALL_METHOD(NULL, &_6$$4, "__construct", NULL, 2, &_7$$4);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_6$$4, "tensor/vector.zep", 1255);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	ZVAL_DOUBLE(&_10, q);
+	tensor_quantile(&result, &_8, &_9, &_10);
+	ZVAL_LONG(&_12, 0);
+	ZEPHIR_CALL_METHOD(&_11, &result, "get", NULL, 0, &_12);
+	zephir_check_call_status();
+	RETURN_MM_DOUBLE(zephir_get_doubleval(&_11));
 }
 
 /**
@@ -3464,7 +3456,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 2, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1291);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1275);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3530,7 +3522,7 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1315);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1299);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3649,7 +3641,7 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1354);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1338);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3859,7 +3851,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1414);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1398);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3937,7 +3929,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1440);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1424);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4015,7 +4007,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1466);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1450);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4093,7 +4085,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1492);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1476);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4171,7 +4163,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1518);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1502);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4249,7 +4241,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1544);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1528);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4327,7 +4319,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1570);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1554);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4405,7 +4397,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1596);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1580);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4483,7 +4475,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1622);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1606);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4561,7 +4553,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1648);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1632);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4639,7 +4631,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1674);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1658);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4717,7 +4709,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1700);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1684);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4796,7 +4788,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1726);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1710);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4868,7 +4860,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1744);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1728);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4940,7 +4932,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1762);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1746);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5012,7 +5004,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1780);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1764);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5084,7 +5076,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1798);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1782);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5156,7 +5148,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1816);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1800);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5229,7 +5221,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1835);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1819);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5301,7 +5293,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1853);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1837);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5373,7 +5365,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1871);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1855);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5445,7 +5437,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1889);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1873);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5517,7 +5509,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1907);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1891);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5589,7 +5581,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1925);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1909);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6100,7 +6092,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2082);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2066);
 	return;
 }
 
@@ -6151,7 +6143,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2106);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2090);
 	return;
 }
 
@@ -6209,7 +6201,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2120);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2104);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6244,7 +6236,7 @@ PHP_METHOD(Tensor_Vector, getIterator)
 	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1, PH_NOISY_CC | PH_READONLY);
 	ZEPHIR_CALL_METHOD(&_1, &_0, "toArray", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 20, &_1);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 18, &_1);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -6317,13 +6309,13 @@ PHP_METHOD(Tensor_Vector, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2161);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2145);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, &_1);
-	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2164);
+	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2148);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_2);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/optimizers/TensorMatrixMedianOptimizer.php b/optimizers/TensorMedianOptimizer.php
similarity index 87%
rename from optimizers/TensorMatrixMedianOptimizer.php
rename to optimizers/TensorMedianOptimizer.php
index d156812..849f852 100644
--- a/optimizers/TensorMatrixMedianOptimizer.php
+++ b/optimizers/TensorMedianOptimizer.php
@@ -9,7 +9,7 @@
 use Zephir\Exception\CompilerException;
 use Zephir\Optimizers\OptimizerAbstract;
 
-class TensorMatrixMedianOptimizer extends OptimizerAbstract
+class TensorMedianOptimizer extends OptimizerAbstract
 {
     /**
      * @param mixed[] $expression
@@ -26,7 +26,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
 
         if (count($expression['parameters']) !== 2) {
             throw new CompilerException(
-                'Tensor matrix median accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                'Tensor median accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_matrix_median($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+            "tensor_median($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
         );
 
         return new CompiledExpression(
diff --git a/optimizers/TensorMatrixQuantileOptimizer.php b/optimizers/TensorQuantileOptimizer.php
similarity index 86%
rename from optimizers/TensorMatrixQuantileOptimizer.php
rename to optimizers/TensorQuantileOptimizer.php
index 7ce438e..0c36863 100644
--- a/optimizers/TensorMatrixQuantileOptimizer.php
+++ b/optimizers/TensorQuantileOptimizer.php
@@ -9,7 +9,7 @@
 use Zephir\Exception\CompilerException;
 use Zephir\Optimizers\OptimizerAbstract;
 
-class TensorMatrixQuantileOptimizer extends OptimizerAbstract
+class TensorQuantileOptimizer extends OptimizerAbstract
 {
     /**
      * @param mixed[] $expression
@@ -26,7 +26,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
 
         if (count($expression['parameters']) !== 3) {
             throw new CompilerException(
-                'Tensor matrix quantile accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                'Tensor quantile accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
                 $expression
             );
         }
@@ -64,7 +64,7 @@ public function optimize(array $expression, Call $call, CompilationContext $cont
         $symbol = $context->backend->getVariableCode($symbolVariable);
 
         $context->codePrinter->output(
-            "tensor_matrix_quantile($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+            "tensor_quantile($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
         );
 
         return new CompiledExpression(
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index f92a58e..425e594 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -1647,7 +1647,7 @@ class Matrix implements Tensor
      */
     public function median() -> <ColumnVector>
     {
-        return new ColumnVector(tensor_matrix_median(this->a, this->n));
+        return new ColumnVector(tensor_median(this->a, this->n));
     }
 
     /**
@@ -1664,7 +1664,7 @@ class Matrix implements Tensor
                 . " 0 and 1, " . strval(q) . " given.");
         }
 
-        return new ColumnVector(tensor_matrix_quantile(this->a, this->n, q));
+        return new ColumnVector(tensor_quantile(this->a, this->n, q));
     }
 
     /**
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 578cfce..883813d 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -1226,21 +1226,14 @@ class Vector implements Tensor
      */
     public function median() -> float
     {
-        var median;
-
-        int mid = (int) intdiv(this->n, 2);
-
-        var a = this->a->toArray();
-
-        sort(a);
-
-        if this->n % 2 === 1 {
-            let median = a[mid];
-        } else {
-            let median = (a[mid - 1] + a[mid]) / 2.0;
+        if unlikely this->n < 1 {
+            throw new InvalidArgumentException("Cannot compute"
+                . " the median of an empty vector.");
         }
 
-        return median;
+        var result = tensor_median(this->a, this->n);
+
+        return (float) result->get(0);
     }
 
     /**
@@ -1257,23 +1250,14 @@ class Vector implements Tensor
                 . " between 0 and 1, " . strval(q) . " given.");
         }
 
-        var a = this->a->toArray();
-
-        sort(a);
-
-        float x = q * (this->n - 1) + 1;
-
-        int xHat = (int) x;
-
-        if xHat >= this->n {
-            return (float) a[this->n - 1];
+        if unlikely this->n < 1 {
+            throw new InvalidArgumentException("Cannot compute"
+                . " the quantile of an empty vector.");
         }
 
-        float remainder = x - xHat;
-
-        float t = (float) a[xHat - 1];
+        var result = tensor_quantile(this->a, this->n, q);
 
-        return t + remainder * (a[xHat] - t);
+        return (float) result->get(0);
     }
 
     /**
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index c899768..cf8b4c5 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -1861,6 +1861,18 @@ public function median() : void
         $this->assertEquals(30.0, $a->median());
     }
 
+    /**
+     * @test
+     */
+    public function medianEmptyVectorThrows() : void
+    {
+        $a = Vector::fromArray([], false);
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $a->median();
+    }
+
     /**
      * @test
      */
@@ -1879,6 +1891,18 @@ public function quantile() : void
         $this->assertEqualsWithDelta(5.0, $single->quantile(1.0), self::MAX_DELTA);
     }
 
+    /**
+     * @test
+     */
+    public function quantileEmptyVectorThrows() : void
+    {
+        $a = Vector::fromArray([], false);
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $a->quantile(0.5);
+    }
+
     /**
      * @test
      */

From d3dd4150dadd7d8adc059b112a5d87cc5547969b Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Thu, 24 Sep 2026 01:31:49 -0500
Subject: [PATCH 47/51] Optimize transpose

---
 AGENTS.md                                     |   2 +-
 config.json                                   |   1 +
 ext/config.m4                                 |   1 +
 ext/config.w32                                |   2 +-
 ext/include/shape.c                           |  73 ++++++
 ext/include/shape.h                           |   8 +
 ext/tensor/matrix.zep.c                       | 216 +++++++++---------
 ext/tensor/reductions/ref.zep.c               |   2 +-
 ext/tensor/reductions/rref.zep.c              |   2 +-
 ext/tensor/tensorbuffer.zep.c                 |   2 +-
 optimizers/TensorMatrixTransposeOptimizer.php |  76 ++++++
 tensor/matrix.zep                             |  12 +-
 12 files changed, 276 insertions(+), 121 deletions(-)
 create mode 100644 ext/include/shape.c
 create mode 100644 ext/include/shape.h
 create mode 100644 optimizers/TensorMatrixTransposeOptimizer.php

diff --git a/AGENTS.md b/AGENTS.md
index 5cdae9b..f15aab9 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -54,7 +54,7 @@ composer fix
   - New functionality ships with a matching unit test in `tests/`.
   - Bug fixes ship with a passing test that would have reproduced the bug beforehand.
   - Tests target public methods and cover edge cases / invalid input.
-- **Documentation & changelog:** update docs if behavior changes.
+- **Documentation:** update docs if behavior changes.
 - **PHPDoc:** classes use `@category` / `@package` / `@author` blocks; methods carry param and return annotations. Use `@var list<float>` for element arrays.
 - **Exceptions** are typed under `Tensor\Exceptions` (e.g. `InvalidArgumentException`, `DimensionalityMismatch`, `RuntimeException`). Use the existing ones rather than `Exception`.
 - **Math is float-only.** Values stored/computed as `float`; don't introduce integer-only branches. When adding a new operation, mirror it across the `Tensor` sub-interfaces (`Arithmetic`, `Comparable`, `Algebraic`, `Trigonometric`, `Statistical`, `Special`).
diff --git a/config.json b/config.json
index 95d66d9..054be19 100644
--- a/config.json
+++ b/config.json
@@ -13,6 +13,7 @@
         "include/buffer.c",
         "include/comparison.c",
         "include/reductions.c",
+        "include/shape.c",
         "include/unary.c",
         "include/linear_algebra.c",
         "include/signal_processing.c",
diff --git a/ext/config.m4 b/ext/config.m4
index cd7782b..e77b81a 100644
--- a/ext/config.m4
+++ b/ext/config.m4
@@ -36,6 +36,7 @@ if test "$PHP_TENSOR_EXT" = "yes"; then
 	include/buffer.c
 	include/comparison.c
 	include/reductions.c
+	include/shape.c
 	include/unary.c
 	include/linear_algebra.c
 	include/signal_processing.c
diff --git a/ext/config.w32 b/ext/config.w32
index 6aff90e..018e89d 100644
--- a/ext/config.w32
+++ b/ext/config.w32
@@ -9,7 +9,7 @@ if (PHP_TENSOR_EXT != "no") {
     ADD_EXTENSION_DEP("tensor_ext", "json");
     AC_DEFINE("ZEPHIR_USE_PHP_JSON", 1, "Whether PHP json extension is present at compile time");
   }
-  ADD_SOURCES(configure_module_dirname + "/include", "arithmetic.c buffer.c comparison.c reductions.c unary.c linear_algebra.c signal_processing.c settings.c", "tensor_ext");
+  ADD_SOURCES(configure_module_dirname + "/include", "arithmetic.c buffer.c comparison.c reductions.c shape.c unary.c linear_algebra.c signal_processing.c settings.c", "tensor_ext");
   ADD_SOURCES(configure_module_dirname + "/tensor", "algebraic.zep.c arithmetic.zep.c arraylike.zep.c comparable.zep.c special.zep.c statistical.zep.c trigonometric.zep.c tensor.zep.c vector.zep.c columnvector.zep.c matrix.zep.c settings.zep.c tensorbuffer.zep.c", "tensor_ext");
 	ADD_SOURCES(configure_module_dirname + "/tensor/exceptions", "tensorexception.zep.c invalidargumentexception.zep.c runtimeexception.zep.c dimensionalitymismatch.zep.c singularmatrix.zep.c", "tensor_ext");
 	ADD_SOURCES(configure_module_dirname + "/tensor/decompositions", "cholesky.zep.c eigen.zep.c lu.zep.c svd.zep.c", "tensor_ext");
diff --git a/ext/include/shape.c b/ext/include/shape.c
new file mode 100644
index 0000000..f16fac6
--- /dev/null
+++ b/ext/include/shape.c
@@ -0,0 +1,73 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <php.h>
+#include <stdlib.h>
+#include <ext/spl/spl_exceptions.h>
+#include "kernel/main.h"
+#include "php_ext.h"
+#include "kernel/buffer.h"
+#include "kernel/exception.h"
+#include "kernel/operators.h"
+#include "include/buffer.h"
+
+/**
+ * Return the transpose of the matrix as a new matrix buffer, i.e. row i of the
+ * output holds column i of the input. Eliminates the strided per-column slices
+ * and concatenation used by the previous pure-Zephir path.
+ *
+ * @param return_value
+ * @param a
+ * @param m
+ * @param n
+ */
+void tensor_matrix_transpose(zval * return_value, zval * a, zval * m, zval * n)
+{
+	zend_long total = 0;
+	int ok = 0;
+
+	double * va = tensor_tensorbuffer_doubles(a, &total, &ok);
+
+	if (UNEXPECTED(!ok)) {
+		return;
+	}
+
+	zend_long ma = zephir_get_intval(m);
+	zend_long na = zephir_get_intval(n);
+
+	if (UNEXPECTED(ma < 0 || na < 0)) {
+		zephir_throw_exception_string(spl_ce_InvalidArgumentException,
+			SL("Dimensions must be non-negative."));
+		return;
+	}
+
+	if (UNEXPECTED(total != ma * na)) {
+		zephir_throw_exception_string(spl_ce_LengthException,
+			SL("Input buffer must match the given dimensions."));
+		return;
+	}
+
+	zval c;
+
+	if (UNEXPECTED(tensor_tensorbuffer_create(return_value, total, &c) == FAILURE)) {
+		return;
+	}
+
+	double * vc = zephir_buffer_doubles(&c);
+
+	if (total > 0) {
+		zend_long i, j;
+
+		for (i = 0; i < ma; ++i) {
+			const double * src = va + i * na;
+			double * dst = vc + i;
+
+			for (j = 0; j < na; ++j) {
+				dst[j * ma] = src[j];
+			}
+		}
+	}
+
+	zval_ptr_dtor(&c);
+}
\ No newline at end of file
diff --git a/ext/include/shape.h b/ext/include/shape.h
new file mode 100644
index 0000000..268673a
--- /dev/null
+++ b/ext/include/shape.h
@@ -0,0 +1,8 @@
+#ifndef TENSOR_SHAPE_H
+#define TENSOR_SHAPE_H
+
+#include <Zend/zend.h>
+
+void tensor_matrix_transpose(zval * return_value, zval * a, zval * m, zval * n);
+
+#endif
\ No newline at end of file
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index caff54f..4dee235 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -25,6 +25,7 @@
 #include "ext/spl/spl_array.h"
 #include "include/buffer.h"
 #include "include/reductions.h"
+#include "include/shape.h"
 #include "include/linear_algebra.h"
 #include "include/signal_processing.h"
 #include "include/unary.h"
@@ -1946,52 +1947,53 @@ PHP_METHOD(Tensor_Matrix, reduce)
  */
 PHP_METHOD(Tensor_Matrix, transpose)
 {
-	zval col, cols, _2, _3, _4, _5, _0$$3, _1$$3;
+	zval _0, result, _3, _4, _5, _6, _7, _1$$3, _2$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
 	zval *this_ptr = getThis();
 
-	ZVAL_UNDEF(&col);
-	ZVAL_UNDEF(&cols);
-	ZVAL_UNDEF(&_2);
+	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_3);
 	ZVAL_UNDEF(&_4);
 	ZVAL_UNDEF(&_5);
-	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
 	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
 	static zend_string *_zephir_prop_0 = NULL;
 	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
 	if (UNEXPECTED(!_zephir_prop_1)) {
-		_zephir_prop_1 = zend_string_init("m", 1, 1);
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
 	}
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 
-	ZEPHIR_CALL_METHOD(&cols, this_ptr, "asColumnBuffers", NULL, 0);
-	zephir_check_call_status();
-	if (UNEXPECTED(zephir_fast_count_int(&cols) < 1)) {
-		ZEPHIR_INIT_VAR(&_0$$3);
-		array_init(&_0$$3);
-		ZVAL_BOOL(&_1$$3, 0);
-		ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &_0$$3, &_1$$3);
+	zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	if (UNEXPECTED(ZEPHIR_LT_LONG(&_0, 1))) {
+		ZEPHIR_INIT_VAR(&_1$$3);
+		array_init(&_1$$3);
+		ZVAL_BOOL(&_2$$3, 0);
+		ZEPHIR_RETURN_CALL_SELF("fromArray", NULL, 0, &_1$$3, &_2$$3);
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	zephir_memory_observe(&col);
-	zephir_array_fetch_long(&col, &cols, 0, PH_NOISY, "tensor/matrix.zep", 713);
-	ZVAL_LONG(&_3, 1);
-	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 25, &cols, &_3);
-	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_2, &col, "concat", NULL, 0, &_4);
-	zephir_check_call_status();
-	ZEPHIR_CPY_WRT(&col, &_2);
+	ZEPHIR_INIT_VAR(&result);
+	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_matrix_transpose(&result, &_3, &_4, &_5);
 	object_init_ex(return_value, tensor_matrix_ce);
-	zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
-	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 15, PH_NOISY_CC | PH_READONLY);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &col, &_3, &_5);
+	zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_6, &_7);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -2046,7 +2048,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 730);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 724);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2057,9 +2059,9 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_5$$4, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_6$$4);
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 26, &_6$$4);
+		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 25, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 735);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 729);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2072,9 +2074,9 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		object_init_ex(&_9$$5, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_10$$5);
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 26, &_10$$5);
+		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 25, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 742);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 736);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2132,9 +2134,9 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		object_init_ex(&_3$$3, tensor_exceptions_runtimeexception_ce);
 		ZEPHIR_INIT_VAR(&_4$$3);
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
-		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 26, &_4$$3);
+		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 25, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 759);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 753);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2184,7 +2186,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 775);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 769);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2284,7 +2286,7 @@ PHP_METHOD(Tensor_Matrix, fullRank)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_1, this_ptr, "shape", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 27, &_1);
+	ZEPHIR_CALL_FUNCTION(&_2, "min", NULL, 26, &_1);
 	zephir_check_call_status();
 	RETURN_MM_BOOL(ZEPHIR_IS_IDENTICAL(&_0, &_2));
 }
@@ -2393,7 +2395,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 843);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 837);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2468,7 +2470,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 863);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 857);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2566,7 +2568,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 2, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 881);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 875);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2580,7 +2582,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 2, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 886);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 880);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2598,13 +2600,13 @@ PHP_METHOD(Tensor_Matrix, convolve)
 	zephir_read_property_cached(&_18, this_ptr, _zephir_prop_0, 15, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_19, ((zephir_get_numberval(&_18) + stride) - 1));
 	ZVAL_LONG(&_20, stride);
-	ZEPHIR_CALL_FUNCTION(&_21, "intdiv", NULL, 28, &_19, &_20);
+	ZEPHIR_CALL_FUNCTION(&_21, "intdiv", NULL, 27, &_19, &_20);
 	zephir_check_call_status();
 	outM = zephir_get_intval(&_21);
 	zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 16, PH_NOISY_CC | PH_READONLY);
 	ZVAL_LONG(&_20, ((zephir_get_numberval(&_19) + stride) - 1));
 	ZVAL_LONG(&_22, stride);
-	ZEPHIR_CALL_FUNCTION(&_23, "intdiv", NULL, 28, &_20, &_22);
+	ZEPHIR_CALL_FUNCTION(&_23, "intdiv", NULL, 27, &_20, &_22);
 	zephir_check_call_status();
 	outN = zephir_get_intval(&_23);
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -2917,7 +2919,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1030);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1024);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2988,7 +2990,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1063);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1057);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3060,7 +3062,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1097);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1091);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3132,7 +3134,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1131);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1125);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3204,7 +3206,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1165);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1159);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3276,7 +3278,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1199);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1193);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3348,7 +3350,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1233);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1227);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3420,7 +3422,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1267);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1261);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3492,7 +3494,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1301);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1295);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3564,7 +3566,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1335);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1329);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3636,7 +3638,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1369);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1363);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3708,7 +3710,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1403);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1397);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4754,7 +4756,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1664);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1658);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4835,7 +4837,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1683);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1677);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -4855,7 +4857,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 2, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1689);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1683);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -4944,7 +4946,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 2, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1714);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1708);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5020,7 +5022,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1735);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1729);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5175,7 +5177,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1774);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1768);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5452,7 +5454,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1840);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1834);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5550,7 +5552,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1860);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1854);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5660,7 +5662,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1880);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1874);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5703,7 +5705,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1894);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1888);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -5806,7 +5808,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1912);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1906);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5849,7 +5851,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1926);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1920);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -5935,7 +5937,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		ZEPHIR_CONCAT_SS(&_4$$4, "Chunk length must be", " greater than 0, 0 given.");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 2, &_4$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$4, "tensor/matrix.zep", 1948);
+		zephir_throw_exception_debug(&_3$$4, "tensor/matrix.zep", 1942);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6024,7 +6026,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1971);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1965);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6100,7 +6102,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1990);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1984);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6176,7 +6178,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2009);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2003);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6252,7 +6254,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2028);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2022);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6329,7 +6331,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2048);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2042);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6406,7 +6408,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2068);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2062);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6483,7 +6485,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2088);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2082);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6559,7 +6561,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2107);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2101);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6636,7 +6638,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2127);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2121);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6713,7 +6715,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2147);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2141);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6789,7 +6791,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2166);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2160);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6865,7 +6867,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2185);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2179);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6946,7 +6948,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2205);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2199);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7029,7 +7031,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2229);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2223);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7112,7 +7114,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2253);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2247);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7195,7 +7197,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2277);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2271);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7278,7 +7280,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2301);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2295);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7361,7 +7363,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2325);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2319);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7445,7 +7447,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2350);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2344);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7528,7 +7530,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2374);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2368);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7611,7 +7613,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2398);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2392);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7694,7 +7696,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2422);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2416);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7777,7 +7779,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2446);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2440);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7861,7 +7863,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2471);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2465);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7944,7 +7946,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2495);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2489);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8027,7 +8029,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2519);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2513);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8110,7 +8112,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2543);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2537);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8193,7 +8195,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2567);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2561);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8276,7 +8278,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2591);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2585);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8359,7 +8361,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2615);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2609);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8442,7 +8444,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2639);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2633);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8525,7 +8527,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2663);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2657);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8608,7 +8610,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2687);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2681);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8691,7 +8693,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2711);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2705);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8774,7 +8776,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2735);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2729);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8857,7 +8859,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2759);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2753);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9521,7 +9523,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2944);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2938);
 	return;
 }
 
@@ -9572,7 +9574,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2968);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2962);
 	return;
 }
 
@@ -9632,7 +9634,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 2982);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 2976);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9649,7 +9651,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 2987);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 2981);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9772,16 +9774,16 @@ PHP_METHOD(Tensor_Matrix, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3030);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3024);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_2, &rebuilt, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_2);
-	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3033);
+	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3027);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_3);
-	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3034);
+	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3028);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_4);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/ext/tensor/reductions/ref.zep.c b/ext/tensor/reductions/ref.zep.c
index ba4fdb3..533e871 100644
--- a/ext/tensor/reductions/ref.zep.c
+++ b/ext/tensor/reductions/ref.zep.c
@@ -115,7 +115,7 @@ PHP_METHOD(Tensor_Reductions_Ref, reduce)
 	swaps = zephir_get_intval(&_8);
 	object_init_ex(return_value, tensor_reductions_ref_ce);
 	ZVAL_LONG(&_9, swaps);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 29, &b, &_9);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 28, &b, &_9);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/reductions/rref.zep.c b/ext/tensor/reductions/rref.zep.c
index edd602e..80bc6ff 100644
--- a/ext/tensor/reductions/rref.zep.c
+++ b/ext/tensor/reductions/rref.zep.c
@@ -88,7 +88,7 @@ PHP_METHOD(Tensor_Reductions_Rref, reduce)
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 14, &result, &_4, &_5);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 30, &_3);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 29, &_3);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/tensorbuffer.zep.c b/ext/tensor/tensorbuffer.zep.c
index b7b7181..83d9887 100644
--- a/ext/tensor/tensorbuffer.zep.c
+++ b/ext/tensor/tensorbuffer.zep.c
@@ -91,7 +91,7 @@ PHP_METHOD(Tensor_TensorBuffer, fromBuffers)
 	zephir_memory_observe(&_2);
 	zephir_array_fetch_long(&_2, &buffers, 0, PH_NOISY, "tensor/tensorbuffer.zep", 46);
 	ZVAL_LONG(&_3, 1);
-	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 25, &buffers, &_3);
+	ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 30, &buffers, &_3);
 	zephir_check_call_status();
 	ZEPHIR_RETURN_CALL_METHOD(&_2, "concat", NULL, 0, &_4);
 	zephir_check_call_status();
diff --git a/optimizers/TensorMatrixTransposeOptimizer.php b/optimizers/TensorMatrixTransposeOptimizer.php
new file mode 100644
index 0000000..86a962c
--- /dev/null
+++ b/optimizers/TensorMatrixTransposeOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixTransposeOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor matrix transpose accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/shape',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_transpose($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 425e594..abd1018 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -702,19 +702,13 @@ class Matrix implements Tensor
      */
     public function transpose() -> <Matrix>
     {
-        var col;
-
-        var cols = this->asColumnBuffers();
-
-        if unlikely count(cols) < 1 {
+        if unlikely this->n < 1 {
             return self::fromArray([], false);
         }
 
-        let col = cols[0];
+        var result = tensor_matrix_transpose(this->a, this->m, this->n);
 
-        let col = col->concat(array_slice(cols, 1));
-
-        return new self(col, this->n, this->m);
+        return new self(result, this->n, this->m);
     }
 
     /**

From 0ed244974b172a3185732dec006656881644e93f Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Thu, 24 Sep 2026 01:52:07 -0500
Subject: [PATCH 48/51] More optimizations

---
 benchmarks/LinearAlgebra/MatrixDotBench.php |  41 +++
 ext/include/linear_algebra.c                |  42 +++
 ext/include/linear_algebra.h                |   1 +
 ext/tensor/columnvector.zep.c               |  76 ++++-
 ext/tensor/matrix.zep.c                     |  27 +-
 ext/tensor/vector.zep.c                     | 308 +++++++++++---------
 optimizers/TensorMatrixDotOptimizer.php     |  76 +++++
 tensor/columnvector.zep                     |   9 +-
 tensor/matrix.zep                           |   2 +-
 tensor/vector.zep                           |  72 ++---
 10 files changed, 446 insertions(+), 208 deletions(-)
 create mode 100644 benchmarks/LinearAlgebra/MatrixDotBench.php
 create mode 100644 optimizers/TensorMatrixDotOptimizer.php

diff --git a/benchmarks/LinearAlgebra/MatrixDotBench.php b/benchmarks/LinearAlgebra/MatrixDotBench.php
new file mode 100644
index 0000000..3507831
--- /dev/null
+++ b/benchmarks/LinearAlgebra/MatrixDotBench.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace Tensor\Benchmarks\LinearAlgebra;
+
+use Tensor\Matrix;
+use Tensor\Vector;
+
+/**
+ * @Groups({"LinearAlgebra"})
+ * @BeforeMethods({"setUp"})
+ */
+class MatrixDotBench
+{
+    /**
+     * @var Matrix
+     */
+    protected $a;
+
+    /**
+     * @var Vector
+     */
+    protected $b;
+
+    public function setUp() : void
+    {
+        $this->a = Matrix::uniform(1000, 1000);
+
+        $this->b = Vector::uniform(1000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @Revs(100)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function dot() : void
+    {
+        $this->a->dot($this->b);
+    }
+}
diff --git a/ext/include/linear_algebra.c b/ext/include/linear_algebra.c
index c150a2c..d9ff24c 100644
--- a/ext/include/linear_algebra.c
+++ b/ext/include/linear_algebra.c
@@ -57,6 +57,48 @@ void tensor_matmul(zval * return_value, zval * a, zval * b, zval * m, zval * p,
     zval_ptr_dtor(&c);
 }
 
+/**
+ * Matrix-vector product i.e. the dot product of matrix A and vector B.
+ *
+ * @param return_value
+ * @param a
+ * @param b
+ * @param m
+ * @param p
+ */
+void tensor_matrix_dot(zval * return_value, zval * a, zval * b, zval * m, zval * p)
+{
+    zend_long ma = zephir_get_intval(m);
+    zend_long pc = zephir_get_intval(p);
+    zend_long na = 0, nb = 0;
+    int ok_a = 0, ok_b = 0;
+
+    double * va = tensor_tensorbuffer_doubles(a, &na, &ok_a);
+    double * vb = tensor_tensorbuffer_doubles(b, &nb, &ok_b);
+
+    if (UNEXPECTED(!ok_a || !ok_b)) {
+        return;
+    }
+
+    if (UNEXPECTED(na != ma * pc || nb != pc)) {
+        zephir_throw_exception_string(spl_ce_LengthException,
+            SL("Input buffers must match the given dimensions."));
+        return;
+    }
+
+    zval c;
+
+    if (UNEXPECTED(tensor_tensorbuffer_create(return_value, ma, &c) == FAILURE)) {
+        return;
+    }
+
+    double * vc = zephir_buffer_doubles(&c);
+
+    cblas_dgemv(CblasRowMajor, CblasNoTrans, (blasint) ma, (blasint) pc, 1.0, va, (blasint) pc, vb, 1, 0.0, vc, 1);
+
+    zval_ptr_dtor(&c);
+}
+
 /**
  * Dot product between vectors A and B.
  * 
diff --git a/ext/include/linear_algebra.h b/ext/include/linear_algebra.h
index 4f98775..143b233 100644
--- a/ext/include/linear_algebra.h
+++ b/ext/include/linear_algebra.h
@@ -4,6 +4,7 @@
 #include <Zend/zend.h>
 
 void tensor_matmul(zval * return_value, zval * a, zval * b, zval * m, zval * p, zval * n);
+void tensor_matrix_dot(zval * return_value, zval * a, zval * b, zval * m, zval * p);
 void tensor_dot(zval * return_value, zval * a, zval * b);
 
 void tensor_inverse(zval * return_value, zval * a, zval * n);
diff --git a/ext/tensor/columnvector.zep.c b/ext/tensor/columnvector.zep.c
index 511f8db..985535e 100644
--- a/ext/tensor/columnvector.zep.c
+++ b/ext/tensor/columnvector.zep.c
@@ -18,6 +18,7 @@
 #include "kernel/operators.h"
 #include "kernel/exception.h"
 #include "kernel/concat.h"
+#include "include/linear_algebra.h"
 #include "include/arithmetic.h"
 #include "include/comparison.h"
 
@@ -95,22 +96,67 @@ PHP_METHOD(Tensor_ColumnVector, transpose)
  */
 PHP_METHOD(Tensor_ColumnVector, matmul)
 {
+	zval _3$$3, _4$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0;
+	zval *b, b_sub, _0, product, _5, _6, _7, _8, _9, _10, _1$$3, _2$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
+	ZVAL_UNDEF(&product);
+	ZVAL_UNDEF(&_5);
+	ZVAL_UNDEF(&_6);
+	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_8);
+	ZVAL_UNDEF(&_9);
+	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_1$$3);
+	ZVAL_UNDEF(&_2$$3);
+	ZVAL_UNDEF(&_3$$3);
+	ZVAL_UNDEF(&_4$$3);
+	static zend_string *_zephir_prop_0 = NULL;
+	if (UNEXPECTED(!_zephir_prop_0)) {
+		_zephir_prop_0 = zend_string_init("a", 1, 1);
+	}
+
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
 	ZEND_PARSE_PARAMETERS_END();
 	ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0);
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &b);
-	ZEPHIR_CALL_METHOD(&_0, this_ptr, "asColumnMatrix", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_0, b, "m", NULL, 0);
+	zephir_check_call_status();
+	if (UNEXPECTED(!ZEPHIR_IS_LONG_IDENTICAL(&_0, 1))) {
+		ZEPHIR_INIT_VAR(&_1$$3);
+		object_init_ex(&_1$$3, tensor_exceptions_dimensionalitymismatch_ce);
+		ZEPHIR_CALL_METHOD(&_2$$3, b, "m", NULL, 0);
+		zephir_check_call_status();
+		zephir_cast_to_string(&_3$$3, &_2$$3);
+		ZEPHIR_INIT_VAR(&_4$$3);
+		ZEPHIR_CONCAT_SSVS(&_4$$3, "Matrix A requires", " 1 rows but Matrix B has ", &_3$$3, ".");
+		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
+		zephir_check_call_status();
+		zephir_throw_exception_debug(&_1$$3, "tensor/columnvector.zep", 57);
+		ZEPHIR_MM_RESTORE();
+		return;
+	}
+	ZEPHIR_INIT_VAR(&product);
+	zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 3, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_6, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_7, this_ptr, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_8, b, "n", NULL, 0);
+	zephir_check_call_status();
+	tensor_outer(&product, &_5, &_6, &_7, &_8);
+	object_init_ex(return_value, tensor_matrix_ce);
+	ZEPHIR_CALL_METHOD(&_9, this_ptr, "m", NULL, 0);
+	zephir_check_call_status();
+	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_RETURN_CALL_METHOD(&_0, "matmul", NULL, 0, b);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &product, &_9, &_10);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -176,7 +222,7 @@ PHP_METHOD(Tensor_ColumnVector, multiplyMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 70);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 77);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -258,7 +304,7 @@ PHP_METHOD(Tensor_ColumnVector, divideMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 94);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 101);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -340,7 +386,7 @@ PHP_METHOD(Tensor_ColumnVector, addMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 118);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 125);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -422,7 +468,7 @@ PHP_METHOD(Tensor_ColumnVector, subtractMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 142);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 149);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -504,7 +550,7 @@ PHP_METHOD(Tensor_ColumnVector, powMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 166);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 173);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -586,7 +632,7 @@ PHP_METHOD(Tensor_ColumnVector, modMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 190);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 197);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -668,7 +714,7 @@ PHP_METHOD(Tensor_ColumnVector, equalMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 214);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 221);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -750,7 +796,7 @@ PHP_METHOD(Tensor_ColumnVector, notEqualMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 238);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 245);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -832,7 +878,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 262);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 269);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -914,7 +960,7 @@ PHP_METHOD(Tensor_ColumnVector, greaterEqualMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 286);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 293);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -996,7 +1042,7 @@ PHP_METHOD(Tensor_ColumnVector, lessMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 310);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 317);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1078,7 +1124,7 @@ PHP_METHOD(Tensor_ColumnVector, lessEqualMatrix)
 		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, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 334);
+		zephir_throw_exception_debug(&_2$$3, "tensor/columnvector.zep", 341);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 4dee235..3f79adb 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -2428,7 +2428,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, _8, _9, _10, _11, _12, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
@@ -2437,6 +2437,8 @@ PHP_METHOD(Tensor_Matrix, dot)
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
+	ZVAL_UNDEF(&_12);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -2444,9 +2446,17 @@ PHP_METHOD(Tensor_Matrix, dot)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
+	static zend_string *_zephir_prop_2 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
+	if (UNEXPECTED(!_zephir_prop_2)) {
+		_zephir_prop_2 = zend_string_init("m", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\vector")))
@@ -2474,12 +2484,15 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&_9, b, "asColumnMatrix", NULL, 0);
-	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_8, this_ptr, "matmul", NULL, 0, &_9);
-	zephir_check_call_status();
-	ZVAL_LONG(&_10, 0);
-	ZEPHIR_RETURN_CALL_METHOD(&_8, "columnAsVector", NULL, 0, &_10);
+	object_init_ex(return_value, tensor_columnvector_ce);
+	ZEPHIR_INIT_VAR(&_8);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 14, PH_NOISY_CC | PH_READONLY);
+	ZEPHIR_CALL_METHOD(&_10, b, "asTensorBuffer", NULL, 0);
+	zephir_check_call_status();
+	zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 15, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_12, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
+	tensor_matrix_dot(&_8, &_9, &_10, &_11, &_12);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &_8);
 	zephir_check_call_status();
 	RETURN_MM();
 }
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 21a835f..1cf248d 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -3806,18 +3806,18 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -3825,9 +3825,13 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -3855,19 +3859,18 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_multiply_row(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_multiply_row(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3884,18 +3887,18 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -3903,9 +3906,13 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -3929,23 +3936,22 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1424);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1422);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_divide_row_reverse(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_divide_row_reverse(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -3962,18 +3968,18 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -3981,9 +3987,13 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4007,23 +4017,22 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1450);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1446);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_add_row(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_add_row(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4040,18 +4049,18 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4059,9 +4068,13 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4085,23 +4098,22 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1476);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1470);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_subtract_row_reverse(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_subtract_row_reverse(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4118,18 +4130,18 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4137,9 +4149,13 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4163,23 +4179,22 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1502);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1494);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_pow_row_reverse(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_pow_row_reverse(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4196,18 +4211,18 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4215,9 +4230,13 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4241,23 +4260,22 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1528);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1518);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_mod_row_reverse(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_mod_row_reverse(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4274,18 +4292,18 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4293,9 +4311,13 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4319,23 +4341,22 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1554);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1542);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_equal_row(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_equal_row(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4352,18 +4373,18 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4371,9 +4392,13 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4397,23 +4422,22 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1580);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1566);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_not_equal_row(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_not_equal_row(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4430,18 +4454,18 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4449,9 +4473,13 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4475,23 +4503,22 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1606);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1590);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_greater_row_reverse(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_greater_row_reverse(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4508,18 +4535,18 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4527,9 +4554,13 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4553,23 +4584,22 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1632);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1614);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_greater_equal_row_reverse(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_greater_equal_row_reverse(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4586,18 +4616,18 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4605,9 +4635,13 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4631,23 +4665,22 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1658);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1638);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_less_row_reverse(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_less_row_reverse(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4664,18 +4697,18 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	zval _4$$3, _6$$3, _7$$3;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zval *b, b_sub, _0, _1, aHat, bHat, result, _8, _9, _10, _2$$3, _3$$3, _5$$3;
+	zval *b, b_sub, _0, _1, bHat, result, _8, _9, _10, _11, _2$$3, _3$$3, _5$$3;
 	zval *this_ptr = getThis();
 
 	ZVAL_UNDEF(&b_sub);
 	ZVAL_UNDEF(&_0);
 	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&aHat);
 	ZVAL_UNDEF(&bHat);
 	ZVAL_UNDEF(&result);
 	ZVAL_UNDEF(&_8);
 	ZVAL_UNDEF(&_9);
 	ZVAL_UNDEF(&_10);
+	ZVAL_UNDEF(&_11);
 	ZVAL_UNDEF(&_2$$3);
 	ZVAL_UNDEF(&_3$$3);
 	ZVAL_UNDEF(&_5$$3);
@@ -4683,9 +4716,13 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 	ZVAL_UNDEF(&_6$$3);
 	ZVAL_UNDEF(&_7$$3);
 	static zend_string *_zephir_prop_0 = NULL;
+	static zend_string *_zephir_prop_1 = NULL;
 	if (UNEXPECTED(!_zephir_prop_0)) {
 		_zephir_prop_0 = zend_string_init("n", 1, 1);
 	}
+	if (UNEXPECTED(!_zephir_prop_1)) {
+		_zephir_prop_1 = zend_string_init("a", 1, 1);
+	}
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
 		Z_PARAM_OBJECT_OF_CLASS(b, zephir_get_internal_ce(SL("tensor\\matrix")))
@@ -4709,23 +4746,22 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1684);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1662);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
-	ZEPHIR_CALL_METHOD(&aHat, this_ptr, "asTensorBuffer", NULL, 0);
-	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&bHat, b, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	ZEPHIR_INIT_VAR(&result);
-	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
-	tensor_less_equal_row_reverse(&result, &bHat, &aHat, &_8);
+	zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1, PH_NOISY_CC | PH_READONLY);
+	zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 2, PH_NOISY_CC | PH_READONLY);
+	tensor_less_equal_row_reverse(&result, &bHat, &_8, &_9);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZEPHIR_CALL_METHOD(&_9, b, "m", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_10, b, "m", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(&_10, b, "n", NULL, 0);
+	ZEPHIR_CALL_METHOD(&_11, b, "n", NULL, 0);
 	zephir_check_call_status();
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_9, &_10);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &result, &_10, &_11);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -4788,7 +4824,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1710);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1686);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4860,7 +4896,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1728);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1704);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4932,7 +4968,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1746);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1722);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5004,7 +5040,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1764);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1740);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5076,7 +5112,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1782);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1758);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5148,7 +5184,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1800);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1776);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5221,7 +5257,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1819);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1795);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5293,7 +5329,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1837);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1813);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5365,7 +5401,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1855);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1831);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5437,7 +5473,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1873);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1849);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5509,7 +5545,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1891);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1867);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5581,7 +5617,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1909);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1885);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6092,7 +6128,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2066);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2042);
 	return;
 }
 
@@ -6143,7 +6179,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2090);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2066);
 	return;
 }
 
@@ -6201,7 +6237,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2104);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2080);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6309,13 +6345,13 @@ PHP_METHOD(Tensor_Vector, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2145);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2121);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, &_1);
-	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2148);
+	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2124);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_2);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/optimizers/TensorMatrixDotOptimizer.php b/optimizers/TensorMatrixDotOptimizer.php
new file mode 100644
index 0000000..9d1ca25
--- /dev/null
+++ b/optimizers/TensorMatrixDotOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixDotOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 4) {
+            throw new CompilerException(
+                'MatrixDot accepts exactly four arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/linear_algebra',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_dot($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]}, {$resolvedParams[3]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/tensor/columnvector.zep b/tensor/columnvector.zep
index abfea12..27606aa 100644
--- a/tensor/columnvector.zep
+++ b/tensor/columnvector.zep
@@ -52,7 +52,14 @@ class ColumnVector extends Vector
      */
     public function matmul(const <Matrix> b) -> <Matrix>
     {
-        return this->asColumnMatrix()->matmul(b);
+        if unlikely b->m() !== 1 {
+            throw new DimensionalityMismatch("Matrix A requires"
+                . " 1 rows but Matrix B has " . (string) b->m() . ".");
+        }
+
+        var product = tensor_outer(this->a, b->asTensorBuffer(), this->m(), b->n());
+
+        return new Matrix(product, this->m(), b->n());
     }
 
     /**
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index abd1018..7a570cc 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -857,7 +857,7 @@ class Matrix implements Tensor
                 . (string) b->size() . ".");
         }
 
-        return this->matmul(b->asColumnMatrix())->columnAsVector(0);
+        return new ColumnVector(tensor_matrix_dot(this->a, b->asTensorBuffer(), this->m, this->n));
     }
 
     /**
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 883813d..9a9269a 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -1398,13 +1398,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_multiply_row(bHat, aHat, this->n);
+        let result = tensor_multiply_row(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1424,13 +1422,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_divide_row_reverse(bHat, aHat, this->n);
+        let result = tensor_divide_row_reverse(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1450,13 +1446,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_add_row(bHat, aHat, this->n);
+        let result = tensor_add_row(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1476,13 +1470,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_subtract_row_reverse(bHat, aHat, this->n);
+        let result = tensor_subtract_row_reverse(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1502,13 +1494,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_pow_row_reverse(bHat, aHat, this->n);
+        let result = tensor_pow_row_reverse(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1528,13 +1518,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_mod_row_reverse(bHat, aHat, this->n);
+        let result = tensor_mod_row_reverse(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1554,13 +1542,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_equal_row(bHat, aHat, this->n);
+        let result = tensor_equal_row(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1580,13 +1566,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_not_equal_row(bHat, aHat, this->n);
+        let result = tensor_not_equal_row(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1606,13 +1590,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_greater_row_reverse(bHat, aHat, this->n);
+        let result = tensor_greater_row_reverse(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1632,13 +1614,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_greater_equal_row_reverse(bHat, aHat, this->n);
+        let result = tensor_greater_equal_row_reverse(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1658,13 +1638,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_less_row_reverse(bHat, aHat, this->n);
+        let result = tensor_less_row_reverse(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }
@@ -1684,13 +1662,11 @@ class Vector implements Tensor
                 . (string) b->n() . ".");
         }
 
-        var aHat, bHat, result;
-
-        let aHat = this->asTensorBuffer();
+        var bHat, result;
 
         let bHat = b->asTensorBuffer();
 
-        let result = tensor_less_equal_row_reverse(bHat, aHat, this->n);
+        let result = tensor_less_equal_row_reverse(bHat, this->a, this->n);
 
         return new Matrix(result, b->m(), b->n());
     }

From 8b1b1c3e07e39d851ba1e67f4bc21abd605b6585 Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Thu, 24 Sep 2026 02:03:54 -0500
Subject: [PATCH 49/51] Fix typo

---
 ext/include/unary.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ext/include/unary.c b/ext/include/unary.c
index 99a6871..1af9709 100644
--- a/ext/include/unary.c
+++ b/ext/include/unary.c
@@ -59,7 +59,7 @@ TENSOR_UNARY(cos, cos(va[i]))
 TENSOR_UNARY(acos, acos(va[i]))
 TENSOR_UNARY(tan, tan(va[i]))
 TENSOR_UNARY(atan, atan(va[i]))
-TENSOR_UNARY(rad2deg, (va[i] / M_PI) * 180)
+TENSOR_UNARY(rad2deg, (va[i] / M_PI) * 180.0)
 TENSOR_UNARY(deg2rad, (va[i] / 180.0) * M_PI)
 TENSOR_UNARY(floor, floor(va[i]))
 TENSOR_UNARY(ceil, ceil(va[i]))

From 1b499f60a80395d0cd1c7c726d6f42160178597f Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Thu, 24 Sep 2026 16:40:25 -0500
Subject: [PATCH 50/51] Save game

---
 CHANGELOG.md                                  |   1 +
 benchmarks/Statistical/VectorPNormBench.php   |  52 ++
 .../Structural/MatrixFromArrayBench.php       |  54 ++
 .../Structural/VectorFromArrayBench.php       |  48 ++
 ext/tensor/matrix.zep.c                       | 517 +++++++++++-------
 ext/tensor/vector.zep.c                       | 251 ++++-----
 optimizers/TensorCovarianceOptimizer.php      |  76 +++
 .../TensorCovarianceWithMeanOptimizer.php     |  76 +++
 optimizers/TensorInfNormOptimizer.php         |  76 +++
 optimizers/TensorMatL1NormOptimizer.php       |  76 +++
 optimizers/TensorMatL2NormOptimizer.php       |  76 +++
 optimizers/TensorMatMaxNormOptimizer.php      |  76 +++
 optimizers/TensorMatrixMeanOptimizer.php      |  76 +++
 optimizers/TensorMatrixVarianceOptimizer.php  |  76 +++
 .../TensorMatrixVarianceWithMeanOptimizer.php |  76 +++
 optimizers/TensorPNormOptimizer.php           |  76 +++
 optimizers/TensorReciprocalOptimizer.php      |  76 +++
 optimizers/TensorVecL1NormOptimizer.php       |  76 +++
 optimizers/TensorVecL2NormOptimizer.php       |  76 +++
 optimizers/TensorVecMaxNormOptimizer.php      |  76 +++
 optimizers/TensorVecMeanOptimizer.php         |  76 +++
 optimizers/TensorVecVarianceOptimizer.php     |  76 +++
 .../TensorVecVarianceWithMeanOptimizer.php    |  76 +++
 tensor/matrix.zep                             |  49 +-
 tensor/vector.zep                             |  18 +-
 tests/MatrixTest.php                          |  40 ++
 tests/VectorTest.php                          |  33 ++
 27 files changed, 1988 insertions(+), 367 deletions(-)
 create mode 100644 benchmarks/Statistical/VectorPNormBench.php
 create mode 100644 benchmarks/Structural/MatrixFromArrayBench.php
 create mode 100644 benchmarks/Structural/VectorFromArrayBench.php
 create mode 100644 optimizers/TensorCovarianceOptimizer.php
 create mode 100644 optimizers/TensorCovarianceWithMeanOptimizer.php
 create mode 100644 optimizers/TensorInfNormOptimizer.php
 create mode 100644 optimizers/TensorMatL1NormOptimizer.php
 create mode 100644 optimizers/TensorMatL2NormOptimizer.php
 create mode 100644 optimizers/TensorMatMaxNormOptimizer.php
 create mode 100644 optimizers/TensorMatrixMeanOptimizer.php
 create mode 100644 optimizers/TensorMatrixVarianceOptimizer.php
 create mode 100644 optimizers/TensorMatrixVarianceWithMeanOptimizer.php
 create mode 100644 optimizers/TensorPNormOptimizer.php
 create mode 100644 optimizers/TensorReciprocalOptimizer.php
 create mode 100644 optimizers/TensorVecL1NormOptimizer.php
 create mode 100644 optimizers/TensorVecL2NormOptimizer.php
 create mode 100644 optimizers/TensorVecMaxNormOptimizer.php
 create mode 100644 optimizers/TensorVecMeanOptimizer.php
 create mode 100644 optimizers/TensorVecVarianceOptimizer.php
 create mode 100644 optimizers/TensorVecVarianceWithMeanOptimizer.php

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cb9c05d..14d77b1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,7 @@
 # Change Log
 
 - 4.0.0
+    - Speed up `Vector::fromArray()` and `Matrix::fromArray()` by eliminating intermediate array copies
 
 - 3.1.0
     - Implemented the singular value decomposition (SVD) in the extension
diff --git a/benchmarks/Statistical/VectorPNormBench.php b/benchmarks/Statistical/VectorPNormBench.php
new file mode 100644
index 0000000..bdc825e
--- /dev/null
+++ b/benchmarks/Statistical/VectorPNormBench.php
@@ -0,0 +1,52 @@
+<?php
+
+namespace Tensor\Benchmarks\Statistical;
+
+use Tensor\Vector;
+
+/**
+ * @Groups({"Statistical"})
+ * @BeforeMethods({"setUp"})
+ */
+class VectorPNormBench
+{
+    /**
+     * @var Vector
+     */
+    protected $a;
+
+    public function setUp() : void
+    {
+        $this->a = Vector::uniform(100000);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function p2() : void
+    {
+        $this->a->pNorm(2.0);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function p3() : void
+    {
+        $this->a->pNorm(3.0);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(5)
+     * @OutputTimeUnit("milliseconds", precision=3)
+     */
+    public function p10() : void
+    {
+        $this->a->pNorm(10.0);
+    }
+}
diff --git a/benchmarks/Structural/MatrixFromArrayBench.php b/benchmarks/Structural/MatrixFromArrayBench.php
new file mode 100644
index 0000000..29ad375
--- /dev/null
+++ b/benchmarks/Structural/MatrixFromArrayBench.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace Tensor\Benchmarks\Structural;
+
+use Tensor\Matrix;
+
+/**
+ * @Groups({"Structural"})
+ * @BeforeMethods({"setUp"})
+ */
+class MatrixFromArrayBench
+{
+    /**
+     * @var array[]
+     */
+    protected $a;
+
+    public function setUp() : void
+    {
+        $a = [];
+
+        for ($i = 0; $i < 2000; ++$i) {
+            $row = [];
+
+            for ($j = 0; $j < 2000; ++$j) {
+                $row[] = ($i * $j) % 2000;
+            }
+
+            $a[] = $row;
+        }
+
+        $this->a = $a;
+    }
+
+    /**
+     * @Subject
+     * @Iterations(10)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function fromArray() : void
+    {
+        Matrix::fromArray($this->a);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(10)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function fromArrayNoValidate() : void
+    {
+        Matrix::fromArray($this->a, false);
+    }
+}
diff --git a/benchmarks/Structural/VectorFromArrayBench.php b/benchmarks/Structural/VectorFromArrayBench.php
new file mode 100644
index 0000000..4da84fc
--- /dev/null
+++ b/benchmarks/Structural/VectorFromArrayBench.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace Tensor\Benchmarks\Structural;
+
+use Tensor\Vector;
+
+/**
+ * @Groups({"Structural"})
+ * @BeforeMethods({"setUp"})
+ */
+class VectorFromArrayBench
+{
+    /**
+     * @var list<float>
+     */
+    protected $a;
+
+    public function setUp() : void
+    {
+        $a = [];
+
+        for ($i = 0; $i < 4000000; ++$i) {
+            $a[] = $i;
+        }
+
+        $this->a = $a;
+    }
+
+    /**
+     * @Subject
+     * @Iterations(10)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function fromArray() : void
+    {
+        Vector::fromArray($this->a);
+    }
+
+    /**
+     * @Subject
+     * @Iterations(10)
+     * @OutputTimeUnit("seconds", precision=3)
+     */
+    public function fromArrayNoValidate() : void
+    {
+        Vector::fromArray($this->a, false);
+    }
+}
diff --git a/ext/tensor/matrix.zep.c b/ext/tensor/matrix.zep.c
index 3f79adb..2804da6 100644
--- a/ext/tensor/matrix.zep.c
+++ b/ext/tensor/matrix.zep.c
@@ -886,37 +886,48 @@ PHP_METHOD(Tensor_Matrix, uniform)
  */
 PHP_METHOD(Tensor_Matrix, fromArray)
 {
-	zval _4$$4, _7$$6;
+	zval _5$$6, _9$$8, _25$$14, _28$$16;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_11 = NULL;
-	zend_long ZEPHIR_LAST_CALL_STATUS, rows, i = 0;
-	zend_bool validate, _5$$5, _8$$5, _18$$5;
-	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, firstRow, n, aList, buffer, _19, buffer$$3, _0$$3, _1$$3, _2$$3, _3$$4, *_14$$5, _15$$5, *_16$$5, _17$$5, _6$$6, _9$$7, _10$$7, _12$$7, _13$$7;
+	zephir_fcall_cache_entry *_6 = NULL, *_14 = NULL;
+	zend_long ZEPHIR_LAST_CALL_STATUS, rows, n;
+	zend_bool validate, found, _23, _7$$7, _10$$7, _21$$4, _26$$15, _29$$15, _39$$12;
+	zval *a_param = NULL, *validate_param = NULL, rowA, valueA, *_3, _22, buffer, _40, _41, buffer$$3, _0$$3, _1$$3, _2$$3, _4$$6, _8$$8, _11$$9, _12$$9, _13$$9, _15$$9, _16$$9, *_17$$4, _18$$4, *_19$$4, _20$$4, _24$$14, _27$$16, _30$$17, _31$$17, _32$$17, _33$$17, _34$$17, *_35$$12, _36$$12, *_37$$12, _38$$12;
 	zval a, flat;
 
 	ZVAL_UNDEF(&a);
 	ZVAL_UNDEF(&flat);
 	ZVAL_UNDEF(&rowA);
 	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&firstRow);
-	ZVAL_UNDEF(&n);
-	ZVAL_UNDEF(&aList);
+	ZVAL_UNDEF(&_22);
 	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_19);
+	ZVAL_UNDEF(&_40);
+	ZVAL_UNDEF(&_41);
 	ZVAL_UNDEF(&buffer$$3);
 	ZVAL_UNDEF(&_0$$3);
 	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&_2$$3);
-	ZVAL_UNDEF(&_3$$4);
-	ZVAL_UNDEF(&_15$$5);
-	ZVAL_UNDEF(&_17$$5);
-	ZVAL_UNDEF(&_6$$6);
-	ZVAL_UNDEF(&_9$$7);
-	ZVAL_UNDEF(&_10$$7);
-	ZVAL_UNDEF(&_12$$7);
-	ZVAL_UNDEF(&_13$$7);
-	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&_7$$6);
+	ZVAL_UNDEF(&_4$$6);
+	ZVAL_UNDEF(&_8$$8);
+	ZVAL_UNDEF(&_11$$9);
+	ZVAL_UNDEF(&_12$$9);
+	ZVAL_UNDEF(&_13$$9);
+	ZVAL_UNDEF(&_15$$9);
+	ZVAL_UNDEF(&_16$$9);
+	ZVAL_UNDEF(&_18$$4);
+	ZVAL_UNDEF(&_20$$4);
+	ZVAL_UNDEF(&_24$$14);
+	ZVAL_UNDEF(&_27$$16);
+	ZVAL_UNDEF(&_30$$17);
+	ZVAL_UNDEF(&_31$$17);
+	ZVAL_UNDEF(&_32$$17);
+	ZVAL_UNDEF(&_33$$17);
+	ZVAL_UNDEF(&_34$$17);
+	ZVAL_UNDEF(&_36$$12);
+	ZVAL_UNDEF(&_38$$12);
+	ZVAL_UNDEF(&_5$$6);
+	ZVAL_UNDEF(&_9$$8);
+	ZVAL_UNDEF(&_25$$14);
+	ZVAL_UNDEF(&_28$$16);
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
 		Z_PARAM_OPTIONAL
@@ -943,110 +954,220 @@ PHP_METHOD(Tensor_Matrix, fromArray)
 		zephir_check_call_status();
 		RETURN_MM();
 	}
-	ZEPHIR_CALL_FUNCTION(&aList, "array_values", NULL, 24, &a);
-	zephir_check_call_status();
-	zephir_memory_observe(&firstRow);
-	zephir_array_fetch_long(&firstRow, &aList, 0, PH_NOISY, "tensor/matrix.zep", 377);
-	if (UNEXPECTED(!(Z_TYPE_P(&firstRow) == IS_ARRAY))) {
-		ZEPHIR_INIT_VAR(&_3$$4);
-		object_init_ex(&_3$$4, tensor_exceptions_invalidargumentexception_ce);
-		ZEPHIR_INIT_VAR(&_4$$4);
-		ZEPHIR_CONCAT_SS(&_4$$4, "Matrix requires an", " array of arrays.");
-		ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 2, &_4$$4);
-		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$4, "tensor/matrix.zep", 381);
-		ZEPHIR_MM_RESTORE();
-		return;
-	}
-	ZEPHIR_INIT_VAR(&n);
-	ZVAL_LONG(&n, zephir_fast_count_int(&firstRow));
 	ZEPHIR_INIT_VAR(&flat);
 	array_init(&flat);
-	i = 0;
-	while (1) {
-		if (!(i < rows)) {
-			break;
-		}
-		ZEPHIR_OBS_NVAR(&rowA);
-		zephir_array_fetch_long(&rowA, &aList, i, PH_NOISY, "tensor/matrix.zep", 391);
-		_5$$5 = validate;
-		if (_5$$5) {
-			_5$$5 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
-		}
-		if (UNEXPECTED(_5$$5)) {
-			ZEPHIR_INIT_NVAR(&_6$$6);
-			object_init_ex(&_6$$6, tensor_exceptions_invalidargumentexception_ce);
-			ZEPHIR_INIT_NVAR(&_7$$6);
-			ZEPHIR_CONCAT_SS(&_7$$6, "Matrix requires an", " array of arrays.");
-			ZEPHIR_CALL_METHOD(NULL, &_6$$6, "__construct", NULL, 2, &_7$$6);
-			zephir_check_call_status();
-			zephir_throw_exception_debug(&_6$$6, "tensor/matrix.zep", 395);
-			ZEPHIR_MM_RESTORE();
-			return;
-		}
-		_8$$5 = validate;
-		if (_8$$5) {
-			_8$$5 = !ZEPHIR_IS_LONG_IDENTICAL(&n, zephir_fast_count_int(&rowA));
-		}
-		if (UNEXPECTED(_8$$5)) {
-			ZEPHIR_INIT_NVAR(&_9$$7);
-			object_init_ex(&_9$$7, tensor_exceptions_invalidargumentexception_ce);
-			ZEPHIR_CALL_FUNCTION(&_10$$7, "strval", &_11, 3, &n);
-			zephir_check_call_status();
-			ZEPHIR_INIT_NVAR(&_12$$7);
-			ZVAL_LONG(&_12$$7, zephir_fast_count_int(&rowA));
-			ZEPHIR_INIT_NVAR(&_13$$7);
-			ZEPHIR_CONCAT_SSVSVS(&_13$$7, "The number of", " columns must be equal for all rows, ", &_10$$7, " needed but ", &_12$$7, " given.");
-			ZEPHIR_CALL_METHOD(NULL, &_9$$7, "__construct", NULL, 2, &_13$$7);
-			zephir_check_call_status();
-			zephir_throw_exception_debug(&_9$$7, "tensor/matrix.zep", 401);
-			ZEPHIR_MM_RESTORE();
-			return;
-		}
-		if (Z_TYPE_P(&rowA) == IS_STRING) {
-			ZEPHIR_INIT_NVAR(&_15$$5);
-			zephir_string_to_char_array(&_15$$5, &rowA);
-			_14$$5 = &_15$$5;
-		} else {
-			_14$$5 = &rowA;
-		}
-		zephir_is_iterable(_14$$5, 0, "tensor/matrix.zep", 408);
-		if (Z_TYPE_P(_14$$5) == IS_ARRAY) {
-			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_14$$5), _16$$5)
-			{
-				ZEPHIR_INIT_NVAR(&valueA);
-				ZVAL_COPY(&valueA, _16$$5);
-				zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 405);
-			} ZEND_HASH_FOREACH_END();
-		} else {
-			ZEPHIR_CALL_METHOD(NULL, _14$$5, "rewind", NULL, 0);
-			zephir_check_call_status();
-			_18$$5 = 1;
-			while (1) {
-				if (_18$$5) {
-					_18$$5 = 0;
-				} else {
-					ZEPHIR_CALL_METHOD(NULL, _14$$5, "next", NULL, 0);
+	n = 0;
+	found = 0;
+	zephir_is_iterable(&a, 0, "tensor/matrix.zep", 404);
+	if (Z_TYPE_P(&a) == IS_ARRAY) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&a), _3)
+		{
+			ZEPHIR_INIT_NVAR(&rowA);
+			ZVAL_COPY(&rowA, _3);
+			if (UNEXPECTED(!found)) {
+				if (UNEXPECTED(!(Z_TYPE_P(&rowA) == IS_ARRAY))) {
+					ZEPHIR_INIT_NVAR(&_4$$6);
+					object_init_ex(&_4$$6, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_INIT_NVAR(&_5$$6);
+					ZEPHIR_CONCAT_SS(&_5$$6, "Matrix requires an", " array of arrays.");
+					ZEPHIR_CALL_METHOD(NULL, &_4$$6, "__construct", &_6, 2, &_5$$6);
 					zephir_check_call_status();
+					zephir_throw_exception_debug(&_4$$6, "tensor/matrix.zep", 380);
+					ZEPHIR_MM_RESTORE();
+					return;
+				}
+				n = zephir_fast_count_int(&rowA);
+				found = 1;
+			} else {
+				_7$$7 = validate;
+				if (_7$$7) {
+					_7$$7 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
+				}
+				if (UNEXPECTED(_7$$7)) {
+					ZEPHIR_INIT_NVAR(&_8$$8);
+					object_init_ex(&_8$$8, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_INIT_NVAR(&_9$$8);
+					ZEPHIR_CONCAT_SS(&_9$$8, "Matrix requires an", " array of arrays.");
+					ZEPHIR_CALL_METHOD(NULL, &_8$$8, "__construct", &_6, 2, &_9$$8);
+					zephir_check_call_status();
+					zephir_throw_exception_debug(&_8$$8, "tensor/matrix.zep", 389);
+					ZEPHIR_MM_RESTORE();
+					return;
+				}
+				_10$$7 = validate;
+				if (_10$$7) {
+					_10$$7 = zephir_fast_count_int(&rowA) != n;
 				}
-				ZEPHIR_CALL_METHOD(&_17$$5, _14$$5, "valid", NULL, 0);
+				if (UNEXPECTED(_10$$7)) {
+					ZEPHIR_INIT_NVAR(&_11$$9);
+					object_init_ex(&_11$$9, tensor_exceptions_invalidargumentexception_ce);
+					ZVAL_LONG(&_12$$9, n);
+					ZEPHIR_CALL_FUNCTION(&_13$$9, "strval", &_14, 3, &_12$$9);
+					zephir_check_call_status();
+					ZEPHIR_INIT_NVAR(&_15$$9);
+					ZVAL_LONG(&_15$$9, zephir_fast_count_int(&rowA));
+					ZEPHIR_INIT_NVAR(&_16$$9);
+					ZEPHIR_CONCAT_SSVSVS(&_16$$9, "The number of", " columns must be equal for all rows, ", &_13$$9, " needed but ", &_15$$9, " given.");
+					ZEPHIR_CALL_METHOD(NULL, &_11$$9, "__construct", &_6, 2, &_16$$9);
+					zephir_check_call_status();
+					zephir_throw_exception_debug(&_11$$9, "tensor/matrix.zep", 395);
+					ZEPHIR_MM_RESTORE();
+					return;
+				}
+			}
+			if (Z_TYPE_P(&rowA) == IS_STRING) {
+				ZEPHIR_INIT_NVAR(&_18$$4);
+				zephir_string_to_char_array(&_18$$4, &rowA);
+				_17$$4 = &_18$$4;
+			} else {
+				_17$$4 = &rowA;
+			}
+			zephir_is_iterable(_17$$4, 0, "tensor/matrix.zep", 402);
+			if (Z_TYPE_P(_17$$4) == IS_ARRAY) {
+				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_17$$4), _19$$4)
+				{
+					ZEPHIR_INIT_NVAR(&valueA);
+					ZVAL_COPY(&valueA, _19$$4);
+					zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 400);
+				} ZEND_HASH_FOREACH_END();
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, _17$$4, "rewind", NULL, 0);
 				zephir_check_call_status();
-				if (!zend_is_true(&_17$$5)) {
-					break;
+				_21$$4 = 1;
+				while (1) {
+					if (_21$$4) {
+						_21$$4 = 0;
+					} else {
+						ZEPHIR_CALL_METHOD(NULL, _17$$4, "next", NULL, 0);
+						zephir_check_call_status();
+					}
+					ZEPHIR_CALL_METHOD(&_20$$4, _17$$4, "valid", NULL, 0);
+					zephir_check_call_status();
+					if (!zend_is_true(&_20$$4)) {
+						break;
+					}
+					ZEPHIR_CALL_METHOD(&valueA, _17$$4, "current", NULL, 0);
+					zephir_check_call_status();
+						zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 400);
 				}
-				ZEPHIR_CALL_METHOD(&valueA, _14$$5, "current", NULL, 0);
+			}
+			ZEPHIR_INIT_NVAR(&valueA);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEPHIR_CALL_METHOD(NULL, &a, "rewind", NULL, 0);
+		zephir_check_call_status();
+		_23 = 1;
+		while (1) {
+			if (_23) {
+				_23 = 0;
+			} else {
+				ZEPHIR_CALL_METHOD(NULL, &a, "next", NULL, 0);
 				zephir_check_call_status();
-					zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 405);
 			}
+			ZEPHIR_CALL_METHOD(&_22, &a, "valid", NULL, 0);
+			zephir_check_call_status();
+			if (!zend_is_true(&_22)) {
+				break;
+			}
+			ZEPHIR_CALL_METHOD(&rowA, &a, "current", NULL, 0);
+			zephir_check_call_status();
+				if (UNEXPECTED(!found)) {
+					if (UNEXPECTED(!(Z_TYPE_P(&rowA) == IS_ARRAY))) {
+						ZEPHIR_INIT_NVAR(&_24$$14);
+						object_init_ex(&_24$$14, tensor_exceptions_invalidargumentexception_ce);
+						ZEPHIR_INIT_NVAR(&_25$$14);
+						ZEPHIR_CONCAT_SS(&_25$$14, "Matrix requires an", " array of arrays.");
+						ZEPHIR_CALL_METHOD(NULL, &_24$$14, "__construct", &_6, 2, &_25$$14);
+						zephir_check_call_status();
+						zephir_throw_exception_debug(&_24$$14, "tensor/matrix.zep", 380);
+						ZEPHIR_MM_RESTORE();
+						return;
+					}
+					n = zephir_fast_count_int(&rowA);
+					found = 1;
+				} else {
+					_26$$15 = validate;
+					if (_26$$15) {
+						_26$$15 = !(Z_TYPE_P(&rowA) == IS_ARRAY);
+					}
+					if (UNEXPECTED(_26$$15)) {
+						ZEPHIR_INIT_NVAR(&_27$$16);
+						object_init_ex(&_27$$16, tensor_exceptions_invalidargumentexception_ce);
+						ZEPHIR_INIT_NVAR(&_28$$16);
+						ZEPHIR_CONCAT_SS(&_28$$16, "Matrix requires an", " array of arrays.");
+						ZEPHIR_CALL_METHOD(NULL, &_27$$16, "__construct", &_6, 2, &_28$$16);
+						zephir_check_call_status();
+						zephir_throw_exception_debug(&_27$$16, "tensor/matrix.zep", 389);
+						ZEPHIR_MM_RESTORE();
+						return;
+					}
+					_29$$15 = validate;
+					if (_29$$15) {
+						_29$$15 = zephir_fast_count_int(&rowA) != n;
+					}
+					if (UNEXPECTED(_29$$15)) {
+						ZEPHIR_INIT_NVAR(&_30$$17);
+						object_init_ex(&_30$$17, tensor_exceptions_invalidargumentexception_ce);
+						ZVAL_LONG(&_31$$17, n);
+						ZEPHIR_CALL_FUNCTION(&_32$$17, "strval", &_14, 3, &_31$$17);
+						zephir_check_call_status();
+						ZEPHIR_INIT_NVAR(&_33$$17);
+						ZVAL_LONG(&_33$$17, zephir_fast_count_int(&rowA));
+						ZEPHIR_INIT_NVAR(&_34$$17);
+						ZEPHIR_CONCAT_SSVSVS(&_34$$17, "The number of", " columns must be equal for all rows, ", &_32$$17, " needed but ", &_33$$17, " given.");
+						ZEPHIR_CALL_METHOD(NULL, &_30$$17, "__construct", &_6, 2, &_34$$17);
+						zephir_check_call_status();
+						zephir_throw_exception_debug(&_30$$17, "tensor/matrix.zep", 395);
+						ZEPHIR_MM_RESTORE();
+						return;
+					}
+				}
+				if (Z_TYPE_P(&rowA) == IS_STRING) {
+					ZEPHIR_INIT_NVAR(&_36$$12);
+					zephir_string_to_char_array(&_36$$12, &rowA);
+					_35$$12 = &_36$$12;
+				} else {
+					_35$$12 = &rowA;
+				}
+				zephir_is_iterable(_35$$12, 0, "tensor/matrix.zep", 402);
+				if (Z_TYPE_P(_35$$12) == IS_ARRAY) {
+					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_35$$12), _37$$12)
+					{
+						ZEPHIR_INIT_NVAR(&valueA);
+						ZVAL_COPY(&valueA, _37$$12);
+						zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 400);
+					} ZEND_HASH_FOREACH_END();
+				} else {
+					ZEPHIR_CALL_METHOD(NULL, _35$$12, "rewind", NULL, 0);
+					zephir_check_call_status();
+					_39$$12 = 1;
+					while (1) {
+						if (_39$$12) {
+							_39$$12 = 0;
+						} else {
+							ZEPHIR_CALL_METHOD(NULL, _35$$12, "next", NULL, 0);
+							zephir_check_call_status();
+						}
+						ZEPHIR_CALL_METHOD(&_38$$12, _35$$12, "valid", NULL, 0);
+						zephir_check_call_status();
+						if (!zend_is_true(&_38$$12)) {
+							break;
+						}
+						ZEPHIR_CALL_METHOD(&valueA, _35$$12, "current", NULL, 0);
+						zephir_check_call_status();
+							zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/matrix.zep", 400);
+					}
+				}
+				ZEPHIR_INIT_NVAR(&valueA);
 		}
-		ZEPHIR_INIT_NVAR(&valueA);
-		i++;
 	}
+	ZEPHIR_INIT_NVAR(&rowA);
 	ZEPHIR_INIT_VAR(&buffer);
 	tensor_buffer_from_array(&buffer, &flat);
 	object_init_ex(return_value, tensor_matrix_ce);
-	ZVAL_LONG(&_19, rows);
-	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &buffer, &_19, &n);
+	ZVAL_LONG(&_40, rows);
+	ZVAL_LONG(&_41, n);
+	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 14, &buffer, &_40, &_41);
 	zephir_check_call_status();
 	RETURN_MM();
 }
@@ -1104,7 +1225,7 @@ PHP_METHOD(Tensor_Matrix, __construct)
 		ZEPHIR_CONCAT_SS(&_2$$3, "Matrix dimensions must be", " non-negative.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 428);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 421);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1316,7 +1437,7 @@ PHP_METHOD(Tensor_Matrix, rowAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Row offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 507);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 500);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1387,7 +1508,7 @@ PHP_METHOD(Tensor_Matrix, columnAsVector)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Column offset out of", " bounds.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 524);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 517);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1452,7 +1573,7 @@ PHP_METHOD(Tensor_Matrix, diagonalAsVector)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 540);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 533);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1523,7 +1644,7 @@ PHP_METHOD(Tensor_Matrix, asVectors)
 	} else {
 		_4 = &_2;
 	}
-	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 565);
+	zephir_is_iterable(_4, 0, "tensor/matrix.zep", 558);
 	if (Z_TYPE_P(_4) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6)
 		{
@@ -1533,7 +1654,7 @@ PHP_METHOD(Tensor_Matrix, asVectors)
 			object_init_ex(&_7$$4, tensor_vector_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", &_8, 13, &rowBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 562);
+			zephir_array_append(&b, &_7$$4, PH_SEPARATE, "tensor/matrix.zep", 555);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _4, "rewind", NULL, 0);
@@ -1557,7 +1678,7 @@ PHP_METHOD(Tensor_Matrix, asVectors)
 				object_init_ex(&_11$$5, tensor_vector_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_11$$5, "__construct", &_8, 13, &rowBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 562);
+				zephir_array_append(&b, &_11$$5, PH_SEPARATE, "tensor/matrix.zep", 555);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&rowBuffer);
@@ -1610,7 +1731,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 	} else {
 		_2 = &_1;
 	}
-	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 587);
+	zephir_is_iterable(_2, 0, "tensor/matrix.zep", 580);
 	if (Z_TYPE_P(_2) == IS_ARRAY) {
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4)
 		{
@@ -1620,7 +1741,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 			object_init_ex(&_5$$4, tensor_columnvector_ce);
 			ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_6, 13, &columnBuffer);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 584);
+			zephir_array_append(&b, &_5$$4, PH_SEPARATE, "tensor/matrix.zep", 577);
 		} ZEND_HASH_FOREACH_END();
 	} else {
 		ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0);
@@ -1644,7 +1765,7 @@ PHP_METHOD(Tensor_Matrix, asColumnVectors)
 				object_init_ex(&_9$$5, tensor_columnvector_ce);
 				ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", &_6, 13, &columnBuffer);
 				zephir_check_call_status();
-				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 584);
+				zephir_array_append(&b, &_9$$5, PH_SEPARATE, "tensor/matrix.zep", 577);
 		}
 	}
 	ZEPHIR_INIT_NVAR(&columnBuffer);
@@ -1830,7 +1951,7 @@ PHP_METHOD(Tensor_Matrix, asColumnBuffers)
 			zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 16, PH_NOISY_CC | PH_READONLY);
 			ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "sliceStrided", NULL, 0, &i, &_7$$4, &_8$$4);
 			zephir_check_call_status();
-			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 661);
+			zephir_array_append(&b, &_6$$4, PH_SEPARATE, "tensor/matrix.zep", 654);
 		}
 	}
 	RETURN_CTOR(&b);
@@ -2048,7 +2169,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 724);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 717);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2061,7 +2182,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_6$$4, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 25, &_6$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 729);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 722);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2076,7 +2197,7 @@ PHP_METHOD(Tensor_Matrix, inverse)
 		ZEPHIR_CONCAT_SS(&_10$$5, "Failed to compute the inverse", " of a singular matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 25, &_10$$5);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 736);
+		zephir_throw_exception_debug(&_9$$5, "tensor/matrix.zep", 729);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2136,7 +2257,7 @@ PHP_METHOD(Tensor_Matrix, pseudoinverse)
 		ZEPHIR_CONCAT_SS(&_4$$3, "Failed to compute the pseudoinverse", " of the matrix.");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 25, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 753);
+		zephir_throw_exception_debug(&_3$$3, "tensor/matrix.zep", 746);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2186,7 +2307,7 @@ PHP_METHOD(Tensor_Matrix, det)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Matrix must be", " square, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 769);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 762);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2395,7 +2516,7 @@ PHP_METHOD(Tensor_Matrix, matmul)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " rows but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 837);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 830);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2480,7 +2601,7 @@ PHP_METHOD(Tensor_Matrix, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 857);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 850);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2581,7 +2702,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SS(&_6$$3, "Matrix B cannot be", " larger than Matrix A.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 2, &_6$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 875);
+		zephir_throw_exception_debug(&_5$$3, "tensor/matrix.zep", 868);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2595,7 +2716,7 @@ PHP_METHOD(Tensor_Matrix, convolve)
 		ZEPHIR_CONCAT_SSVS(&_10$$4, "Stride cannot be", " less than 1, ", &_9$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_7$$4, "__construct", NULL, 2, &_10$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 880);
+		zephir_throw_exception_debug(&_7$$4, "tensor/matrix.zep", 873);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -2932,7 +3053,7 @@ PHP_METHOD(Tensor_Matrix, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1024);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1017);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3003,7 +3124,7 @@ PHP_METHOD(Tensor_Matrix, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " matrix by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1057);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1050);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3075,7 +3196,7 @@ PHP_METHOD(Tensor_Matrix, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1091);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1084);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3147,7 +3268,7 @@ PHP_METHOD(Tensor_Matrix, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1125);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1118);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3219,7 +3340,7 @@ PHP_METHOD(Tensor_Matrix, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " matrix to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1159);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1152);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3291,7 +3412,7 @@ PHP_METHOD(Tensor_Matrix, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " matrix with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1193);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1186);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3363,7 +3484,7 @@ PHP_METHOD(Tensor_Matrix, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1227);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1220);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3435,7 +3556,7 @@ PHP_METHOD(Tensor_Matrix, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1261);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1254);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3507,7 +3628,7 @@ PHP_METHOD(Tensor_Matrix, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1295);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1288);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3579,7 +3700,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1329);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1322);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3651,7 +3772,7 @@ PHP_METHOD(Tensor_Matrix, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1363);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1356);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -3723,7 +3844,7 @@ PHP_METHOD(Tensor_Matrix, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " matrix to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1397);
+	zephir_throw_exception_debug(&_2, "tensor/matrix.zep", 1390);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -4769,7 +4890,7 @@ PHP_METHOD(Tensor_Matrix, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be between", " 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1658);
+		zephir_throw_exception_debug(&_1$$3, "tensor/matrix.zep", 1651);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4850,7 +4971,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVS(&_2$$4, "Mean must be a", " column vector ", &_1$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 2, &_2$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1677);
+			zephir_throw_exception_debug(&_0$$4, "tensor/matrix.zep", 1670);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -4870,7 +4991,7 @@ PHP_METHOD(Tensor_Matrix, variance)
 			ZEPHIR_CONCAT_SSVSVS(&_10$$5, "Mean vector must", " have ", &_7$$5, " rows, ", &_9$$5, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", NULL, 2, &_10$$5);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1683);
+			zephir_throw_exception_debug(&_5$$5, "tensor/matrix.zep", 1676);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -4959,7 +5080,7 @@ PHP_METHOD(Tensor_Matrix, covariance)
 			ZEPHIR_CONCAT_SSVSVS(&_7$$4, "Mean vector must", " have ", &_4$$4, " rows, ", &_6$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 2, &_7$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1708);
+			zephir_throw_exception_debug(&_2$$4, "tensor/matrix.zep", 1701);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -5035,7 +5156,7 @@ PHP_METHOD(Tensor_Matrix, round)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1729);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1722);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5190,7 +5311,7 @@ PHP_METHOD(Tensor_Matrix, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1768);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 1761);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5467,7 +5588,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1834);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1827);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5565,7 +5686,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1854);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1847);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5675,7 +5796,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1874);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1867);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5718,7 +5839,7 @@ PHP_METHOD(Tensor_Matrix, augmentLeft)
 			zephir_array_fast_append(&_22$$4, &bufferA);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferB, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1888);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1881);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -5821,7 +5942,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, 2, &_9$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1906);
+		zephir_throw_exception_debug(&_4$$3, "tensor/matrix.zep", 1899);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5864,7 +5985,7 @@ PHP_METHOD(Tensor_Matrix, augmentRight)
 			zephir_array_fast_append(&_22$$4, &bufferB);
 			ZEPHIR_CALL_METHOD(&_21$$4, &bufferA, "concat", NULL, 0, &_22$$4);
 			zephir_check_call_status();
-			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1920);
+			zephir_array_append(&c, &_21$$4, PH_SEPARATE, "tensor/matrix.zep", 1913);
 		}
 	}
 	object_init_ex(return_value, tensor_matrix_ce);
@@ -5950,7 +6071,7 @@ PHP_METHOD(Tensor_Matrix, repeat)
 		ZEPHIR_CONCAT_SS(&_4$$4, "Chunk length must be", " greater than 0, 0 given.");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 2, &_4$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$4, "tensor/matrix.zep", 1942);
+		zephir_throw_exception_debug(&_3$$4, "tensor/matrix.zep", 1935);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6039,7 +6160,7 @@ PHP_METHOD(Tensor_Matrix, multiplyMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1965);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1958);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6115,7 +6236,7 @@ PHP_METHOD(Tensor_Matrix, divideMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1984);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1977);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6191,7 +6312,7 @@ PHP_METHOD(Tensor_Matrix, addMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2003);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 1996);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6267,7 +6388,7 @@ PHP_METHOD(Tensor_Matrix, subtractMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2022);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2015);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6344,7 +6465,7 @@ PHP_METHOD(Tensor_Matrix, powMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2042);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2035);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6421,7 +6542,7 @@ PHP_METHOD(Tensor_Matrix, modMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2062);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2055);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6498,7 +6619,7 @@ PHP_METHOD(Tensor_Matrix, equalMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2082);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2075);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6574,7 +6695,7 @@ PHP_METHOD(Tensor_Matrix, notEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2101);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2094);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6651,7 +6772,7 @@ PHP_METHOD(Tensor_Matrix, greaterMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2121);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2114);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6728,7 +6849,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2141);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2134);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6804,7 +6925,7 @@ PHP_METHOD(Tensor_Matrix, lessMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2160);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2153);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6880,7 +7001,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualMatrix)
 		ZEPHIR_CONCAT_VSVS(&_5$$3, &_3$$3, " matrix expected but ", &_4$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2179);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2172);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6961,7 +7082,7 @@ PHP_METHOD(Tensor_Matrix, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2199);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2192);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7044,7 +7165,7 @@ PHP_METHOD(Tensor_Matrix, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2223);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2216);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7127,7 +7248,7 @@ PHP_METHOD(Tensor_Matrix, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2247);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2240);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7210,7 +7331,7 @@ PHP_METHOD(Tensor_Matrix, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2271);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2264);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7293,7 +7414,7 @@ PHP_METHOD(Tensor_Matrix, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2295);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2288);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7376,7 +7497,7 @@ PHP_METHOD(Tensor_Matrix, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2319);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2312);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7460,7 +7581,7 @@ PHP_METHOD(Tensor_Matrix, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2344);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2337);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7543,7 +7664,7 @@ PHP_METHOD(Tensor_Matrix, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2368);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2361);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7626,7 +7747,7 @@ PHP_METHOD(Tensor_Matrix, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2392);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2385);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7709,7 +7830,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2416);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2409);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7792,7 +7913,7 @@ PHP_METHOD(Tensor_Matrix, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2440);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2433);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7876,7 +7997,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " columns but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2465);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2458);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -7959,7 +8080,7 @@ PHP_METHOD(Tensor_Matrix, multiplyColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2489);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2482);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8042,7 +8163,7 @@ PHP_METHOD(Tensor_Matrix, divideColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2513);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2506);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8125,7 +8246,7 @@ PHP_METHOD(Tensor_Matrix, addColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2537);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2530);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8208,7 +8329,7 @@ PHP_METHOD(Tensor_Matrix, subtractColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2561);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2554);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8291,7 +8412,7 @@ PHP_METHOD(Tensor_Matrix, powColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2585);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2578);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8374,7 +8495,7 @@ PHP_METHOD(Tensor_Matrix, modColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2609);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2602);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8457,7 +8578,7 @@ PHP_METHOD(Tensor_Matrix, equalColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2633);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2626);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8540,7 +8661,7 @@ PHP_METHOD(Tensor_Matrix, notEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2657);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2650);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8623,7 +8744,7 @@ PHP_METHOD(Tensor_Matrix, greaterColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2681);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2674);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8706,7 +8827,7 @@ PHP_METHOD(Tensor_Matrix, greaterEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2705);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2698);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8789,7 +8910,7 @@ PHP_METHOD(Tensor_Matrix, lessColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2729);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2722);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -8872,7 +8993,7 @@ PHP_METHOD(Tensor_Matrix, lessEqualColumnVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Matrix A expects ", &_4$$3, " rows but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2753);
+		zephir_throw_exception_debug(&_2$$3, "tensor/matrix.zep", 2746);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9536,7 +9657,7 @@ PHP_METHOD(Tensor_Matrix, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2938);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2931);
 	return;
 }
 
@@ -9587,7 +9708,7 @@ PHP_METHOD(Tensor_Matrix, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2962);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Matrix cannot be mutated directly.", "tensor/matrix.zep", 2955);
 	return;
 }
 
@@ -9647,7 +9768,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_2$$3, "Row offset must be", " an integer, ", &_1$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 2976);
+		zephir_throw_exception_debug(&_0$$3, "tensor/matrix.zep", 2969);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9664,7 +9785,7 @@ PHP_METHOD(Tensor_Matrix, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Row offset out of", " bounds, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 2981);
+		zephir_throw_exception_debug(&_5$$4, "tensor/matrix.zep", 2974);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -9787,16 +9908,16 @@ PHP_METHOD(Tensor_Matrix, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3024);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3017);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	ZEPHIR_CALL_METHOD(&_2, &rebuilt, "asTensorBuffer", NULL, 0);
 	zephir_check_call_status();
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 14, &_2);
-	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3027);
+	zephir_array_fetch_string(&_3, &data, SL("m"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3020);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 15, &_3);
-	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3028);
+	zephir_array_fetch_string(&_4, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/matrix.zep", 3021);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 16, &_4);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/ext/tensor/vector.zep.c b/ext/tensor/vector.zep.c
index 1cf248d..543e0a0 100644
--- a/ext/tensor/vector.zep.c
+++ b/ext/tensor/vector.zep.c
@@ -684,25 +684,24 @@ PHP_METHOD(Tensor_Vector, linspace)
  */
 PHP_METHOD(Tensor_Vector, fromArray)
 {
-	zval _5$$4, _11$$6;
+	zval _4$$5, _9$$7;
 	zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
-	zephir_fcall_cache_entry *_6 = NULL;
+	zephir_fcall_cache_entry *_5 = NULL;
 	zend_long ZEPHIR_LAST_CALL_STATUS;
-	zend_bool validate, _8, _3$$3, _9$$5;
-	zval *a_param = NULL, *validate_param = NULL, valueA, _0, *_2, _7, buffer, _4$$4, _10$$6;
-	zval a, flat, _1;
+	zend_bool validate, _7$$3;
+	zval *a_param = NULL, *validate_param = NULL, buffer, valueA, _0$$3, *_2$$3, _6$$3, _3$$5, _8$$7;
+	zval a, _1$$3;
 
 	ZVAL_UNDEF(&a);
-	ZVAL_UNDEF(&flat);
-	ZVAL_UNDEF(&_1);
-	ZVAL_UNDEF(&valueA);
-	ZVAL_UNDEF(&_0);
-	ZVAL_UNDEF(&_7);
+	ZVAL_UNDEF(&_1$$3);
 	ZVAL_UNDEF(&buffer);
-	ZVAL_UNDEF(&_4$$4);
-	ZVAL_UNDEF(&_10$$6);
-	ZVAL_UNDEF(&_5$$4);
-	ZVAL_UNDEF(&_11$$6);
+	ZVAL_UNDEF(&valueA);
+	ZVAL_UNDEF(&_0$$3);
+	ZVAL_UNDEF(&_6$$3);
+	ZVAL_UNDEF(&_3$$5);
+	ZVAL_UNDEF(&_8$$7);
+	ZVAL_UNDEF(&_4$$5);
+	ZVAL_UNDEF(&_9$$7);
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		ZEPHIR_Z_PARAM_ARRAY(a, a_param)
 		Z_PARAM_OPTIONAL
@@ -716,72 +715,62 @@ PHP_METHOD(Tensor_Vector, fromArray)
 		validate = 1;
 	} else {
 		}
-	ZEPHIR_INIT_VAR(&flat);
-	array_init(&flat);
-	ZEPHIR_CPY_WRT(&_0, &a);
-	zephir_get_arrval(&_1, &_0);
-	zephir_is_iterable(&_1, 0, "tensor/vector.zep", 287);
-	if (Z_TYPE_P(&_1) == IS_ARRAY) {
-		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_1), _2)
-		{
-			ZEPHIR_INIT_NVAR(&valueA);
-			ZVAL_COPY(&valueA, _2);
-			_3$$3 = validate;
-			if (_3$$3) {
-				_3$$3 = Z_TYPE_P(&valueA) == IS_ARRAY;
-			}
-			if (UNEXPECTED(_3$$3)) {
-				ZEPHIR_INIT_NVAR(&_4$$4);
-				object_init_ex(&_4$$4, tensor_exceptions_invalidargumentexception_ce);
-				ZEPHIR_INIT_NVAR(&_5$$4);
-				ZEPHIR_CONCAT_SS(&_5$$4, "Vector requires a", " flat array of numeric elements.");
-				ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", &_6, 2, &_5$$4);
-				zephir_check_call_status();
-				zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 281);
-				ZEPHIR_MM_RESTORE();
-				return;
-			}
-			zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/vector.zep", 284);
-		} ZEND_HASH_FOREACH_END();
-	} else {
-		ZEPHIR_CALL_METHOD(NULL, &_1, "rewind", NULL, 0);
-		zephir_check_call_status();
-		_8 = 1;
-		while (1) {
-			if (_8) {
-				_8 = 0;
-			} else {
-				ZEPHIR_CALL_METHOD(NULL, &_1, "next", NULL, 0);
-				zephir_check_call_status();
-			}
-			ZEPHIR_CALL_METHOD(&_7, &_1, "valid", NULL, 0);
-			zephir_check_call_status();
-			if (!zend_is_true(&_7)) {
-				break;
-			}
-			ZEPHIR_CALL_METHOD(&valueA, &_1, "current", NULL, 0);
-			zephir_check_call_status();
-				_9$$5 = validate;
-				if (_9$$5) {
-					_9$$5 = Z_TYPE_P(&valueA) == IS_ARRAY;
-				}
-				if (UNEXPECTED(_9$$5)) {
-					ZEPHIR_INIT_NVAR(&_10$$6);
-					object_init_ex(&_10$$6, tensor_exceptions_invalidargumentexception_ce);
-					ZEPHIR_INIT_NVAR(&_11$$6);
-					ZEPHIR_CONCAT_SS(&_11$$6, "Vector requires a", " flat array of numeric elements.");
-					ZEPHIR_CALL_METHOD(NULL, &_10$$6, "__construct", &_6, 2, &_11$$6);
+	if (UNEXPECTED(validate)) {
+		ZEPHIR_CPY_WRT(&_0$$3, &a);
+		zephir_get_arrval(&_1$$3, &_0$$3);
+		zephir_is_iterable(&_1$$3, 0, "tensor/vector.zep", 283);
+		if (Z_TYPE_P(&_1$$3) == IS_ARRAY) {
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_1$$3), _2$$3)
+			{
+				ZEPHIR_INIT_NVAR(&valueA);
+				ZVAL_COPY(&valueA, _2$$3);
+				if (UNEXPECTED(Z_TYPE_P(&valueA) == IS_ARRAY)) {
+					ZEPHIR_INIT_NVAR(&_3$$5);
+					object_init_ex(&_3$$5, tensor_exceptions_invalidargumentexception_ce);
+					ZEPHIR_INIT_NVAR(&_4$$5);
+					ZEPHIR_CONCAT_SS(&_4$$5, "Vector requires a", " flat array of numeric elements.");
+					ZEPHIR_CALL_METHOD(NULL, &_3$$5, "__construct", &_5, 2, &_4$$5);
 					zephir_check_call_status();
-					zephir_throw_exception_debug(&_10$$6, "tensor/vector.zep", 281);
+					zephir_throw_exception_debug(&_3$$5, "tensor/vector.zep", 280);
 					ZEPHIR_MM_RESTORE();
 					return;
 				}
-				zephir_array_append(&flat, &valueA, PH_SEPARATE, "tensor/vector.zep", 284);
+			} ZEND_HASH_FOREACH_END();
+		} else {
+			ZEPHIR_CALL_METHOD(NULL, &_1$$3, "rewind", NULL, 0);
+			zephir_check_call_status();
+			_7$$3 = 1;
+			while (1) {
+				if (_7$$3) {
+					_7$$3 = 0;
+				} else {
+					ZEPHIR_CALL_METHOD(NULL, &_1$$3, "next", NULL, 0);
+					zephir_check_call_status();
+				}
+				ZEPHIR_CALL_METHOD(&_6$$3, &_1$$3, "valid", NULL, 0);
+				zephir_check_call_status();
+				if (!zend_is_true(&_6$$3)) {
+					break;
+				}
+				ZEPHIR_CALL_METHOD(&valueA, &_1$$3, "current", NULL, 0);
+				zephir_check_call_status();
+					if (UNEXPECTED(Z_TYPE_P(&valueA) == IS_ARRAY)) {
+						ZEPHIR_INIT_NVAR(&_8$$7);
+						object_init_ex(&_8$$7, tensor_exceptions_invalidargumentexception_ce);
+						ZEPHIR_INIT_NVAR(&_9$$7);
+						ZEPHIR_CONCAT_SS(&_9$$7, "Vector requires a", " flat array of numeric elements.");
+						ZEPHIR_CALL_METHOD(NULL, &_8$$7, "__construct", &_5, 2, &_9$$7);
+						zephir_check_call_status();
+						zephir_throw_exception_debug(&_8$$7, "tensor/vector.zep", 280);
+						ZEPHIR_MM_RESTORE();
+						return;
+					}
+			}
 		}
+		ZEPHIR_INIT_NVAR(&valueA);
 	}
-	ZEPHIR_INIT_NVAR(&valueA);
 	ZEPHIR_INIT_VAR(&buffer);
-	tensor_buffer_from_array(&buffer, &flat);
+	tensor_buffer_from_array(&buffer, &a);
 	object_init_ex(return_value, zend_get_called_scope(execute_data));
 	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 13, &buffer);
 	zephir_check_call_status();
@@ -1074,7 +1063,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_SS(&_2$$3, "The number of rows", " and/or columns cannot be less than 0.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 406);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 404);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1091,7 +1080,7 @@ PHP_METHOD(Tensor_Vector, reshape)
 		ZEPHIR_CONCAT_VSSVS(&_7$$4, &_6$$4, " elements", " are needed but vector only has ", &_5$$4, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 413);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 411);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1278,7 +1267,7 @@ PHP_METHOD(Tensor_Vector, dot)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " elements but vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 468);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 466);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1348,7 +1337,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SS(&_3$$3, "Vector B cannot be", " larger than Vector A.");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 486);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 484);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1362,7 +1351,7 @@ PHP_METHOD(Tensor_Vector, convolve)
 		ZEPHIR_CONCAT_SSVS(&_7$$4, "Stride cannot be", " less than 1, ", &_6$$4, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 491);
+		zephir_throw_exception_debug(&_4$$4, "tensor/vector.zep", 489);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1575,7 +1564,7 @@ PHP_METHOD(Tensor_Vector, pNorm)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "P must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 563);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 561);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -1677,7 +1666,7 @@ PHP_METHOD(Tensor_Vector, multiply)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot multiply", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 606);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 604);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1743,7 +1732,7 @@ PHP_METHOD(Tensor_Vector, divide)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot divide", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 636);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 634);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1810,7 +1799,7 @@ PHP_METHOD(Tensor_Vector, add)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot add", " vector by the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 667);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 665);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1877,7 +1866,7 @@ PHP_METHOD(Tensor_Vector, subtract)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot subtract", " vector from the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 698);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 696);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -1944,7 +1933,7 @@ PHP_METHOD(Tensor_Vector, pow)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot raise", " vector to the power of the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 729);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 727);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2011,7 +2000,7 @@ PHP_METHOD(Tensor_Vector, mod)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot mod", " vector with the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 760);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 758);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2078,7 +2067,7 @@ PHP_METHOD(Tensor_Vector, equal)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 791);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 789);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2145,7 +2134,7 @@ PHP_METHOD(Tensor_Vector, notEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 822);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 820);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2212,7 +2201,7 @@ PHP_METHOD(Tensor_Vector, greater)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 853);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 851);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2279,7 +2268,7 @@ PHP_METHOD(Tensor_Vector, greaterEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 884);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 882);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2346,7 +2335,7 @@ PHP_METHOD(Tensor_Vector, less)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 915);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 913);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2413,7 +2402,7 @@ PHP_METHOD(Tensor_Vector, lessEqual)
 	ZEPHIR_CONCAT_SS(&_3, "Cannot compare", " vector to the given input.");
 	ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 2, &_3);
 	zephir_check_call_status();
-	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 946);
+	zephir_throw_exception_debug(&_2, "tensor/vector.zep", 944);
 	ZEPHIR_MM_RESTORE();
 	return;
 }
@@ -2635,7 +2624,7 @@ PHP_METHOD(Tensor_Vector, log)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Log base must be greater", " than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1020);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1018);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3049,7 +3038,7 @@ PHP_METHOD(Tensor_Vector, min)
 		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the minimum of an empty vector.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1153);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1151);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3105,7 +3094,7 @@ PHP_METHOD(Tensor_Vector, max)
 		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the maximum of an empty vector.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1170);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1168);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3161,7 +3150,7 @@ PHP_METHOD(Tensor_Vector, argmin)
 		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the argmin of an empty vector.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1187);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1185);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3217,7 +3206,7 @@ PHP_METHOD(Tensor_Vector, argmax)
 		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the argmax of an empty vector.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1204);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1202);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3300,7 +3289,7 @@ PHP_METHOD(Tensor_Vector, median)
 		ZEPHIR_CONCAT_SS(&_2$$3, "Cannot compute", " the median of an empty vector.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_2$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1231);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1229);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3374,7 +3363,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SSVS(&_4$$3, "Q must be", " between 0 and 1, ", &_3$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 2, &_4$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1250);
+		zephir_throw_exception_debug(&_1$$3, "tensor/vector.zep", 1248);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3386,7 +3375,7 @@ PHP_METHOD(Tensor_Vector, quantile)
 		ZEPHIR_CONCAT_SS(&_7$$4, "Cannot compute", " the quantile of an empty vector.");
 		ZEPHIR_CALL_METHOD(NULL, &_6$$4, "__construct", NULL, 2, &_7$$4);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_6$$4, "tensor/vector.zep", 1255);
+		zephir_throw_exception_debug(&_6$$4, "tensor/vector.zep", 1253);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3456,7 +3445,7 @@ PHP_METHOD(Tensor_Vector, variance)
 			ZEPHIR_CONCAT_SSVS(&_3$$4, "Mean scalar must be", " a floating point number ", &_2$$4, " given.");
 			ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 2, &_3$$4);
 			zephir_check_call_status();
-			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1275);
+			zephir_throw_exception_debug(&_1$$4, "tensor/vector.zep", 1273);
 			ZEPHIR_MM_RESTORE();
 			return;
 		}
@@ -3522,7 +3511,7 @@ PHP_METHOD(Tensor_Vector, round)
 		ZEPHIR_CONCAT_SSVS(&_3$$3, "Decimal precision cannot", " be less than 0, ", &_2$$3, " given.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_3$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1299);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1297);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3641,7 +3630,7 @@ PHP_METHOD(Tensor_Vector, clip)
 		ZEPHIR_CONCAT_SS(&_1$$3, "Minimum cannot be", " greater than maximum.");
 		ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 2, &_1$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1338);
+		zephir_throw_exception_debug(&_0$$3, "tensor/vector.zep", 1336);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3855,7 +3844,7 @@ PHP_METHOD(Tensor_Vector, multiplyMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1398);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1396);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -3936,7 +3925,7 @@ PHP_METHOD(Tensor_Vector, divideMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1422);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1420);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4017,7 +4006,7 @@ PHP_METHOD(Tensor_Vector, addMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1446);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1444);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4098,7 +4087,7 @@ PHP_METHOD(Tensor_Vector, subtractMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1470);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1468);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4179,7 +4168,7 @@ PHP_METHOD(Tensor_Vector, powMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1494);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1492);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4260,7 +4249,7 @@ PHP_METHOD(Tensor_Vector, modMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1518);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1516);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4341,7 +4330,7 @@ PHP_METHOD(Tensor_Vector, equalMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1542);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1540);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4422,7 +4411,7 @@ PHP_METHOD(Tensor_Vector, notEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1566);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1564);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4503,7 +4492,7 @@ PHP_METHOD(Tensor_Vector, greaterMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1590);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1588);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4584,7 +4573,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1614);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1612);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4665,7 +4654,7 @@ PHP_METHOD(Tensor_Vector, lessMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1638);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1636);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4746,7 +4735,7 @@ PHP_METHOD(Tensor_Vector, lessEqualMatrix)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A expects ", &_4$$3, " columns but Matrix B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1662);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1660);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4824,7 +4813,7 @@ PHP_METHOD(Tensor_Vector, multiplyVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1686);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1684);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4896,7 +4885,7 @@ PHP_METHOD(Tensor_Vector, divideVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1704);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1702);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -4968,7 +4957,7 @@ PHP_METHOD(Tensor_Vector, addVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1722);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1720);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5040,7 +5029,7 @@ PHP_METHOD(Tensor_Vector, subtractVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1740);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1738);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5112,7 +5101,7 @@ PHP_METHOD(Tensor_Vector, powVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1758);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1756);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5184,7 +5173,7 @@ PHP_METHOD(Tensor_Vector, modVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1776);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1774);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5257,7 +5246,7 @@ PHP_METHOD(Tensor_Vector, equalVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1795);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1793);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5329,7 +5318,7 @@ PHP_METHOD(Tensor_Vector, notEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1813);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1811);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5401,7 +5390,7 @@ PHP_METHOD(Tensor_Vector, greaterVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1831);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1829);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5473,7 +5462,7 @@ PHP_METHOD(Tensor_Vector, greaterEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1849);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1847);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5545,7 +5534,7 @@ PHP_METHOD(Tensor_Vector, lessVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1867);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1865);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -5617,7 +5606,7 @@ PHP_METHOD(Tensor_Vector, lessEqualVector)
 		ZEPHIR_CONCAT_SVSVS(&_7$$3, "Vector A requires ", &_4$$3, " elements but Vector B has ", &_6$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 2, &_7$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1885);
+		zephir_throw_exception_debug(&_2$$3, "tensor/vector.zep", 1883);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6128,7 +6117,7 @@ PHP_METHOD(Tensor_Vector, offsetSet)
 		Z_PARAM_ZVAL(values)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(2, 0, &index, &values);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2042);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2040);
 	return;
 }
 
@@ -6179,7 +6168,7 @@ PHP_METHOD(Tensor_Vector, offsetUnset)
 		Z_PARAM_ZVAL(index)
 	ZEND_PARSE_PARAMETERS_END();
 	zephir_fetch_params_without_memory_grow(1, 0, &index);
-	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2066);
+	ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(tensor_exceptions_runtimeexception_ce, "Vector cannot be mutated directly.", "tensor/vector.zep", 2064);
 	return;
 }
 
@@ -6237,7 +6226,7 @@ PHP_METHOD(Tensor_Vector, offsetGet)
 		ZEPHIR_CONCAT_SSVS(&_5$$3, "Element not found at", " offset ", &_4$$3, ".");
 		ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 2, &_5$$3);
 		zephir_check_call_status();
-		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2080);
+		zephir_throw_exception_debug(&_3$$3, "tensor/vector.zep", 2078);
 		ZEPHIR_MM_RESTORE();
 		return;
 	}
@@ -6345,13 +6334,13 @@ PHP_METHOD(Tensor_Vector, __unserialize)
 	zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__);
 	zephir_fetch_params(1, 1, 0, &data_param);
 	zephir_get_arrval(&data, data_param);
-	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2121);
+	zephir_array_fetch_string(&_0, &data, SL("data"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2119);
 	ZVAL_BOOL(&_1, 0);
 	ZEPHIR_CALL_SELF(&rebuilt, "fromArray", NULL, 0, &_0, &_1);
 	zephir_check_call_status();
 	zephir_read_property_cached(&_1, &rebuilt, _zephir_prop_0, 0, PH_NOISY_CC | PH_READONLY);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1, &_1);
-	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2124);
+	zephir_array_fetch_string(&_2, &data, SL("n"), PH_NOISY | PH_READONLY, "tensor/vector.zep", 2122);
 	zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 2, &_2);
 	ZEPHIR_MM_RESTORE();
 }
diff --git a/optimizers/TensorCovarianceOptimizer.php b/optimizers/TensorCovarianceOptimizer.php
new file mode 100644
index 0000000..82f7e75
--- /dev/null
+++ b/optimizers/TensorCovarianceOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorCovarianceOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor covariance accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/linear_algebra',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_covariance($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorCovarianceWithMeanOptimizer.php b/optimizers/TensorCovarianceWithMeanOptimizer.php
new file mode 100644
index 0000000..ec2a873
--- /dev/null
+++ b/optimizers/TensorCovarianceWithMeanOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorCovarianceWithMeanOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 4) {
+            throw new CompilerException(
+                'Tensor covariance with mean accepts exactly four arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/linear_algebra',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_covariance_with_mean($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]}, {$resolvedParams[3]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorInfNormOptimizer.php b/optimizers/TensorInfNormOptimizer.php
new file mode 100644
index 0000000..9fc5ba6
--- /dev/null
+++ b/optimizers/TensorInfNormOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorInfNormOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor matrix infinity norm accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_inf_norm($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatL1NormOptimizer.php b/optimizers/TensorMatL1NormOptimizer.php
new file mode 100644
index 0000000..bbe0a7e
--- /dev/null
+++ b/optimizers/TensorMatL1NormOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatL1NormOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor matrix L1 norm accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_mat_l1_norm($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatL2NormOptimizer.php b/optimizers/TensorMatL2NormOptimizer.php
new file mode 100644
index 0000000..0f2f006
--- /dev/null
+++ b/optimizers/TensorMatL2NormOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatL2NormOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor matrix L2 norm accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_mat_l2_norm($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatMaxNormOptimizer.php b/optimizers/TensorMatMaxNormOptimizer.php
new file mode 100644
index 0000000..1cbc41d
--- /dev/null
+++ b/optimizers/TensorMatMaxNormOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatMaxNormOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor matrix max norm accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_mat_max_norm($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixMeanOptimizer.php b/optimizers/TensorMatrixMeanOptimizer.php
new file mode 100644
index 0000000..63f2206
--- /dev/null
+++ b/optimizers/TensorMatrixMeanOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixMeanOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor matrix mean accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_mean($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixVarianceOptimizer.php b/optimizers/TensorMatrixVarianceOptimizer.php
new file mode 100644
index 0000000..76cd19b
--- /dev/null
+++ b/optimizers/TensorMatrixVarianceOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixVarianceOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor matrix variance accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_variance($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorMatrixVarianceWithMeanOptimizer.php b/optimizers/TensorMatrixVarianceWithMeanOptimizer.php
new file mode 100644
index 0000000..358fb67
--- /dev/null
+++ b/optimizers/TensorMatrixVarianceWithMeanOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorMatrixVarianceWithMeanOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 4) {
+            throw new CompilerException(
+                'Tensor matrix variance with mean accepts exactly four arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_matrix_variance_with_mean($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]}, {$resolvedParams[3]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorPNormOptimizer.php b/optimizers/TensorPNormOptimizer.php
new file mode 100644
index 0000000..95ddbe9
--- /dev/null
+++ b/optimizers/TensorPNormOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorPNormOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor p-norm accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_p_norm($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorReciprocalOptimizer.php b/optimizers/TensorReciprocalOptimizer.php
new file mode 100644
index 0000000..a8c8a99
--- /dev/null
+++ b/optimizers/TensorReciprocalOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorReciprocalOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 1) {
+            throw new CompilerException(
+                'Tensor reciprocal accepts exactly 1 argument, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/unary',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_reciprocal($symbol, {$resolvedParams[0]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorVecL1NormOptimizer.php b/optimizers/TensorVecL1NormOptimizer.php
new file mode 100644
index 0000000..48b8c46
--- /dev/null
+++ b/optimizers/TensorVecL1NormOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorVecL1NormOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor vector L1 norm accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_vec_l1_norm($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorVecL2NormOptimizer.php b/optimizers/TensorVecL2NormOptimizer.php
new file mode 100644
index 0000000..cb12588
--- /dev/null
+++ b/optimizers/TensorVecL2NormOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorVecL2NormOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor vector L2 norm accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_vec_l2_norm($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorVecMaxNormOptimizer.php b/optimizers/TensorVecMaxNormOptimizer.php
new file mode 100644
index 0000000..039883d
--- /dev/null
+++ b/optimizers/TensorVecMaxNormOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorVecMaxNormOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor vector max norm accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_vec_max_norm($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorVecMeanOptimizer.php b/optimizers/TensorVecMeanOptimizer.php
new file mode 100644
index 0000000..a7147a7
--- /dev/null
+++ b/optimizers/TensorVecMeanOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorVecMeanOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor vector mean accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_vec_mean($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorVecVarianceOptimizer.php b/optimizers/TensorVecVarianceOptimizer.php
new file mode 100644
index 0000000..f19cd66
--- /dev/null
+++ b/optimizers/TensorVecVarianceOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorVecVarianceOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 2) {
+            throw new CompilerException(
+                'Tensor vector variance accepts exactly two arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_vec_variance($symbol, {$resolvedParams[0]}, {$resolvedParams[1]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/optimizers/TensorVecVarianceWithMeanOptimizer.php b/optimizers/TensorVecVarianceWithMeanOptimizer.php
new file mode 100644
index 0000000..58ad40c
--- /dev/null
+++ b/optimizers/TensorVecVarianceWithMeanOptimizer.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Zephir\Optimizers\FunctionCall;
+
+use Zephir\Call;
+use Zephir\CompilationContext;
+use Zephir\CompiledExpression;
+use Zephir\HeadersManager;
+use Zephir\Exception\CompilerException;
+use Zephir\Optimizers\OptimizerAbstract;
+
+class TensorVecVarianceWithMeanOptimizer extends OptimizerAbstract
+{
+    /**
+     * @param mixed[] $expression
+     * @param Call $call
+     * @param CompilationContext $context
+     * @throws CompilerException
+     * @return CompiledExpression|bool
+     */
+    public function optimize(array $expression, Call $call, CompilationContext $context)
+    {
+        if (!isset($expression['parameters'])) {
+            return false;
+        }
+
+        if (count($expression['parameters']) !== 3) {
+            throw new CompilerException(
+                'Tensor vector variance with mean accepts exactly three arguments, ' . count($expression['parameters']) . 'given.',
+                $expression
+            );
+        }
+
+        $call->processExpectedReturn($context);
+
+        $symbolVariable = $call->getSymbolVariable();
+
+        if (empty($symbolVariable)) {
+            throw new CompilerException('Missing symbol variable.');
+        }
+
+        if ($symbolVariable->getType() !== 'variable') {
+            throw new CompilerException(
+                'Return value must only be assigned to a dynamic variable.',
+                $expression
+            );
+        }
+
+        if ($call->mustInitSymbolVariable()) {
+            $symbolVariable->initVariant($context);
+        }
+
+        $context->headersManager->add(
+            'include/reductions',
+            HeadersManager::POSITION_LAST
+        );
+
+        $resolvedParams = $call->getResolvedParams(
+            $expression['parameters'],
+            $context,
+            $expression
+        );
+
+        $symbol = $context->backend->getVariableCode($symbolVariable);
+
+        $context->codePrinter->output(
+            "tensor_vec_variance_with_mean($symbol, {$resolvedParams[0]}, {$resolvedParams[1]}, {$resolvedParams[2]});"
+        );
+
+        return new CompiledExpression(
+            'variable',
+            $symbolVariable->getRealName(),
+            $expression
+        );
+    }
+}
diff --git a/tensor/matrix.zep b/tensor/matrix.zep
index 7a570cc..fc58e7d 100644
--- a/tensor/matrix.zep
+++ b/tensor/matrix.zep
@@ -368,44 +368,37 @@ class Matrix implements Tensor
 
         var rowA, valueA;
 
-        var firstRow, n, aList;
-
-        int i;
-
-        let aList = array_values(a);
-
-        let firstRow = aList[0];
-
-        if unlikely !is_array(firstRow) {
-            throw new InvalidArgumentException("Matrix requires an"
-                . " array of arrays.");
-        }
-
-        let n = count(firstRow);
-
         array flat = [];
 
-        let i = 0;
+        int n = 0;
+        bool found = false;
 
-        while i < rows {
-            let rowA = aList[i];
+        for rowA in a {
+            if unlikely !found {
+                if unlikely !is_array(rowA) {
+                    throw new InvalidArgumentException("Matrix requires an"
+                        . " array of arrays.");
+                }
 
-            if unlikely validate && !is_array(rowA) {
-                throw new InvalidArgumentException("Matrix requires an"
-                    . " array of arrays.");
-            }
+                let n = count(rowA);
+
+                let found = true;
+            } else {
+                if unlikely validate && !is_array(rowA) {
+                    throw new InvalidArgumentException("Matrix requires an"
+                        . " array of arrays.");
+                }
 
-            if unlikely validate && count(rowA) !== n {
-                throw new InvalidArgumentException("The number of"
-                    . " columns must be equal for all rows, "
-                    .  strval(n) . " needed but " . count(rowA) . " given.");
+                if unlikely validate && count(rowA) !== n {
+                    throw new InvalidArgumentException("The number of"
+                        . " columns must be equal for all rows, "
+                        .  strval(n) . " needed but " . count(rowA) . " given.");
+                }
             }
 
             for valueA in rowA {
                 let flat[] = valueA;
             }
-
-            let i++;
         }
 
         var buffer = tensor_buffer_from_array(flat);
diff --git a/tensor/vector.zep b/tensor/vector.zep
index 9a9269a..08ed74f 100644
--- a/tensor/vector.zep
+++ b/tensor/vector.zep
@@ -271,20 +271,18 @@ class Vector implements Tensor
      */
     public static function fromArray(const array a, const bool validate = true) -> <Vector>
     {
-        var valueA;
+        var buffer, valueA;
 
-        array flat = [];
-
-        for valueA in (array) a {
-            if unlikely validate && is_array(valueA) {
-                throw new InvalidArgumentException("Vector requires a"
-                    . " flat array of numeric elements.");
+        if unlikely validate {
+            for valueA in (array) a {
+                if unlikely is_array(valueA) {
+                    throw new InvalidArgumentException("Vector requires a"
+                        . " flat array of numeric elements.");
+                }
             }
-
-            let flat[] = valueA;
         }
 
-        var buffer = tensor_buffer_from_array(flat);
+        let buffer = tensor_buffer_from_array(a);
 
         return new static(buffer);
     }
diff --git a/tests/MatrixTest.php b/tests/MatrixTest.php
index ebf92dc..5049861 100644
--- a/tests/MatrixTest.php
+++ b/tests/MatrixTest.php
@@ -90,6 +90,46 @@ public function buildCastsIntegersToFloatsAndPreservesShape() : void
         ], $result, self::MAX_DELTA);
     }
 
+    /**
+     * @test
+     */
+    public function fromArrayThrowsOnNonArrayRow() : void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        Matrix::fromArray([
+            [1.0, 2.0],
+            3.0,
+        ]);
+    }
+
+    /**
+     * @test
+     */
+    public function fromArrayThrowsOnRaggedColumns() : void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        Matrix::fromArray([
+            [1.0, 2.0],
+            [3.0],
+        ]);
+    }
+
+    /**
+     * @test
+     */
+    public function fromArraySkipsValidationWhenValidateFalse() : void
+    {
+        $matrix = Matrix::fromArray([
+            [1.0, 2.0],
+            [3.0],
+        ], false);
+
+        $this->assertInstanceOf(Matrix::class, $matrix);
+        $this->assertSame([2, 2], $matrix->shape());
+    }
+
     /**
      * @test
      */
diff --git a/tests/VectorTest.php b/tests/VectorTest.php
index cf8b4c5..215d7e7 100644
--- a/tests/VectorTest.php
+++ b/tests/VectorTest.php
@@ -69,6 +69,39 @@ public function buildCastsIntegersToFloats() : void
         $this->assertEqualsWithDelta([1.0, 2.0, 3.0, 4.0, 5.0], $result, self::MAX_DELTA);
     }
 
+    /**
+     * @test
+     */
+    public function fromArrayThrowsOnNestedArray() : void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        Vector::fromArray([1.0, [2.0], 3.0]);
+    }
+
+    /**
+     * @test
+     */
+    public function fromArraySkipsValidationWhenValidateFalse() : void
+    {
+        $expected = Vector::fromArray([1.0, 2.0, 3.0]);
+
+        $a = Vector::fromArray([1.0, 2.0, 3.0], false);
+
+        $this->assertInstanceOf(Vector::class, $a);
+        $this->assertEquals($expected->asArray(), $a->asArray());
+    }
+
+    /**
+     * @test
+     */
+    public function fromArrayDiscardsKeysPositionally() : void
+    {
+        $vector = Vector::fromArray([1 => 1.5, 0 => 2.5, 3 => 4.0]);
+
+        $this->assertEqualsWithDelta([1.5, 2.5, 4.0], $vector->asArray(), self::MAX_DELTA);
+    }
+
     /**
      * @test
      */

From b705ac589bfa58c51fb09e48eea02fdc246c0e1d Mon Sep 17 00:00:00 2001
From: Andrew DalPino <andrewdalpino@icloud.com>
Date: Thu, 24 Sep 2026 16:52:37 -0500
Subject: [PATCH 51/51] Optimize sum and product

---
 ext/include/reductions.c | 71 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 65 insertions(+), 6 deletions(-)

diff --git a/ext/include/reductions.c b/ext/include/reductions.c
index 5e3ad4f..530b77f 100644
--- a/ext/include/reductions.c
+++ b/ext/include/reductions.c
@@ -83,42 +83,99 @@ static double tensor_group_reduce(const uint8_t kind, const void * data, const z
 
 	if (mode == TENSOR_REDUCE_SUM) {
 		double acc = 0.0;
+		double u0 = 0.0, u1 = 0.0, u2 = 0.0, u3 = 0.0;
+		double u4 = 0.0, u5 = 0.0, u6 = 0.0, u7 = 0.0;
+
+		/* Accumulate into eight independent partial sums so the floating
+		 * point dependency chain no longer serializes the iterations, and
+		 * merge the partials in a small tree on the way out. The pairwise
+		 * merge also keeps the accumulated rounding error a fraction of the
+		 * naive serial sum. */
+		i = 0;
 
 		if (kind == ZEPHIR_BUFFER_LONG) {
 			const zend_long * ptr = (const zend_long *) data;
 
-			for (i = 0; i < len; ++i) {
+			for (; i + 7 < len; i += 8) {
+				u0 += (double) ptr[i];
+				u1 += (double) ptr[i + 1];
+				u2 += (double) ptr[i + 2];
+				u3 += (double) ptr[i + 3];
+				u4 += (double) ptr[i + 4];
+				u5 += (double) ptr[i + 5];
+				u6 += (double) ptr[i + 6];
+				u7 += (double) ptr[i + 7];
+			}
+
+			for (; i < len; ++i) {
 				acc += (double) ptr[i];
 			}
 		} else {
 			const double * ptr = (const double *) data;
 
-			for (i = 0; i < len; ++i) {
+			for (; i + 7 < len; i += 8) {
+				u0 += ptr[i];
+				u1 += ptr[i + 1];
+				u2 += ptr[i + 2];
+				u3 += ptr[i + 3];
+				u4 += ptr[i + 4];
+				u5 += ptr[i + 5];
+				u6 += ptr[i + 6];
+				u7 += ptr[i + 7];
+			}
+
+			for (; i < len; ++i) {
 				acc += ptr[i];
 			}
 		}
 
-		return acc;
+		return ((u0 + u1) + (u2 + u3)) + ((u4 + u5) + (u6 + u7)) + acc;
 	}
 
 	if (mode == TENSOR_REDUCE_PRODUCT) {
 		double acc = 1.0;
+		double u0 = 1.0, u1 = 1.0, u2 = 1.0, u3 = 1.0;
+		double u4 = 1.0, u5 = 1.0, u6 = 1.0, u7 = 1.0;
+
+		i = 0;
 
 		if (kind == ZEPHIR_BUFFER_LONG) {
 			const zend_long * ptr = (const zend_long *) data;
 
-			for (i = 0; i < len; ++i) {
+			for (; i + 7 < len; i += 8) {
+				u0 *= (double) ptr[i];
+				u1 *= (double) ptr[i + 1];
+				u2 *= (double) ptr[i + 2];
+				u3 *= (double) ptr[i + 3];
+				u4 *= (double) ptr[i + 4];
+				u5 *= (double) ptr[i + 5];
+				u6 *= (double) ptr[i + 6];
+				u7 *= (double) ptr[i + 7];
+			}
+
+			for (; i < len; ++i) {
 				acc *= (double) ptr[i];
 			}
 		} else {
 			const double * ptr = (const double *) data;
 
-			for (i = 0; i < len; ++i) {
+			for (; i + 7 < len; i += 8) {
+				u0 *= ptr[i];
+				u1 *= ptr[i + 1];
+				u2 *= ptr[i + 2];
+				u3 *= ptr[i + 3];
+				u4 *= ptr[i + 4];
+				u5 *= ptr[i + 5];
+				u6 *= ptr[i + 6];
+				u7 *= ptr[i + 7];
+			}
+
+			for (; i < len; ++i) {
 				acc *= ptr[i];
 			}
 		}
 
-		return acc;
+		return ((u0 * u1) * (u2 * u3)) * ((u4 * u5) * (u6 * u7)) * acc;
 	}
 
 	int find_min = mode == TENSOR_REDUCE_MIN || mode == TENSOR_REDUCE_ARGMIN;
@@ -235,6 +292,7 @@ static void tensor_reduce_apply(zval * return_value, zval * obj, zval * groups_z
 
 		for (i = 0; i < groupsHat; ++i) {
 			zend_long index = 0;
+
 			double value = tensor_group_reduce(kind, ptr + i * lengthHat, lengthHat, mode, &index);
 
 			vc[i] = (mode == TENSOR_REDUCE_ARGMIN || mode == TENSOR_REDUCE_ARGMAX)
@@ -245,6 +303,7 @@ static void tensor_reduce_apply(zval * return_value, zval * obj, zval * groups_z
 
 		for (i = 0; i < groupsHat; ++i) {
 			zend_long index = 0;
+			
 			double value = tensor_group_reduce(kind, ptr + i * lengthHat, lengthHat, mode, &index);
 
 			vc[i] = (mode == TENSOR_REDUCE_ARGMIN || mode == TENSOR_REDUCE_ARGMAX)