[FEAT] Implement benchmark for cpu and gpu for initializer methods Cl…

.gitignore

@@ -45,4 +45,6 @@ test.php
 *.IoT
 *.loT
 tensor
-test_img.jpg
+test_img.jpg
+composer.lock
+vendor

README.md

@@ -33,7 +33,23 @@ NumPower aims to manage memory more efficiently than a matrix in PHP arrays
 - **Optional (GPU)**: CUBLAS, CUDA Build Toolkit and cuDNN
 - **Optional (Image)**: PHP-GD
 
-## Composer Install
+## Compiling
+
+``` 
+$ phpize
+$ ./configure
+$ make install
+```
+
+## Compiling with GPU (CUDA) support
+
+``` 
+$ phpize
+$ ./configure --with-cuda
+$ make install-cuda
+```
+
+## Composer install
 The composer package provides a stubs file to facilitate autocomplete in the IDE. To install, simply run the command below in your environment with composer installed:
 
 ```bash
@@ -42,7 +58,7 @@ $ composer require numpower/numpower
 
 The composer package will follow the same versioning as the extension.
 
-## GPU Support
+## GPU support
 
 If you have an NVIDIA graphics card with CUDA support, you can use your graphics card 
 to perform operations. To do this, just copy your array to the GPU memory.

benchmarks/initializers/ArangeInitializerBench.php

@@ -0,0 +1,35 @@
+<?php
+    /**
+     * @Groups({"initializers"})
+     */
+    class ArangeInitializerBench
+    {
+        /**
+        * @var size
+        */
+        private $size = 1;
+
+        public function setUp(array $params): void
+        {
+            $this->size = $params['size'];
+        }
+
+        /**
+        * @BeforeMethods("setUp")
+        * @Revs(1000)
+        * @Iterations(5)
+        * @ParamProviders({
+        *     "provideSizes",
+        * })
+        */
+        public function benchARange($params)
+        {
+            $ndarray = \NDArray::arange($this->size, 0, 1);
+        }
+        public function provideSizes() {
+            yield ['size' => 100];
+            yield ['size' => 500];
+            yield ['size' => 1000];
+        }
+    }
+?>

benchmarks/initializers/ArrayInitializerBench.php

@@ -0,0 +1,39 @@
+<?php
+    /**
+     * @Groups({"initializers"})
+     */
+    class ArrayInitializerBench
+    {
+        /**
+        * @var matrix
+        */
+        private $matrix = [];
+
+        public function setUp(array $params): void
+        {
+            $this->matrix = $params['matrix'];
+        }
+
+        /**
+        * @BeforeMethods("setUp")
+        * @Revs(1000)
+        * @Iterations(5)
+        * @ParamProviders({
+        *     "provideMatrix",
+        * })
+        */
+        public function benchArray($params)
+        {
+            $ndarray = \NDArray::array($this->matrix);
+        }
+
+        public function provideMatrix() {
+            yield ['matrix' => \NDArray::zeros([1, 100])];
+            yield ['matrix' => \NDArray::zeros([1, 500])];
+            yield ['matrix' => \NDArray::zeros([1, 1000])];
+            yield ['matrix' => \NDArray::zeros([10, 100])];
+            yield ['matrix' => \NDArray::zeros([1000, 500])];
+            yield ['matrix' => \NDArray::zeros([10000, 1000])];
+        }
+    }
+?>

benchmarks/initializers/FullInitializerBench.php

@@ -0,0 +1,39 @@
+<?php
+    /**
+     * @Groups({"initializers"})
+     */
+    class FullInitializerBench
+    {
+        /**
+        * @var shape
+        */
+        private $shape = [];
+
+        public function setUp(array $params): void
+        {
+            $this->shape = $params['shape'];
+        }
+
+        /**
+        * @BeforeMethods("setUp")
+        * @Revs(1000)
+        * @Iterations(5)
+        * @ParamProviders({
+        *     "provideShapes"
+        * })
+        */
+        public function benchFull($params): void
+        {  
+            \NDArray::full($this->shape, 4);
+        }
+
+        public function provideShapes() {
+            yield ['shape' => [100, 1]];
+            yield ['shape' => [500, 1]];
+            yield ['shape' => [1000, 1]];
+            yield ['shape' => [10, 100]];
+            yield ['shape' => [500, 1000]];
+            yield ['shape' => [1000, 10000]];
+        }
+    }
+?>

benchmarks/initializers/IdentityInitializerBench.php

@@ -0,0 +1,36 @@
+<?php
+    /**
+     * @Groups({"initializers"})
+     */
+    class IdentityInitializerBench
+    {
+        /**
+        * @var size
+        */
+        private $size = 0;
+
+        public function setUp(array $params): void
+        {
+            $this->size = $params['size'];
+        }
+
+        /**
+        * @BeforeMethods("setUp")
+        * @Revs(1000)
+        * @Iterations(5)
+        * @ParamProviders({
+        *     "provideSizes",
+        * })
+        */
+        public function benchIdentity($params)
+        {
+            $ndarray = \NDArray::identity($this->size);
+        }
+
+        public function provideSizes() {
+            yield ['size' => 100];
+            yield ['size' => 500];
+            yield ['size' => 1000];
+        }
+    }
+?>

benchmarks/initializers/OnesInitializerBench.php

@@ -0,0 +1,39 @@
+<?php
+    /**
+     * @Groups({"initializers"})
+     */
+    class OnesInitializerBench
+    {
+        /**
+        * @var shape
+        */
+        private $shape = [];
+
+        public function setUp(array $params): void
+        {
+            $this->shape = $params['shape'];
+        }
+
+        /**
+        * @BeforeMethods("setUp")
+        * @Revs(1000)
+        * @Iterations(5)
+        * @ParamProviders({
+        *     "provideShapes"
+        * })
+        */
+        public function benchOnes($params): void
+        {
+            \NDArray::ones($this->shape);
+        }
+
+        public function provideShapes() {
+            yield ['shape' => [100, 1]];
+            yield ['shape' => [500, 1]];
+            yield ['shape' => [1000, 1]];
+            yield ['shape' => [10, 100]];
+            yield ['shape' => [500, 1000]];
+            yield ['shape' => [1000, 10000]];
+        }
+    }
+?>

benchmarks/initializers/ZerosInitializerBench.php

@@ -0,0 +1,39 @@
+<?php
+    /**
+     * @Groups({"initializers"})
+     */
+    class ZerosInitializerBench
+    {
+        /**
+        * @var shape
+        */
+        private $shape = [];
+
+        public function setUp(array $params): void
+        {
+            $this->shape = $params['shape'];
+        }
+
+        /**
+        * @BeforeMethods("setUp")
+        * @Revs(1000)
+        * @Iterations(5)
+        * @ParamProviders({
+        *     "provideShapes"
+        * })
+        */
+        public function benchZeros($params): void
+        {
+            \NDArray::zeros($this->shape);
+        }
+
+        public function provideShapes() {
+            yield ['shape' => [100, 1]];
+            yield ['shape' => [500, 1]];
+            yield ['shape' => [1000, 1]];
+            yield ['shape' => [10, 100]];
+            yield ['shape' => [500, 1000]];
+            yield ['shape' => [1000, 10000]];
+        }
+    }
+?>

benchmarks/linalg/CholeskyBench.php

@@ -0,0 +1,49 @@
+<?php
+    /**
+     * @Groups({"linearAlgebra"})
+     */
+    class CholeskyBench
+    {
+        /**
+        * @var testArray
+        */
+        private $testArray = [];
+
+        public function setUp(array $params): void
+        {
+            $this->testArray = $params['testArray'];
+        }
+
+        /**
+        * @BeforeMethods("setUp")
+        * @Revs(1000)
+        * @Iterations(5)
+        * @ParamProviders({
+        *     "provideArrays"
+        * })
+        */
+        public function benchCholesky($params): void
+        {
+            \NDArray::cholesky($this->testArray);
+        }
+
+        private function createArray($ndim) {
+            $symmetric = \NDArray::ones([$ndim, $ndim]);
+            for ($i=0; $i<$ndim; $i++) {
+                $symmetric[$i][$i] += $ndim * 10;
+            }
+            $L = \NDArray::cholesky($symmetric);
+            $L_T = \NDArray::transpose($L);
+            $positive_definite_matrix = \NDArray::matmul($L, $L_T);
+            return $positive_definite_matrix;
+        }
+
+        public function provideArrays() {
+            $testSizes = array(10, 100, 1000, 10000);
+            foreach ($testSizes as &$value) {
+                $currTestMatrix = $this->createArray($value);
+                yield ['testArray' => $currTestMatrix];
+            }
+        }
+    }
+?>

benchmarks/linalg/CondBench.php

@@ -0,0 +1,46 @@
+<?php
+    /**
+     * @Groups({"linearAlgebra"})
+     */
+    class CondBench
+    {
+        /**
+        * @var testArray
+        */
+        private $testArray = [];
+
+        public function setUp(array $params): void
+        {
+            $this->testArray = $params['testArray'];
+        }
+
+        /**
+        * @BeforeMethods("setUp")
+        * @Revs(1000)
+        * @Iterations(5)
+        * @ParamProviders({
+        *     "provideArrays"
+        * })
+        */
+        public function benchCond($params): void
+        {
+            \NDArray::cond($this->testArray);
+        }
+
+        private function createArray($ndim) {
+            $symmetric = \NDArray::ones([$ndim, $ndim]);
+            for ($i=0; $i<$ndim; $i++) {
+                $symmetric[$i][$i] += $ndim * 10;
+            }
+            return $symmetric;
+        }
+
+        public function provideArrays() {
+            $testSizes = array(10, 100, 1000);
+            foreach ($testSizes as &$value) {
+                $currTestMatrix = $this->createArray($value);
+                yield ['testArray' => $currTestMatrix];
+            }
+        }
+    }
+?>