diff options
| -rw-r--r-- | .gitignore | 9 | ||||
| -rw-r--r-- | Makefile | 4 | ||||
| -rw-r--r-- | PHPINFO | 10 | ||||
| -rw-r--r-- | REFLECTION | 4042 | ||||
| -rw-r--r-- | php-pecl-tensor.spec | 211 | ||||
| -rw-r--r-- | tensor-headers.patch | 39 | ||||
| -rw-r--r-- | tensor-libs.patch | 15 |
7 files changed, 4330 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..01f0400 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +clog +package-*.xml +*.tgz +*.tar.bz2 +*.tar.gz +*.tar.xz +*.tar.xz.asc +*.src.rpm +*/*rpm diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..13af741 --- /dev/null +++ b/Makefile @@ -0,0 +1,4 @@ +SRCDIR := $(shell pwd) +NAME := $(shell basename $(SRCDIR)) +include ../../../common/Makefile + @@ -0,0 +1,10 @@ + +tensor + + +Tensor is a library and extension that provides objects for scientific computing in PHP. +tensor => enabled +Author => Andrew DalPino +Version => 2.1.3 +Build Date => Feb 15 2021 00:00:00 +Powered by Zephir => Version 0.12.20-$Id$ diff --git a/REFLECTION b/REFLECTION new file mode 100644 index 0000000..9f7ed85 --- /dev/null +++ b/REFLECTION @@ -0,0 +1,4042 @@ +Extension [ <persistent> extension #105 tensor version 2.1.3 ] { + + - Dependencies { + } + + - Classes [15] { + Interface [ <internal:tensor> interface Tensor\Arithmetic ] { + + - Constants [0] { + } + + - Static properties [0] { + } + + - Static methods [0] { + } + + - Properties [0] { + } + + - Methods [6] { + Method [ <internal:tensor> abstract public method multiply ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method divide ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method add ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method subtract ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method pow ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method mod ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + } + } + + Interface [ <internal:tensor> interface Tensor\ArrayLike extends ArrayAccess, IteratorAggregate, Traversable, Countable ] { + + - Constants [0] { + } + + - Static properties [0] { + } + + - Static methods [0] { + } + + - Properties [0] { + } + + - Methods [9] { + Method [ <internal:tensor> abstract public method shape ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor> abstract public method size ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor> abstract public method asArray ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:Core, inherits ArrayAccess> abstract public method offsetExists ] { + + - Parameters [1] { + Parameter #0 [ <required> $offset ] + } + } + + Method [ <internal:Core, inherits ArrayAccess> abstract public method offsetGet ] { + + - Parameters [1] { + Parameter #0 [ <required> $offset ] + } + } + + Method [ <internal:Core, inherits ArrayAccess> abstract public method offsetSet ] { + + - Parameters [2] { + Parameter #0 [ <required> $offset ] + Parameter #1 [ <required> $value ] + } + } + + Method [ <internal:Core, inherits ArrayAccess> abstract public method offsetUnset ] { + + - Parameters [1] { + Parameter #0 [ <required> $offset ] + } + } + + Method [ <internal:Core, inherits IteratorAggregate> abstract public method getIterator ] { + } + + Method [ <internal:Core, inherits Countable> abstract public method count ] { + + - Parameters [0] { + } + } + } + } + + Interface [ <internal:tensor> interface Tensor\Comparable ] { + + - Constants [0] { + } + + - Static properties [0] { + } + + - Static methods [0] { + } + + - Properties [0] { + } + + - Methods [6] { + Method [ <internal:tensor> abstract public method equal ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method notEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method greater ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method greaterEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method less ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> abstract public method lessEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + } + } + + Interface [ <internal:tensor> interface Tensor\Functional ] { + + - Constants [1] { + Constant [ public float M_E ] { 2.718281828459 } + } + + - Static properties [0] { + } + + - Static methods [0] { + } + + - Properties [0] { + } + + - Methods [16] { + Method [ <internal:tensor> abstract public method abs ] { + } + + Method [ <internal:tensor> abstract public method square ] { + } + + Method [ <internal:tensor> abstract public method sqrt ] { + } + + Method [ <internal:tensor> abstract public method exp ] { + } + + Method [ <internal:tensor> abstract public method expm1 ] { + } + + Method [ <internal:tensor> abstract public method log ] { + + - Parameters [1] { + Parameter #0 [ <optional> float $base ] + } + } + + Method [ <internal:tensor> abstract public method log1p ] { + } + + Method [ <internal:tensor> abstract public method sum ] { + } + + Method [ <internal:tensor> abstract public method product ] { + } + + Method [ <internal:tensor> abstract public method min ] { + } + + Method [ <internal:tensor> abstract public method max ] { + } + + Method [ <internal:tensor> abstract public method round ] { + + - Parameters [1] { + Parameter #0 [ <optional> int $precision ] + } + } + + Method [ <internal:tensor> abstract public method floor ] { + } + + Method [ <internal:tensor> abstract public method ceil ] { + } + + Method [ <internal:tensor> abstract public method sign ] { + } + + Method [ <internal:tensor> abstract public method negate ] { + } + } + } + + Interface [ <internal:tensor> interface Tensor\Statistical ] { + + - Constants [0] { + } + + - Static properties [0] { + } + + - Static methods [0] { + } + + - Properties [0] { + } + + - Methods [4] { + Method [ <internal:tensor> abstract public method mean ] { + } + + Method [ <internal:tensor> abstract public method variance ] { + + - Parameters [1] { + Parameter #0 [ <optional> $mean ] + } + } + + Method [ <internal:tensor> abstract public method median ] { + } + + Method [ <internal:tensor> abstract public method quantile ] { + + - Parameters [1] { + Parameter #0 [ <required> float $q ] + } + } + } + } + + Interface [ <internal:tensor> interface Tensor\Trigonometric ] { + + - Constants [2] { + Constant [ public float M_PI ] { 3.1415926535898 } + Constant [ public float TWO_PI ] { 6.28318530718 } + } + + - Static properties [0] { + } + + - Static methods [0] { + } + + - Properties [0] { + } + + - Methods [8] { + Method [ <internal:tensor> abstract public method sin ] { + } + + Method [ <internal:tensor> abstract public method asin ] { + } + + Method [ <internal:tensor> abstract public method cos ] { + } + + Method [ <internal:tensor> abstract public method acos ] { + } + + Method [ <internal:tensor> abstract public method tan ] { + } + + Method [ <internal:tensor> abstract public method atan ] { + } + + Method [ <internal:tensor> abstract public method rad2deg ] { + } + + Method [ <internal:tensor> abstract public method deg2rad ] { + } + } + } + + Interface [ <internal:tensor> interface Tensor\Tensor extends Tensor\ArrayLike, Countable, Traversable, IteratorAggregate, ArrayAccess, Tensor\Arithmetic, Tensor\Comparable, Tensor\Functional, Tensor\Trigonometric, Tensor\Statistical ] { + + - Constants [4] { + Constant [ public float EPSILON ] { 1.0E-8 } + Constant [ public float M_E ] { 2.718281828459 } + Constant [ public float M_PI ] { 3.1415926535898 } + Constant [ public float TWO_PI ] { 6.28318530718 } + } + + - Static properties [0] { + } + + - Static methods [0] { + } + + - Properties [0] { + } + + - Methods [57] { + Method [ <internal:tensor> abstract public method map ] { + + - Parameters [1] { + Parameter #0 [ <required> $callback ] + } + } + + Method [ <internal:tensor> abstract public method reduce ] { + + - Parameters [2] { + Parameter #0 [ <required> $callback ] + Parameter #1 [ <optional> $initial ] + } + } + + Method [ <internal:tensor> abstract public method transpose ] { + } + + Method [ <internal:tensor> abstract public method clip ] { + + - Parameters [2] { + Parameter #0 [ <required> float $min ] + Parameter #1 [ <required> float $max ] + } + } + + Method [ <internal:tensor> abstract public method clipLower ] { + + - Parameters [1] { + Parameter #0 [ <required> float $min ] + } + } + + Method [ <internal:tensor> abstract public method clipUpper ] { + + - Parameters [1] { + Parameter #0 [ <required> float $max ] + } + } + + Method [ <internal:tensor> abstract public method shapeString ] { + + - Parameters [0] { + } + - Return [ string ] + } + + Method [ <internal:tensor> abstract public method __toString ] { + + - Parameters [0] { + } + - Return [ string ] + } + + Method [ <internal:tensor, inherits Tensor\ArrayLike> abstract public method shape ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor, inherits Tensor\ArrayLike> abstract public method size ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, inherits Tensor\ArrayLike> abstract public method asArray ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:Core, inherits ArrayAccess> abstract public method offsetExists ] { + + - Parameters [1] { + Parameter #0 [ <required> $offset ] + } + } + + Method [ <internal:Core, inherits ArrayAccess> abstract public method offsetGet ] { + + - Parameters [1] { + Parameter #0 [ <required> $offset ] + } + } + + Method [ <internal:Core, inherits ArrayAccess> abstract public method offsetSet ] { + + - Parameters [2] { + Parameter #0 [ <required> $offset ] + Parameter #1 [ <required> $value ] + } + } + + Method [ <internal:Core, inherits ArrayAccess> abstract public method offsetUnset ] { + + - Parameters [1] { + Parameter #0 [ <required> $offset ] + } + } + + Method [ <internal:Core, inherits IteratorAggregate> abstract public method getIterator ] { + } + + Method [ <internal:Core, inherits Countable> abstract public method count ] { + + - Parameters [0] { + } + } + + Method [ <internal:tensor, inherits Tensor\Arithmetic> abstract public method multiply ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Arithmetic> abstract public method divide ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Arithmetic> abstract public method add ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Arithmetic> abstract public method subtract ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Arithmetic> abstract public method pow ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Arithmetic> abstract public method mod ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Comparable> abstract public method equal ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Comparable> abstract public method notEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Comparable> abstract public method greater ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Comparable> abstract public method greaterEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Comparable> abstract public method less ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Comparable> abstract public method lessEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method abs ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method square ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method sqrt ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method exp ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method expm1 ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method log ] { + + - Parameters [1] { + Parameter #0 [ <optional> float $base ] + } + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method log1p ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method sum ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method product ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method min ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method max ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method round ] { + + - Parameters [1] { + Parameter #0 [ <optional> int $precision ] + } + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method floor ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method ceil ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method sign ] { + } + + Method [ <internal:tensor, inherits Tensor\Functional> abstract public method negate ] { + } + + Method [ <internal:tensor, inherits Tensor\Trigonometric> abstract public method sin ] { + } + + Method [ <internal:tensor, inherits Tensor\Trigonometric> abstract public method asin ] { + } + + Method [ <internal:tensor, inherits Tensor\Trigonometric> abstract public method cos ] { + } + + Method [ <internal:tensor, inherits Tensor\Trigonometric> abstract public method acos ] { + } + + Method [ <internal:tensor, inherits Tensor\Trigonometric> abstract public method tan ] { + } + + Method [ <internal:tensor, inherits Tensor\Trigonometric> abstract public method atan ] { + } + + Method [ <internal:tensor, inherits Tensor\Trigonometric> abstract public method rad2deg ] { + } + + Method [ <internal:tensor, inherits Tensor\Trigonometric> abstract public method deg2rad ] { + } + + Method [ <internal:tensor, inherits Tensor\Statistical> abstract public method mean ] { + } + + Method [ <internal:tensor, inherits Tensor\Statistical> abstract public method variance ] { + + - Parameters [1] { + Parameter #0 [ <optional> $mean ] + } + } + + Method [ <internal:tensor, inherits Tensor\Statistical> abstract public method median ] { + } + + Method [ <internal:tensor, inherits Tensor\Statistical> abstract public method quantile ] { + + - Parameters [1] { + Parameter #0 [ <required> float $q ] + } + } + } + } + + Class [ <internal:tensor> <iterateable> class Tensor\Vector implements Tensor\Tensor, Tensor\Statistical, Tensor\Trigonometric, Tensor\Functional, Tensor\Comparable, Tensor\Arithmetic, ArrayAccess, IteratorAggregate, Traversable, Countable, Tensor\ArrayLike ] { + + - Constants [4] { + Constant [ public float EPSILON ] { 1.0E-8 } + Constant [ public float M_E ] { 2.718281828459 } + Constant [ public float M_PI ] { 3.1415926535898 } + Constant [ public float TWO_PI ] { 6.28318530718 } + } + + - Static properties [0] { + } + + - Static methods [13] { + Method [ <internal:tensor> static public method build ] { + + - Parameters [1] { + Parameter #0 [ <optional> array $a ] + } + } + + Method [ <internal:tensor> static public method quick ] { + + - Parameters [1] { + Parameter #0 [ <optional> array $a ] + } + } + + Method [ <internal:tensor> static public method zeros ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method ones ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method fill ] { + + - Parameters [2] { + Parameter #0 [ <required> $value ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method rand ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method gaussian ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method poisson ] { + + - Parameters [2] { + Parameter #0 [ <required> int $n ] + Parameter #1 [ <optional> float $lambda ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method uniform ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method range ] { + + - Parameters [3] { + Parameter #0 [ <required> $start ] + Parameter #1 [ <required> $end ] + Parameter #2 [ <optional> $interval ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method linspace ] { + + - Parameters [3] { + Parameter #0 [ <required> float $min ] + Parameter #1 [ <required> float $max ] + Parameter #2 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method maximum ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Vector $a ] + Parameter #1 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> static public method minimum ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Vector $a ] + Parameter #1 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + } + + - Properties [2] { + Property [ <default> protected $a ] + Property [ <default> protected $n ] + } + + - Methods [113] { + Method [ <internal:tensor, ctor> public method __construct ] { + + - Parameters [2] { + Parameter #0 [ <required> array $a ] + Parameter #1 [ <optional> bool $validate ] + } + } + + Method [ <internal:tensor, prototype Tensor\ArrayLike> public method shape ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method shapeString ] { + + - Parameters [0] { + } + - Return [ string ] + } + + Method [ <internal:tensor, prototype Tensor\ArrayLike> public method size ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor> public method m ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor> public method n ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, prototype Tensor\ArrayLike> public method asArray ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor> public method asRowMatrix ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method asColumnMatrix ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method reshape ] { + + - Parameters [2] { + Parameter #0 [ <required> int $m ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method transpose ] { + } + + Method [ <internal:tensor> public method argmin ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor> public method argmax ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method map ] { + + - Parameters [1] { + Parameter #0 [ <required> $callback ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method reduce ] { + + - Parameters [2] { + Parameter #0 [ <required> $callback ] + Parameter #1 [ <optional> $initial ] + } + } + + Method [ <internal:tensor> public method dot ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ float ] + } + + Method [ <internal:tensor> public method convolve ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Vector $b ] + Parameter #1 [ <optional> int $stride ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method matmul ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method inner ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + } + + Method [ <internal:tensor> public method outer ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method cross ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method project ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method l1Norm ] { + } + + Method [ <internal:tensor> public method l2Norm ] { + } + + Method [ <internal:tensor> public method pNorm ] { + + - Parameters [1] { + Parameter #0 [ <optional> float $p ] + } + } + + Method [ <internal:tensor> public method maxNorm ] { + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method multiply ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method divide ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method add ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method subtract ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method pow ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method mod ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method equal ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method notEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method greater ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method greaterEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method less ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method lessEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> public method reciprocal ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method abs ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method square ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method sqrt ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method exp ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method expm1 ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method log ] { + + - Parameters [1] { + Parameter #0 [ <optional> float $base ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method log1p ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method sin ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method asin ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method cos ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method acos ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method tan ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method atan ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method rad2deg ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method deg2rad ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method sum ] { + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method product ] { + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method min ] { + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method max ] { + } + + Method [ <internal:tensor, prototype Tensor\Statistical> public method mean ] { + } + + Method [ <internal:tensor, prototype Tensor\Statistical> public method median ] { + } + + Method [ <internal:tensor, prototype Tensor\Statistical> public method quantile ] { + + - Parameters [1] { + Parameter #0 [ <required> float $q ] + } + } + + Method [ <internal:tensor, prototype Tensor\Statistical> public method variance ] { + + - Parameters [1] { + Parameter #0 [ <optional> $mean ] + } + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method round ] { + + - Parameters [1] { + Parameter #0 [ <optional> int $precision ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method floor ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method ceil ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method clip ] { + + - Parameters [2] { + Parameter #0 [ <required> float $min ] + Parameter #1 [ <required> float $max ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method clipLower ] { + + - Parameters [1] { + Parameter #0 [ <required> float $min ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method clipUpper ] { + + - Parameters [1] { + Parameter #0 [ <required> float $max ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method sign ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method negate ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method multiplyMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method divideMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method addMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method subtractMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method powMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method modMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method equalMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method notEqualMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterEqualMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessEqualMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method multiplyVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method divideVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method addVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method subtractVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method powVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method modVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method equalVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method notEqualVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method greaterVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method greaterEqualVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method lessVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method lessEqualVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method multiplyScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method divideScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method addScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method subtractScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method powScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method modScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method equalScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method notEqualScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method greaterScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method greaterEqualScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method lessScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method lessEqualScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Countable> public method count ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, prototype ArrayAccess> public method offsetSet ] { + + - Parameters [2] { + Parameter #0 [ <required> $index ] + Parameter #1 [ <required> $values ] + } + - Return [ void ] + } + + Method [ <internal:tensor, prototype ArrayAccess> public method offsetExists ] { + + - Parameters [1] { + Parameter #0 [ <required> $index ] + } + - Return [ bool ] + } + + Method [ <internal:tensor, prototype ArrayAccess> public method offsetUnset ] { + + - Parameters [1] { + Parameter #0 [ <required> $index ] + } + - Return [ void ] + } + + Method [ <internal:tensor, prototype ArrayAccess> public method offsetGet ] { + + - Parameters [1] { + Parameter #0 [ <required> $index ] + } + } + + Method [ <internal:tensor, prototype IteratorAggregate> public method getIterator ] { + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method __toString ] { + + - Parameters [0] { + } + - Return [ string ] + } + } + } + + Class [ <internal:tensor> <iterateable> class Tensor\ColumnVector extends Tensor\Vector implements Tensor\ArrayLike, Countable, Traversable, IteratorAggregate, ArrayAccess, Tensor\Arithmetic, Tensor\Comparable, Tensor\Functional, Tensor\Trigonometric, Tensor\Statistical, Tensor\Tensor ] { + + - Constants [4] { + Constant [ public float EPSILON ] { 1.0E-8 } + Constant [ public float M_E ] { 2.718281828459 } + Constant [ public float M_PI ] { 3.1415926535898 } + Constant [ public float TWO_PI ] { 6.28318530718 } + } + + - Static properties [0] { + } + + - Static methods [13] { + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> static public method build ] { + + - Parameters [1] { + Parameter #0 [ <optional> array $a ] + } + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> static public method quick ] { + + - Parameters [1] { + Parameter #0 [ <optional> array $a ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method zeros ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method ones ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method fill ] { + + - Parameters [2] { + Parameter #0 [ <required> $value ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method rand ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method gaussian ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method poisson ] { + + - Parameters [2] { + Parameter #0 [ <required> int $n ] + Parameter #1 [ <optional> float $lambda ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method uniform ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method range ] { + + - Parameters [3] { + Parameter #0 [ <required> $start ] + Parameter #1 [ <required> $end ] + Parameter #2 [ <optional> $interval ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method linspace ] { + + - Parameters [3] { + Parameter #0 [ <required> float $min ] + Parameter #1 [ <required> float $max ] + Parameter #2 [ <required> int $n ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method maximum ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Vector $a ] + Parameter #1 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> static public method minimum ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Vector $a ] + Parameter #1 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + } + + - Properties [2] { + Property [ <default> protected $a ] + Property [ <default> protected $n ] + } + + - Methods [113] { + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method m ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method n ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Tensor> public method transpose ] { + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method matmul ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method multiplyMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method divideMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method addMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method subtractMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method powMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method modMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method equalMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method notEqualMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method greaterMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method greaterEqualMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method lessMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, overwrites Tensor\Vector, prototype Tensor\Vector> public method lessEqualMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, ctor> public method __construct ] { + + - Parameters [2] { + Parameter #0 [ <required> array $a ] + Parameter #1 [ <optional> bool $validate ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\ArrayLike> public method shape ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Tensor> public method shapeString ] { + + - Parameters [0] { + } + - Return [ string ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\ArrayLike> public method size ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\ArrayLike> public method asArray ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method asRowMatrix ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method asColumnMatrix ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method reshape ] { + + - Parameters [2] { + Parameter #0 [ <required> int $m ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method argmin ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method argmax ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Tensor> public method map ] { + + - Parameters [1] { + Parameter #0 [ <required> $callback ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Tensor> public method reduce ] { + + - Parameters [2] { + Parameter #0 [ <required> $callback ] + Parameter #1 [ <optional> $initial ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method dot ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ float ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method convolve ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Vector $b ] + Parameter #1 [ <optional> int $stride ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method inner ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method outer ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method cross ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method project ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method l1Norm ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method l2Norm ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method pNorm ] { + + - Parameters [1] { + Parameter #0 [ <optional> float $p ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method maxNorm ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Arithmetic> public method multiply ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Arithmetic> public method divide ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Arithmetic> public method add ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Arithmetic> public method subtract ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Arithmetic> public method pow ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Arithmetic> public method mod ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Comparable> public method equal ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Comparable> public method notEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Comparable> public method greater ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Comparable> public method greaterEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Comparable> public method less ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Comparable> public method lessEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method reciprocal ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method abs ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method square ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method sqrt ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method exp ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method expm1 ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method log ] { + + - Parameters [1] { + Parameter #0 [ <optional> float $base ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method log1p ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Trigonometric> public method sin ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Trigonometric> public method asin ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Trigonometric> public method cos ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Trigonometric> public method acos ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Trigonometric> public method tan ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Trigonometric> public method atan ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Trigonometric> public method rad2deg ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Trigonometric> public method deg2rad ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method sum ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method product ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method min ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method max ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Statistical> public method mean ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Statistical> public method median ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Statistical> public method quantile ] { + + - Parameters [1] { + Parameter #0 [ <required> float $q ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Statistical> public method variance ] { + + - Parameters [1] { + Parameter #0 [ <optional> $mean ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method round ] { + + - Parameters [1] { + Parameter #0 [ <optional> int $precision ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method floor ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method ceil ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Tensor> public method clip ] { + + - Parameters [2] { + Parameter #0 [ <required> float $min ] + Parameter #1 [ <required> float $max ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Tensor> public method clipLower ] { + + - Parameters [1] { + Parameter #0 [ <required> float $min ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Tensor> public method clipUpper ] { + + - Parameters [1] { + Parameter #0 [ <required> float $max ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method sign ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Functional> public method negate ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method multiplyVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method divideVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method addVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method subtractVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method powVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method modVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method equalVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method notEqualVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method greaterVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method greaterEqualVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method lessVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method lessEqualVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method multiplyScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method divideScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method addScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method subtractScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method powScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method modScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method equalScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method notEqualScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method greaterScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method greaterEqualScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method lessScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector> public method lessEqualScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Countable> public method count ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype ArrayAccess> public method offsetSet ] { + + - Parameters [2] { + Parameter #0 [ <required> $index ] + Parameter #1 [ <required> $values ] + } + - Return [ void ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype ArrayAccess> public method offsetExists ] { + + - Parameters [1] { + Parameter #0 [ <required> $index ] + } + - Return [ bool ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype ArrayAccess> public method offsetUnset ] { + + - Parameters [1] { + Parameter #0 [ <required> $index ] + } + - Return [ void ] + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype ArrayAccess> public method offsetGet ] { + + - Parameters [1] { + Parameter #0 [ <required> $index ] + } + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype IteratorAggregate> public method getIterator ] { + } + + Method [ <internal:tensor, inherits Tensor\Vector, prototype Tensor\Tensor> public method __toString ] { + + - Parameters [0] { + } + - Return [ string ] + } + } + } + + Class [ <internal:tensor> class Tensor\Decompositions\Cholesky ] { + + - Constants [0] { + } + + - Static properties [0] { + } + + - Static methods [1] { + Method [ <internal:tensor> static public method decompose ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $a ] + } + - Return [ Tensor\Decompositions\Cholesky ] + } + } + + - Properties [1] { + Property [ <default> protected $l ] + } + + - Methods [3] { + Method [ <internal:tensor, ctor> public method __construct ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $l ] + } + } + + Method [ <internal:tensor> public method l ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lT ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + } + } + + Class [ <internal:tensor> class Tensor\Decompositions\Lu ] { + + - Constants [1] { + Constant [ public float EPSILON ] { 1.0E-8 } + } + + - Static properties [0] { + } + + - Static methods [1] { + Method [ <internal:tensor> static public method decompose ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $a ] + } + - Return [ Tensor\Decompositions\Lu ] + } + } + + - Properties [3] { + Property [ <default> protected $l ] + Property [ <default> protected $u ] + Property [ <default> protected $p ] + } + + - Methods [4] { + Method [ <internal:tensor, ctor> public method __construct ] { + + - Parameters [3] { + Parameter #0 [ <required> Tensor\Matrix $l ] + Parameter #1 [ <required> Tensor\Matrix $u ] + Parameter #2 [ <required> Tensor\Matrix $p ] + } + } + + Method [ <internal:tensor> public method l ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method u ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method p ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + } + } + + Class [ <internal:tensor> <iterateable> class Tensor\Matrix implements Tensor\Tensor, Tensor\Statistical, Tensor\Trigonometric, Tensor\Functional, Tensor\Comparable, Tensor\Arithmetic, ArrayAccess, IteratorAggregate, Traversable, Countable, Tensor\ArrayLike ] { + + - Constants [4] { + Constant [ public float EPSILON ] { 1.0E-8 } + Constant [ public float M_E ] { 2.718281828459 } + Constant [ public float M_PI ] { 3.1415926535898 } + Constant [ public float TWO_PI ] { 6.28318530718 } + } + + - Static properties [0] { + } + + - Static methods [15] { + Method [ <internal:tensor> static public method build ] { + + - Parameters [1] { + Parameter #0 [ <optional> array $a ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method quick ] { + + - Parameters [1] { + Parameter #0 [ <optional> array $a ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method identity ] { + + - Parameters [1] { + Parameter #0 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method zeros ] { + + - Parameters [2] { + Parameter #0 [ <required> int $m ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method ones ] { + + - Parameters [2] { + Parameter #0 [ <required> int $m ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method diagonal ] { + + - Parameters [1] { + Parameter #0 [ <required> array $elements ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method fill ] { + + - Parameters [3] { + Parameter #0 [ <required> $value ] + Parameter #1 [ <required> int $m ] + Parameter #2 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method rand ] { + + - Parameters [2] { + Parameter #0 [ <required> int $m ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method gaussian ] { + + - Parameters [2] { + Parameter #0 [ <required> int $m ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method poisson ] { + + - Parameters [3] { + Parameter #0 [ <required> int $m ] + Parameter #1 [ <required> int $n ] + Parameter #2 [ <optional> float $lambda ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method uniform ] { + + - Parameters [2] { + Parameter #0 [ <required> int $m ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method minimum ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Matrix $a ] + Parameter #1 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method maximum ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Matrix $a ] + Parameter #1 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static public method stack ] { + + - Parameters [1] { + Parameter #0 [ <required> array $vectors ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> static protected method implodeRow ] { + + - Parameters [2] { + Parameter #0 [ <required> string $carry ] + Parameter #1 [ <required> array $row ] + } + - Return [ string ] + } + } + + - Properties [3] { + Property [ <default> protected $a ] + Property [ <default> protected $m ] + Property [ <default> protected $n ] + } + + - Methods [148] { + Method [ <internal:tensor, ctor> public method __construct ] { + + - Parameters [2] { + Parameter #0 [ <required> array $a ] + Parameter #1 [ <optional> bool $validate ] + } + } + + Method [ <internal:tensor, prototype Tensor\ArrayLike> public method shape ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method shapeString ] { + + - Parameters [0] { + } + - Return [ string ] + } + + Method [ <internal:tensor> public method isSquare ] { + + - Parameters [0] { + } + - Return [ bool ] + } + + Method [ <internal:tensor, prototype Tensor\ArrayLike> public method size ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor> public method m ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor> public method n ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor> public method row ] { + + - Parameters [1] { + Parameter #0 [ <required> int $index ] + } + - Return [ array ] + } + + Method [ <internal:tensor> public method rowAsVector ] { + + - Parameters [1] { + Parameter #0 [ <required> int $index ] + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method column ] { + + - Parameters [1] { + Parameter #0 [ <required> int $index ] + } + - Return [ array ] + } + + Method [ <internal:tensor> public method columnAsVector ] { + + - Parameters [1] { + Parameter #0 [ <required> int $index ] + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor> public method diagonalAsVector ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor, prototype Tensor\ArrayLike> public method asArray ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor> public method asVectors ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor> public method asColumnVectors ] { + + - Parameters [0] { + } + - Return [ array ] + } + + Method [ <internal:tensor> public method flatten ] { + + - Parameters [0] { + } + - Return [ Tensor\Vector ] + } + + Method [ <internal:tensor> public method argmin ] { + + - Parameters [0] { + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor> public method argmax ] { + + - Parameters [0] { + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method map ] { + + - Parameters [1] { + Parameter #0 [ <required> $callback ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method reduce ] { + + - Parameters [2] { + Parameter #0 [ <required> $callback ] + Parameter #1 [ <optional> $initial ] + } + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method transpose ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method inverse ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method det ] { + } + + Method [ <internal:tensor> public method rank ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor> public method fullRank ] { + + - Parameters [0] { + } + - Return [ bool ] + } + + Method [ <internal:tensor> public method symmetric ] { + + - Parameters [0] { + } + - Return [ bool ] + } + + Method [ <internal:tensor> public method positiveDefinite ] { + + - Parameters [0] { + } + - Return [ bool ] + } + + Method [ <internal:tensor> public method positiveSemidefinite ] { + + - Parameters [0] { + } + - Return [ bool ] + } + + Method [ <internal:tensor> public method matmul ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method dot ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor> public method convolve ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Matrix $b ] + Parameter #1 [ <optional> int $stride ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method ref ] { + + - Parameters [0] { + } + - Return [ Tensor\Reductions\Ref ] + } + + Method [ <internal:tensor> public method rref ] { + + - Parameters [0] { + } + - Return [ Tensor\Reductions\Rref ] + } + + Method [ <internal:tensor> public method lu ] { + + - Parameters [0] { + } + - Return [ Tensor\Decompositions\Lu ] + } + + Method [ <internal:tensor> public method cholesky ] { + + - Parameters [0] { + } + - Return [ Tensor\Decompositions\Cholesky ] + } + + Method [ <internal:tensor> public method eig ] { + + - Parameters [1] { + Parameter #0 [ <optional> bool $normalize ] + } + - Return [ Tensor\Eigen ] + } + + Method [ <internal:tensor> public method solve ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor> public method l1Norm ] { + } + + Method [ <internal:tensor> public method l2Norm ] { + } + + Method [ <internal:tensor> public method infinityNorm ] { + } + + Method [ <internal:tensor> public method maxNorm ] { + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method multiply ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method divide ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method add ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method subtract ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method pow ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Arithmetic> public method mod ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method equal ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method notEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method greater ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method greaterEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method less ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor, prototype Tensor\Comparable> public method lessEqual ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + } + + Method [ <internal:tensor> public method reciprocal ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method abs ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method square ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method sqrt ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method exp ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method expm1 ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method log ] { + + - Parameters [1] { + Parameter #0 [ <optional> float $base ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method log1p ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method sin ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method asin ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method cos ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method acos ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method tan ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method atan ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method rad2deg ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Trigonometric> public method deg2rad ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method sum ] { + + - Parameters [0] { + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method product ] { + + - Parameters [0] { + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method min ] { + + - Parameters [0] { + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method max ] { + + - Parameters [0] { + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor, prototype Tensor\Statistical> public method mean ] { + + - Parameters [0] { + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor, prototype Tensor\Statistical> public method median ] { + + - Parameters [0] { + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor, prototype Tensor\Statistical> public method quantile ] { + + - Parameters [1] { + Parameter #0 [ <required> float $q ] + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor, prototype Tensor\Statistical> public method variance ] { + + - Parameters [1] { + Parameter #0 [ <optional> $mean ] + } + - Return [ Tensor\ColumnVector ] + } + + Method [ <internal:tensor> public method covariance ] { + + - Parameters [1] { + Parameter #0 [ <optional> Tensor\ColumnVector or NULL $mean ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method round ] { + + - Parameters [1] { + Parameter #0 [ <optional> int $precision ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method floor ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method ceil ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method clip ] { + + - Parameters [2] { + Parameter #0 [ <required> float $min ] + Parameter #1 [ <required> float $max ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method clipLower ] { + + - Parameters [1] { + Parameter #0 [ <required> float $min ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method clipUpper ] { + + - Parameters [1] { + Parameter #0 [ <required> float $max ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method sign ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Tensor\Functional> public method negate ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method insert ] { + + - Parameters [3] { + Parameter #0 [ <required> Tensor\Matrix $b ] + Parameter #1 [ <required> int $rowOffset ] + Parameter #2 [ <required> int $columnOffset ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method subMatrix ] { + + - Parameters [4] { + Parameter #0 [ <required> int $startRow ] + Parameter #1 [ <required> int $startColumn ] + Parameter #2 [ <required> int $endRow ] + Parameter #3 [ <required> int $endColumn ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method augmentAbove ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method augmentBelow ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method augmentLeft ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method augmentRight ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method repeat ] { + + - Parameters [2] { + Parameter #0 [ <required> int $m ] + Parameter #1 [ <required> int $n ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method multiplyMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method divideMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method addMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method subtractMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method powMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method modMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method equalMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method notEqualMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterEqualMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessEqualMatrix ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method multiplyVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method divideVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method addVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method subtractVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method powVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method modVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method equalVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method notEqualVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterEqualVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessEqualVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Vector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method multiplyColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method divideColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method addColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method subtractColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method powColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method modColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method equalColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method notEqualColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterEqualColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessEqualColumnVector ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\ColumnVector $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method multiplyScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method divideScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method addScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method subtractScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method powScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method modScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method equalScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method notEqualScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method greaterEqualScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method lessEqualScalar ] { + + - Parameters [1] { + Parameter #0 [ <required> $b ] + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor, prototype Countable> public method count ] { + + - Parameters [0] { + } + - Return [ int ] + } + + Method [ <internal:tensor, prototype ArrayAccess> public method offsetSet ] { + + - Parameters [2] { + Parameter #0 [ <required> $index ] + Parameter #1 [ <required> $values ] + } + - Return [ void ] + } + + Method [ <internal:tensor, prototype ArrayAccess> public method offsetExists ] { + + - Parameters [1] { + Parameter #0 [ <required> $index ] + } + - Return [ bool ] + } + + Method [ <internal:tensor, prototype ArrayAccess> public method offsetUnset ] { + + - Parameters [1] { + Parameter #0 [ <required> $index ] + } + - Return [ void ] + } + + Method [ <internal:tensor, prototype ArrayAccess> public method offsetGet ] { + + - Parameters [1] { + Parameter #0 [ <required> $index ] + } + - Return [ array ] + } + + Method [ <internal:tensor, prototype IteratorAggregate> public method getIterator ] { + } + + Method [ <internal:tensor, prototype Tensor\Tensor> public method __toString ] { + + - Parameters [0] { + } + - Return [ string ] + } + } + } + + Class [ <internal:tensor> class Tensor\Reductions\Ref ] { + + - Constants [0] { + } + + - Static properties [0] { + } + + - Static methods [3] { + Method [ <internal:tensor> static public method reduce ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $a ] + } + - Return [ Tensor\Reductions\Ref ] + } + + Method [ <internal:tensor> static public method gaussianElimination ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $a ] + } + - Return [ Tensor\Reductions\Ref ] + } + + Method [ <internal:tensor> static public method rowReductionMethod ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $a ] + } + - Return [ Tensor\Reductions\Ref ] + } + } + + - Properties [2] { + Property [ <default> protected $a ] + Property [ <default> protected $swaps ] + } + + - Methods [3] { + Method [ <internal:tensor, ctor> public method __construct ] { + + - Parameters [2] { + Parameter #0 [ <required> Tensor\Matrix $a ] + Parameter #1 [ <required> int $swaps ] + } + } + + Method [ <internal:tensor> public method a ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + + Method [ <internal:tensor> public method swaps ] { + + - Parameters [0] { + } + - Return [ int ] + } + } + } + + Class [ <internal:tensor> class Tensor\Reductions\Rref ] { + + - Constants [0] { + } + + - Static properties [0] { + } + + - Static methods [1] { + Method [ <internal:tensor> static public method reduce ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $a ] + } + - Return [ Tensor\Reductions\Rref ] + } + } + + - Properties [1] { + Property [ <default> protected $a ] + } + + - Methods [2] { + Method [ <internal:tensor, ctor> public method __construct ] { + + - Parameters [1] { + Parameter #0 [ <required> Tensor\Matrix $a ] + } + } + + Method [ <internal:tensor> public method a ] { + + - Parameters [0] { + } + - Return [ Tensor\Matrix ] + } + } + } + + Class [ <internal:tensor> class Tensor\Settings ] { + + - Constants [0] { + } + + - Static properties [0] { + } + + - Static methods [2] { + Method [ <internal:tensor> static public method setNumThreads ] { + + - Parameters [1] { + Parameter #0 [ <required> int $threads ] + } + - Return [ void ] + } + + Method [ <internal:tensor> static public method numThreads ] { + + - Parameters [0] { + } + - Return [ int ] + } + } + + - Properties [0] { + } + + - Methods [0] { + } + } + } +} + diff --git a/php-pecl-tensor.spec b/php-pecl-tensor.spec new file mode 100644 index 0000000..e1740dd --- /dev/null +++ b/php-pecl-tensor.spec @@ -0,0 +1,211 @@ +# remirepo spec file for php-pecl-tensor +# +# Copyright (c) 2020-2021 Remi Collet +# License: CC-BY-SA +# http://creativecommons.org/licenses/by-sa/4.0/ +# +# Please, preserve the changelog entries +# +%if 0%{?scl:1} +%global sub_prefix %{scl_prefix} +%scl_package php-pecl-tensor +%endif + +%global pecl_name tensor +%global with_zts 0%{!?_without_zts:%{?__ztsphp:1}} +# After 20-json +%global ini_name 40-%{pecl_name}.ini + +%global upstream_version 2.1.03 +#global upstream_prever alpha2 + +Summary: Objects for scientific computing in PHP +Name: %{?sub_prefix}php-pecl-%{pecl_name} +Version: %{upstream_version}%{?upstream_prever:~%{upstream_prever}} +Release: 1%{?dist}%{!?scl:%{!?nophptag:%(%{__php} -r 'echo ".".PHP_MAJOR_VERSION.".".PHP_MINOR_VERSION;')}} +License: BSD +URL: https://pecl.php.net/package/%{pecl_name} +Source0: https://pecl.php.net/get/%{pecl_name}-%{upstream_version}%{?upstream_prever}.tgz + +Patch0: tensor-headers.patch +Patch1: tensor-libs.patch + +BuildRequires: make +BuildRequires: %{?dtsprefix}gcc +BuildRequires: %{?scl_prefix}php-devel >= 7.2 +BuildRequires: %{?scl_prefix}php-pear +BuildRequires: %{?scl_prefix}php-json +BuildRequires: openblas-devel + +Requires: %{?scl_prefix}php(zend-abi) = %{php_zend_api} +Requires: %{?scl_prefix}php(api) = %{php_core_api} +Requires: %{?scl_prefix}php-json%{?_isa} +Requires: %{?scl_prefix}php-pdo%{?_isa} +%{?_sclreq:Requires: %{?scl_prefix}runtime%{?_sclreq}%{?_isa}} + +Provides: %{?scl_prefix}php-%{pecl_name} = %{version} +Provides: %{?scl_prefix}php-%{pecl_name}%{?_isa} = %{version} +Provides: %{?scl_prefix}php-pecl(%{pecl_name}) = %{version} +Provides: %{?scl_prefix}php-pecl(%{pecl_name})%{?_isa} = %{version} +Provides: %{?scl_prefix}php-pecl-%{pecl_name} = %{version}-%{release} +Provides: %{?scl_prefix}php-pecl-%{pecl_name}%{?_isa} = %{version}-%{release} + +%if "%{?packager}" == "Remi Collet" && 0%{!?scl:1} && 0%{?rhel} +# Other third party repo stuff +%if "%{php_version}" > "8.0" +Obsoletes: php73-pecl-%{pecl_name} <= %{version} +%endif +%if "%{php_version}" > "8.0" +Obsoletes: php74-pecl-%{pecl_name} <= %{version} +%endif +%if "%{php_version}" > "8.0" +Obsoletes: php80-pecl-%{pecl_name} <= %{version} +%endif +%endif + + +%description +Tensor is a library and extension that provides objects for scientific +computing in PHP. + +Package built for PHP %(%{__php} -r 'echo PHP_MAJOR_VERSION.".".PHP_MINOR_VERSION;')%{?scl: as Software Collection (%{scl} by %{?scl_vendor}%{!?scl_vendor:rh})}. + + +%prep +%setup -q -c + +# Don't install/register tests +sed -e 's/role="test"/role="src"/' \ + %{?_licensedir:-e '/LICENSE/s/role="doc"/role="src"/' } \ + -i package.xml + +mv %{pecl_name}-%{upstream_version}%{?upstream_prever} NTS + +cd NTS +%patch0 -p1 -b .headers +%patch1 -p1 -b .libs + +# Sanity check, really often broken +extver=$(sed -n '/#define PHP_TENSOR_VERSION/{s/.* "//;s/".*$//;p}' ext/php_tensor.h) +if test "x${extver}" != "x%{upstream_version}%{?upstream_prever}"; then + : Error: Upstream extension version is ${extver}, expecting %{upstream_version}%{?upstream_prever}. + #exit 1 +fi +cd .. + +%if %{with_zts} +# Duplicate source tree for NTS / ZTS build +cp -pr NTS ZTS +%endif + +# Create configuration file +cat > %{ini_name} << 'EOF' +; Enable %{pecl_name} extension module +extension=%{pecl_name}.so +EOF + + +%build +%{?dtsenable} + +cd NTS/ext +%{_bindir}/phpize +%configure \ + --enable-tensor \ + --with-libdir=%{_lib} \ + --with-php-config=%{_bindir}/php-config + +make %{?_smp_mflags} + +%if %{with_zts} +cd ../../ZTS/ext +%{_bindir}/zts-phpize +%configure \ + --enable-tensor \ + --with-libdir=%{_lib} \ + --with-php-config=%{_bindir}/zts-php-config + +make %{?_smp_mflags} +%endif + + +%install +%{?dtsenable} + +make -C NTS/ext install INSTALL_ROOT=%{buildroot} + +# install config file +install -D -m 644 %{ini_name} %{buildroot}%{php_inidir}/%{ini_name} + +# Install XML package description +install -D -m 644 package.xml %{buildroot}%{pecl_xmldir}/%{name}.xml + +%if %{with_zts} +make -C ZTS/ext install INSTALL_ROOT=%{buildroot} +install -D -m 644 %{ini_name} %{buildroot}%{php_ztsinidir}/%{ini_name} +%endif + +# Documentation +cd NTS +for i in $(grep 'role="doc"' ../package.xml | sed -e 's/^.*name="//;s/".*$//') +do install -Dpm 644 $i %{buildroot}%{pecl_docdir}/%{pecl_name}/$i +done + + +%if 0%{?fedora} < 24 && 0%{?rhel} < 8 +# when pear installed alone, after us +%triggerin -- %{?scl_prefix}php-pear +if [ -x %{__pecl} ] ; then + %{pecl_install} %{pecl_xmldir}/%{name}.xml >/dev/null || : +fi + +# posttrans as pear can be installed after us +%posttrans +if [ -x %{__pecl} ] ; then + %{pecl_install} %{pecl_xmldir}/%{name}.xml >/dev/null || : +fi + +%postun +if [ $1 -eq 0 -a -x %{__pecl} ] ; then + %{pecl_uninstall} %{pecl_name} >/dev/null || : +fi +%endif + + +%check +: Minimal load test for NTS extension +%{_bindir}/php --no-php-ini \ + --define extension=json.so \ + --define extension=%{buildroot}%{php_extdir}/%{pecl_name}.so \ + --modules | grep '^%{pecl_name}$' + +%if %{with_zts} +: Minimal load test for ZTS extension +%{__ztsphp} --no-php-ini \ + --define extension=json.so \ + --define extension=%{buildroot}%{php_ztsextdir}/%{pecl_name}.so \ + --modules | grep '^%{pecl_name}$' +%endif + + +%files +%{?_licensedir:%license NTS/LICENSE} +%doc %{pecl_docdir}/%{pecl_name} +%{pecl_xmldir}/%{name}.xml + +%config(noreplace) %{php_inidir}/%{ini_name} +%{php_extdir}/%{pecl_name}.so + +%if %{with_zts} +%config(noreplace) %{php_ztsinidir}/%{ini_name} +%{php_ztsextdir}/%{pecl_name}.so +%endif + + +%changelog +* Mon Feb 15 2021 Remi Collet <remi@remirepo.net> - 1.8.0~alpha2-1 +- initial package +- open https://github.com/RubixML/Tensor/pull/11 + check for openblas headers +- open https://github.com/RubixML/Tensor/issues/12 + PHP 8 compatibility diff --git a/tensor-headers.patch b/tensor-headers.patch new file mode 100644 index 0000000..e2fed73 --- /dev/null +++ b/tensor-headers.patch @@ -0,0 +1,39 @@ +From 9feb1e81f79e28b78b803abde4dacaca820dafe8 Mon Sep 17 00:00:00 2001 +From: Remi Collet <remi@remirepo.net> +Date: Mon, 15 Feb 2021 09:37:22 +0100 +Subject: [PATCH] check for openblas headers + +--- + ext/config.m4 | 18 +++++++++++++++++- + 1 file changed, 17 insertions(+), 1 deletion(-) + +diff --git a/ext/config.m4 b/ext/config.m4 +index ae03d9c..2b130c0 100644 +--- a/ext/config.m4 ++++ b/ext/config.m4 +@@ -1,8 +1,24 @@ + PHP_ARG_ENABLE(tensor, whether to enable tensor, [ --enable-tensor Enable Tensor]) + ++PHP_ARG_WITH(openblas, libopenblas directory, ++[ --with-openblas=DIR libopenblas directory], no, no) ++ + if test "$PHP_TENSOR" = "yes"; then + +- ++ AC_MSG_CHECKING([Check openblas headers]) ++ for i in $PHP_OPENBLAS /usr/local/include /usr/include/openblas /usr/include; do ++ if test -r $i/cblas.h; then ++ OPENBLAS_DIR=$i ++ AC_MSG_RESULT([found in $i]) ++ break ++ fi ++ done ++ ++ if test -z "$OPENBLAS_DIR"; then ++ AC_MSG_ERROR([openblas headers not found]) ++ else ++ PHP_ADD_INCLUDE($OPENBLAS_DIR) ++ fi + + if ! test "x-lopenblas -llapacke -lgfortran -lpthread" = "x"; then + PHP_EVAL_LIBLINE(-lopenblas -llapacke -lgfortran -lpthread, TENSOR_SHARED_LIBADD) diff --git a/tensor-libs.patch b/tensor-libs.patch new file mode 100644 index 0000000..42fe7b3 --- /dev/null +++ b/tensor-libs.patch @@ -0,0 +1,15 @@ +diff --git a/ext/config.m4 b/ext/config.m4 +index 2b130c0..90b7e1c 100644 +--- a/ext/config.m4 ++++ b/ext/config.m4 +@@ -20,9 +20,7 @@ if test "$PHP_TENSOR" = "yes"; then + PHP_ADD_INCLUDE($OPENBLAS_DIR) + fi + +- if ! test "x-lopenblas -llapacke -lgfortran -lpthread" = "x"; then +- PHP_EVAL_LIBLINE(-lopenblas -llapacke -lgfortran -lpthread, TENSOR_SHARED_LIBADD) +- fi ++ PHP_EVAL_LIBLINE(-lopenblas, TENSOR_SHARED_LIBADD) + + 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 tensor/arithmetic.zep.c |