Implement ArrayAccess interface.

Author: mcordingley

src/Matrix.php

@@ -4,9 +4,10 @@
 
 namespace MCordingley\LinearAlgebra;
 
+use ArrayAccess;
 use MCordingley\LinearAlgebra\Decomposition\LUP;
 
-class Matrix
+class Matrix implements ArrayAccess
 {
     /** @var array */
     protected $internal;
@@ -607,4 +608,42 @@ final public function transpose(): self
 
         return new static($literal);
     }
+
+    /**
+     * @param mixed $offset
+     * @return bool
+     */
+    public function offsetExists($offset): bool
+    {
+        return isset($this->internal[$offset]);
+    }
+
+    /**
+     * @param mixed $offset
+     * @return Vector|null
+     * @throws MatrixException
+     */
+    public function offsetGet($offset)
+    {
+        return $this->offsetExists($offset) ? new Vector($this->internal[$offset]) : null;
+    }
+
+    /**
+     * @param mixed $offset
+     * @param mixed $value
+     * @throws MatrixException
+     */
+    final public function offsetSet($offset, $value)
+    {
+        throw new MatrixException('Matrices are immutable.');
+    }
+
+    /**
+     * @param mixed $offset
+     * @throws MatrixException
+     */
+    final public function offsetUnset($offset)
+    {
+        throw new MatrixException('Matrices are immutable.');
+    }
 }

src/Vector.php

@@ -21,7 +21,7 @@ public function __construct(array $literal)
      */
     public static function fromMatrix(Matrix $matrix, int $row = 0): self
     {
-        return new self($matrix->toArray()[$row]);
+        return $matrix[$row];
     }
 
     /**
@@ -223,4 +223,23 @@ public function maxNorm(): float
             return $carry > $value ? $carry : $value;
         }, -INF);
     }
+
+    /**
+     * @param mixed $offset
+     * @return bool
+     */
+    public function offsetExists($offset): bool
+    {
+        return isset($this->internal[0][$offset]);
+    }
+
+    /**
+     * @param mixed $offset
+     * @return float|null
+     * @throws MatrixException
+     */
+    public function offsetGet($offset)
+    {
+        return $this->offsetExists($offset) ? $this->internal[0][$offset] : null;
+    }
 }

tests/MatrixTest.php

@@ -6,6 +6,7 @@
 
 use MCordingley\LinearAlgebra\Matrix;
 use MCordingley\LinearAlgebra\MatrixException;
+use MCordingley\LinearAlgebra\Vector;
 use PHPUnit_Framework_TestCase;
 
 final class MatrixTest extends PHPUnit_Framework_TestCase
@@ -713,4 +714,39 @@ public function testNonSquareDeterminant()
 
         $matrix->determinant();
     }
+
+    public function testOffsetExists()
+    {
+        $matrix = $this->buildMatrix();
+
+        static::assertTrue(isset($matrix[0]));
+        static::assertFalse(isset($matrix[100]));
+    }
+
+    public function testOffsetGet()
+    {
+        $matrix = $this->buildMatrix();
+
+        $vector = $matrix[1];
+
+        static::assertInstanceOf(Vector::class, $vector);
+    }
+
+    public function testOffsetSet()
+    {
+        $matrix = $this->buildMatrix();
+
+        static::expectException(MatrixException::class);
+
+        $matrix[0] = true;
+    }
+
+    public function testOffsetUnset()
+    {
+        $matrix = $this->buildMatrix();
+
+        static::expectException(MatrixException::class);
+
+        unset($matrix[0]);
+    }
 }

tests/VectorTest.php

@@ -146,4 +146,19 @@ public function testProjection()
 
         $this->assertEquals(new Vector([12 / 10, 4 / 10]), $vector1->projection($vector2));
     }
+
+    public function testOffsetExists()
+    {
+        $vector = self::buildVector();
+
+        static::assertTrue(isset($vector[0]));
+        static::assertFalse(isset($vector[100]));
+    }
+
+    public function testOffsetGet()
+    {
+        $vector = self::buildVector();
+
+        static::assertEquals(2, $vector[1]);
+    }
 }