package and depencies

vendor/markbaker/complex/.github/workflows/main.yml

@@ -12,16 +12,18 @@ jobs:
           - '7.3'
           - '7.4'
           - '8.0'
+          - '8.1'
+          - '8.2'
 
         include:
-          - php-version: '8.1'
+          - php-version: 'nightly'
             experimental: true
 
     name: PHP ${{ matrix.php-version }}
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Setup PHP, with composer and extensions
         uses: shivammathur/setup-php@v2
@@ -34,7 +36,7 @@ jobs:
         run: echo "::set-output name=dir::$(composer config cache-files-dir)"
 
       - name: Cache composer dependencies
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: ${{ steps.composer-cache.outputs.dir }}
           key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.lock') }}
@@ -42,8 +44,9 @@ jobs:
 
       - name: Delete composer lock file
         id: composer-lock
-        if: ${{ matrix.php-version == '8.1' }}
+        if: ${{ matrix.php-version == '8.0' || matrix.php-version == '8.1' || matrix.php-version == '8.2' || matrix.php-version == 'nightly' }}
         run: |
+          rm composer.lock
           echo "::set-output name=flags::--ignore-platform-reqs"
 
       - name: Install dependencies
@@ -64,7 +67,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Setup PHP, with composer and extensions
         uses: shivammathur/setup-php@v2
@@ -78,7 +81,7 @@ jobs:
         run: echo "::set-output name=dir::$(composer config cache-files-dir)"
 
       - name: Cache composer dependencies
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: ${{ steps.composer-cache.outputs.dir }}
           key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.lock') }}
@@ -94,7 +97,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Setup PHP, with composer and extensions
         uses: shivammathur/setup-php@v2
@@ -108,7 +111,7 @@ jobs:
         run: echo "::set-output name=dir::$(composer config cache-files-dir)"
 
       - name: Cache composer dependencies
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: ${{ steps.composer-cache.outputs.dir }}
           key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.lock') }}
@@ -124,7 +127,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Setup PHP, with composer and extensions
         uses: shivammathur/setup-php@v2
@@ -137,7 +140,7 @@ jobs:
         run: echo "::set-output name=dir::$(composer config cache-files-dir)"
 
       - name: Cache composer dependencies
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: ${{ steps.composer-cache.outputs.dir }}
           key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.lock') }}

vendor/markbaker/complex/README.md

@@ -3,11 +3,13 @@ PHPComplex
 
 ---
 
-PHP Class for handling Complex numbers
+PHP Class Library for working with Complex numbers
 
-Master: [![Build Status](https://travis-ci.org/MarkBaker/PHPComplex.png?branch=master)](http://travis-ci.org/MarkBaker/PHPComplex)
+[![Build Status](https://github.com/MarkBaker/PHPComplex/workflows/main/badge.svg)](https://github.com/MarkBaker/PHPComplex/actions)
+[![Total Downloads](https://img.shields.io/packagist/dt/markbaker/complex)](https://packagist.org/packages/markbaker/complex)
+[![Latest Stable Version](https://img.shields.io/github/v/release/MarkBaker/PHPComplex)](https://packagist.org/packages/markbaker/complex)
+[![License](https://img.shields.io/github/license/MarkBaker/PHPComplex)](https://packagist.org/packages/markbaker/complex)
 
-Develop: [![Build Status](https://travis-ci.org/MarkBaker/PHPComplex.png?branch=develop)](http://travis-ci.org/MarkBaker/PHPComplex)
 
 [![Complex Numbers](https://imgs.xkcd.com/comics/complex_numbers_2x.png)](https://xkcd.com/2028/)
 
@@ -63,19 +65,37 @@ together with functions for
  
 ---
 
+# Installation
+
+```shell
+composer require markbaker/complex:^1.0
+```
+
+# Important BC Note
+
+If you've previously been using procedural calls to functions and operations using this library, then from version 3.0 you should use [MarkBaker/PHPComplexFunctions](https://github.com/MarkBaker/PHPComplexFunctions) instead (available on packagist as [markbaker/complex-functions](https://packagist.org/packages/markbaker/complex-functions)).
+
+You'll need to replace `markbaker/complex`in your `composer.json` file with the new library, but otherwise there should be no difference in the namespacing, or in the way that you have called the Complex functions in the past, so no actual code changes are required.
+
+```shell
+composer require markbaker/complex-functions:^3.0
+```
+
+You should not reference this library (`markbaker/complex`) in your `composer.json`, composer wil take care of that for you.
+
 # Usage
 
 To create a new complex object, you can provide either the real, imaginary and suffix parts as individual values, or as an array of values passed passed to the constructor; or a string representing the value. e.g
 
-```
+```php
 $real = 1.23;
 $imaginary = -4.56;
 $suffix = 'i';
 
 $complexObject = new Complex\Complex($real, $imaginary, $suffix);
 ```
-or
-```
+or as an array
+```php
 $real = 1.23;
 $imaginary = -4.56;
 $suffix = 'i';
@@ -84,8 +104,8 @@ $arguments = [$real, $imaginary, $suffix];
 
 $complexObject = new Complex\Complex($arguments);
 ```
-or
-```
+or as a string
+```php
 $complexString = '1.23-4.56i';
 
 $complexObject = new Complex\Complex($complexString);
@@ -98,57 +118,54 @@ This also allows you to chain multiple methods as you would for a fluent interfa
 
 To perform mathematical operations with Complex values, you can call the appropriate method against a complex value, passing other values as arguments
 
-```
+```php
 $complexString1 = '1.23-4.56i';
 $complexString2 = '2.34+5.67i';
 
 $complexObject = new Complex\Complex($complexString1);
 echo $complexObject->add($complexString2);
 ```
-or pass all values to the appropriate function
-```
+
+or use the static Operation methods
+```php
 $complexString1 = '1.23-4.56i';
 $complexString2 = '2.34+5.67i';
 
-echo Complex\add($complexString1, $complexString2);
+echo Complex\Operations::add($complexString1, $complexString2);
 ```
 If you want to perform the same operation against multiple values (e.g. to add three or more complex numbers), then you can pass multiple arguments to any of the operations.
 
-You can pass these arguments as Complex objects, or as an array or string that will parse to a complex object.
+You can pass these arguments as Complex objects, or as an array, or string that will parse to a complex object.
 
 ## Using functions
 
 When calling any of the available functions for a complex value, you can either call the relevant method for the Complex object
-```
+```php
 $complexString = '1.23-4.56i';
 
 $complexObject = new Complex\Complex($complexString);
 echo $complexObject->sinh();
 ```
-or you can call the function as you would in procedural code, passing the Complex object as an argument 
+
+or use the static Functions methods
+```php
+$complexString = '1.23-4.56i';
+
+echo Complex\Functions::sinh($complexString);
 ```
+As with operations, you can pass these arguments as Complex objects, or as an array or string that will parse to a complex object.
+
+
+In the case of the `pow()` function (the only implemented function that requires an additional argument) you need to pass both arguments when calling the function
+
+```php
 $complexString = '1.23-4.56i';
 
 $complexObject = new Complex\Complex($complexString);
-echo Complex\sinh($complexObject);
-```
-When called procedurally using the function, you can pass in the argument as a Complex object, or as an array or string that will parse to a complex object.
-```
-$complexString = '1.23-4.56i';
-
-echo Complex\sinh($complexString);
-```
-
-In the case of the `pow()` function (the only implemented function that requires an additional argument) you need to pass both arguments when calling the function procedurally
-
-```
-$complexString = '1.23-4.56i';
-
-$complexObject = new Complex\Complex($complexString);
-echo Complex\pow($complexObject, 2);
+echo Complex\Functions::pow($complexObject, 2);
 ```
 or pass the additional argument when calling the method
-```
+```php
 $complexString = '1.23-4.56i';
 
 $complexObject = new Complex\Complex($complexString);

vendor/markbaker/complex/classes/Autoloader.php

@@ -1,53 +0,0 @@
-<?php
-
-namespace Complex;
-
-/**
- *
- * Autoloader for Complex classes
- *
- * @package Complex
- * @copyright  Copyright (c) 2014 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT          MIT
- */
-class Autoloader
-{
-    /**
-     * Register the Autoloader with SPL
-     *
-     */
-    public static function Register()
-    {
-        if (function_exists('__autoload')) {
-            //    Register any existing autoloader function with SPL, so we don't get any clashes
-            spl_autoload_register('__autoload');
-        }
-        //    Register ourselves with SPL
-        return spl_autoload_register(['Complex\\Autoloader', 'Load']);
-    }
-
-
-    /**
-     * Autoload a class identified by name
-     *
-     * @param    string    $pClassName    Name of the object to load
-     */
-    public static function Load($pClassName)
-    {
-        if ((class_exists($pClassName, false)) || (strpos($pClassName, 'Complex\\') !== 0)) {
-            // Either already loaded, or not a Complex class request
-            return false;
-        }
-
-        $pClassFilePath = __DIR__ . DIRECTORY_SEPARATOR .
-                          'src' . DIRECTORY_SEPARATOR .
-                          str_replace(['Complex\\', '\\'], ['', '/'], $pClassName) .
-                          '.php';
-
-        if ((file_exists($pClassFilePath) === false) || (is_readable($pClassFilePath) === false)) {
-            // Can't load
-            return false;
-        }
-        require($pClassFilePath);
-    }
-}

vendor/markbaker/complex/classes/Bootstrap.php

@@ -1,38 +0,0 @@
-<?php
-
-include_once __DIR__ . '/Autoloader.php';
-
-\Complex\Autoloader::Register();
-
-
-abstract class FilesystemRegexFilter extends RecursiveRegexIterator
-{
-    protected $regex;
-    public function __construct(RecursiveIterator $it, $regex)
-    {
-        $this->regex = $regex;
-        parent::__construct($it, $regex);
-    }
-}
-
-class FilenameFilter extends FilesystemRegexFilter
-{
-    // Filter files against the regex
-    public function accept()
-    {
-        return (!$this->isFile() || preg_match($this->regex, $this->getFilename()));
-    }
-}
-
-
-$srcFolder = __DIR__ . DIRECTORY_SEPARATOR . 'src';
-$srcDirectory = new RecursiveDirectoryIterator($srcFolder);
-
-$filteredFileList = new FilenameFilter($srcDirectory, '/(?:php)$/i');
-$filteredFileList = new FilenameFilter($filteredFileList, '/^(?!.*(Complex|Exception)\.php).*$/i');
-
-foreach (new RecursiveIteratorIterator($filteredFileList) as $file) {
-    if ($file->isFile()) {
-        include_once $file;
-    }
-}

vendor/markbaker/complex/classes/src/Complex.php

@@ -377,13 +377,11 @@ class Complex
 
         // Test for function calls
         if (in_array($functionName, self::$functions, true)) {
-            $functionName = "\\" . __NAMESPACE__ . "\\{$functionName}";
-            return $functionName($this, ...$arguments);
+            return Functions::$functionName($this, ...$arguments);
         }
         // Test for operation calls
         if (in_array($functionName, self::$operations, true)) {
-            $functionName = "\\" . __NAMESPACE__ . "\\{$functionName}";
-            return $functionName($this, ...$arguments);
+            return Operations::$functionName($this, ...$arguments);
         }
         throw new Exception('Complex Function or Operation does not exist');
     }

vendor/markbaker/complex/classes/src/Functions.php

@@ -0,0 +1,823 @@
+<?php
+
+namespace Complex;
+
+use InvalidArgumentException;
+
+class Functions
+{
+    /**
+     * Returns the absolute value (modulus) of a complex number.
+     * Also known as the rho of the complex number, i.e. the distance/radius
+     *   from the centrepoint to the representation of the number in polar coordinates.
+     *
+     * This function is a synonym for rho()
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    float            The absolute (or rho) value of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     *
+     * @see    rho
+     *
+     */
+    public static function abs($complex): float
+    {
+        return self::rho($complex);
+    }
+
+    /**
+     * Returns the inverse cosine of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse cosine of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function acos($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        $invsqrt = self::sqrt(Operations::subtract(1, Operations::multiply($complex, $complex)));
+        $adjust = new Complex(
+            $complex->getReal() - $invsqrt->getImaginary(),
+            $complex->getImaginary() + $invsqrt->getReal()
+        );
+        $log = self::ln($adjust);
+
+        return new Complex(
+            $log->getImaginary(),
+            -1 * $log->getReal()
+        );
+    }
+
+    /**
+     * Returns the inverse hyperbolic cosine of a complex number.
+     *
+     * Formula from Wolfram Alpha:
+     *   cosh^(-1)z = ln(z + sqrt(z + 1) sqrt(z - 1)).
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse hyperbolic cosine of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function acosh($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->isReal() && ($complex->getReal() > 1)) {
+            return new Complex(\acosh($complex->getReal()));
+        }
+
+        $acosh = self::ln(
+            Operations::add(
+                $complex,
+                Operations::multiply(
+                    self::sqrt(Operations::add($complex, 1)),
+                    self::sqrt(Operations::subtract($complex, 1))
+                )
+            )
+        );
+
+        return $acosh;
+    }
+
+    /**
+     * Returns the inverse cotangent of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse cotangent of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function acot($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        return self::atan(self::inverse($complex));
+    }
+
+    /**
+     * Returns the inverse hyperbolic cotangent of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse hyperbolic cotangent of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function acoth($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        return self::atanh(self::inverse($complex));
+    }
+
+    /**
+     * Returns the inverse cosecant of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse cosecant of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function acsc($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
+            return new Complex(INF);
+        }
+
+        return self::asin(self::inverse($complex));
+    }
+
+    /**
+     * Returns the inverse hyperbolic cosecant of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse hyperbolic cosecant of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function acsch($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
+            return new Complex(INF);
+        }
+
+        return self::asinh(self::inverse($complex));
+    }
+
+    /**
+     * Returns the argument of a complex number.
+     * Also known as the theta of the complex number, i.e. the angle in radians
+     *   from the real axis to the representation of the number in polar coordinates.
+     *
+     * This function is a synonym for theta()
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    float            The argument (or theta) value of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     *
+     * @see    theta
+     */
+    public static function argument($complex): float
+    {
+        return self::theta($complex);
+    }
+
+    /**
+     * Returns the inverse secant of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse secant of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function asec($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
+            return new Complex(INF);
+        }
+
+        return self::acos(self::inverse($complex));
+    }
+
+    /**
+     * Returns the inverse hyperbolic secant of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse hyperbolic secant of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function asech($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
+            return new Complex(INF);
+        }
+
+        return self::acosh(self::inverse($complex));
+    }
+
+    /**
+     * Returns the inverse sine of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse sine of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function asin($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        $invsqrt = self::sqrt(Operations::subtract(1, Operations::multiply($complex, $complex)));
+        $adjust = new Complex(
+            $invsqrt->getReal() - $complex->getImaginary(),
+            $invsqrt->getImaginary() + $complex->getReal()
+        );
+        $log = self::ln($adjust);
+
+        return new Complex(
+            $log->getImaginary(),
+            -1 * $log->getReal()
+        );
+    }
+
+    /**
+     * Returns the inverse hyperbolic sine of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse hyperbolic sine of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function asinh($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->isReal() && ($complex->getReal() > 1)) {
+            return new Complex(\asinh($complex->getReal()));
+        }
+
+        $asinh = clone $complex;
+        $asinh = $asinh->reverse()
+            ->invertReal();
+        $asinh = self::asin($asinh);
+
+        return $asinh->reverse()
+            ->invertImaginary();
+    }
+
+    /**
+     * Returns the inverse tangent of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse tangent of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function atan($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->isReal()) {
+            return new Complex(\atan($complex->getReal()));
+        }
+
+        $t1Value = new Complex(-1 * $complex->getImaginary(), $complex->getReal());
+        $uValue = new Complex(1, 0);
+
+        $d1Value = clone $uValue;
+        $d1Value = Operations::subtract($d1Value, $t1Value);
+        $d2Value = Operations::add($t1Value, $uValue);
+        $uResult = $d1Value->divideBy($d2Value);
+        $uResult = self::ln($uResult);
+
+        $realMultiplier = -0.5;
+        $imaginaryMultiplier = 0.5;
+
+        if (abs($uResult->getImaginary()) === M_PI) {
+            // If we have an imaginary value at the max or min (PI or -PI), then we need to ensure
+            //    that the primary is assigned for the correct quadrant.
+            $realMultiplier = (
+                ($uResult->getImaginary() === M_PI && $uResult->getReal() > 0.0) ||
+                ($uResult->getImaginary() === -M_PI && $uResult->getReal() < 0.0)
+            ) ? 0.5 : -0.5;
+        }
+
+        return new Complex(
+            $uResult->getImaginary() * $realMultiplier,
+            $uResult->getReal() * $imaginaryMultiplier,
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns the inverse hyperbolic tangent of a complex number.
+     *
+     * Formula from Wolfram Alpha:
+     *  tanh^(-1)z = 1/2 [ln(1 + z) - ln(1 - z)].
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse hyperbolic tangent of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function atanh($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->isReal()) {
+            $real = $complex->getReal();
+            if ($real >= -1.0 && $real <= 1.0) {
+                return new Complex(\atanh($real));
+            } else {
+                return new Complex(\atanh(1 / $real), (($real < 0.0) ? M_PI_2 : -1 * M_PI_2));
+            }
+        }
+
+        $atanh = Operations::multiply(
+            Operations::subtract(
+                self::ln(Operations::add(1.0, $complex)),
+                self::ln(Operations::subtract(1.0, $complex))
+            ),
+            0.5
+        );
+
+        return $atanh;
+    }
+
+    /**
+     * Returns the complex conjugate of a complex number
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The conjugate of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function conjugate($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        return new Complex(
+            $complex->getReal(),
+            -1 * $complex->getImaginary(),
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns the cosine of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The cosine of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function cos($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->isReal()) {
+            return new Complex(\cos($complex->getReal()));
+        }
+
+        return self::conjugate(
+            new Complex(
+                \cos($complex->getReal()) * \cosh($complex->getImaginary()),
+                \sin($complex->getReal()) * \sinh($complex->getImaginary()),
+                $complex->getSuffix()
+            )
+        );
+    }
+
+    /**
+     * Returns the hyperbolic cosine of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The hyperbolic cosine of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function cosh($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->isReal()) {
+            return new Complex(\cosh($complex->getReal()));
+        }
+
+        return new Complex(
+            \cosh($complex->getReal()) * \cos($complex->getImaginary()),
+            \sinh($complex->getReal()) * \sin($complex->getImaginary()),
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns the cotangent of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The cotangent of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function cot($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
+            return new Complex(INF);
+        }
+
+        return self::inverse(self::tan($complex));
+    }
+
+    /**
+     * Returns the hyperbolic cotangent of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The hyperbolic cotangent of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function coth($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        return self::inverse(self::tanh($complex));
+    }
+
+    /**
+     * Returns the cosecant of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The cosecant of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function csc($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
+            return new Complex(INF);
+        }
+
+        return self::inverse(self::sin($complex));
+    }
+
+    /**
+     * Returns the hyperbolic cosecant of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The hyperbolic cosecant of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function csch($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
+            return new Complex(INF);
+        }
+
+        return self::inverse(self::sinh($complex));
+    }
+
+    /**
+     * Returns the exponential of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The exponential of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function exp($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if (($complex->getReal() == 0.0) && (\abs($complex->getImaginary()) == M_PI)) {
+            return new Complex(-1.0, 0.0);
+        }
+
+        $rho = \exp($complex->getReal());
+
+        return new Complex(
+            $rho * \cos($complex->getImaginary()),
+            $rho * \sin($complex->getImaginary()),
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns the inverse of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The inverse of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function inverse($complex): Complex
+    {
+        $complex = clone Complex::validateComplexArgument($complex);
+
+        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
+            throw new InvalidArgumentException('Division by zero');
+        }
+
+        return $complex->divideInto(1.0);
+    }
+
+    /**
+     * Returns the natural logarithm of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The natural logarithm of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    InvalidArgumentException  If the real and the imaginary parts are both zero
+     */
+    public static function ln($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if (($complex->getReal() == 0.0) && ($complex->getImaginary() == 0.0)) {
+            throw new InvalidArgumentException();
+        }
+
+        return new Complex(
+            \log(self::rho($complex)),
+            self::theta($complex),
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns the base-2 logarithm of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The base-2 logarithm of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    InvalidArgumentException  If the real and the imaginary parts are both zero
+     */
+    public static function log2($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if (($complex->getReal() == 0.0) && ($complex->getImaginary() == 0.0)) {
+            throw new InvalidArgumentException();
+        } elseif (($complex->getReal() > 0.0) && ($complex->getImaginary() == 0.0)) {
+            return new Complex(\log($complex->getReal(), 2), 0.0, $complex->getSuffix());
+        }
+
+        return self::ln($complex)
+            ->multiply(\log(Complex::EULER, 2));
+    }
+
+    /**
+     * Returns the common logarithm (base 10) of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The common logarithm (base 10) of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    InvalidArgumentException  If the real and the imaginary parts are both zero
+     */
+    public static function log10($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if (($complex->getReal() == 0.0) && ($complex->getImaginary() == 0.0)) {
+            throw new InvalidArgumentException();
+        } elseif (($complex->getReal() > 0.0) && ($complex->getImaginary() == 0.0)) {
+            return new Complex(\log10($complex->getReal()), 0.0, $complex->getSuffix());
+        }
+
+        return self::ln($complex)
+            ->multiply(\log10(Complex::EULER));
+    }
+
+    /**
+     * Returns the negative of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The negative value of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     *
+     * @see    rho
+     *
+     */
+    public static function negative($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        return new Complex(
+            -1 * $complex->getReal(),
+            -1 * $complex->getImaginary(),
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns a complex number raised to a power.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @param     float|integer    $power      The power to raise this value to
+     * @return    Complex          The complex argument raised to the real power.
+     * @throws    Exception        If the power argument isn't a valid real
+     */
+    public static function pow($complex, $power): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if (!is_numeric($power)) {
+            throw new Exception('Power argument must be a real number');
+        }
+
+        if ($complex->getImaginary() == 0.0 && $complex->getReal() >= 0.0) {
+            return new Complex(\pow($complex->getReal(), $power));
+        }
+
+        $rValue = \sqrt(($complex->getReal() * $complex->getReal()) + ($complex->getImaginary() * $complex->getImaginary()));
+        $rPower = \pow($rValue, $power);
+        $theta = $complex->argument() * $power;
+        if ($theta == 0) {
+            return new Complex(1);
+        }
+
+        return new Complex($rPower * \cos($theta), $rPower * \sin($theta), $complex->getSuffix());
+    }
+
+    /**
+     * Returns the rho of a complex number.
+     * This is the distance/radius from the centrepoint to the representation of the number in polar coordinates.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    float            The rho value of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function rho($complex): float
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        return \sqrt(
+            ($complex->getReal() * $complex->getReal()) +
+            ($complex->getImaginary() * $complex->getImaginary())
+        );
+    }
+
+    /**
+     * Returns the secant of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The secant of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function sec($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        return self::inverse(self::cos($complex));
+    }
+
+    /**
+     * Returns the hyperbolic secant of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The hyperbolic secant of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function sech($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        return self::inverse(self::cosh($complex));
+    }
+
+    /**
+     * Returns the sine of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The sine of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function sin($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->isReal()) {
+            return new Complex(\sin($complex->getReal()));
+        }
+
+        return new Complex(
+            \sin($complex->getReal()) * \cosh($complex->getImaginary()),
+            \cos($complex->getReal()) * \sinh($complex->getImaginary()),
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns the hyperbolic sine of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The hyperbolic sine of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function sinh($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->isReal()) {
+            return new Complex(\sinh($complex->getReal()));
+        }
+
+        return new Complex(
+            \sinh($complex->getReal()) * \cos($complex->getImaginary()),
+            \cosh($complex->getReal()) * \sin($complex->getImaginary()),
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns the square root of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The Square root of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function sqrt($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        $theta = self::theta($complex);
+        $delta1 = \cos($theta / 2);
+        $delta2 = \sin($theta / 2);
+        $rho = \sqrt(self::rho($complex));
+
+        return new Complex($delta1 * $rho, $delta2 * $rho, $complex->getSuffix());
+    }
+
+    /**
+     * Returns the tangent of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The tangent of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function tan($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->isReal()) {
+            return new Complex(\tan($complex->getReal()));
+        }
+
+        $real = $complex->getReal();
+        $imaginary = $complex->getImaginary();
+        $divisor = 1 + \pow(\tan($real), 2) * \pow(\tanh($imaginary), 2);
+        if ($divisor == 0.0) {
+            throw new InvalidArgumentException('Division by zero');
+        }
+
+        return new Complex(
+            \pow(self::sech($imaginary)->getReal(), 2) * \tan($real) / $divisor,
+            \pow(self::sec($real)->getReal(), 2) * \tanh($imaginary) / $divisor,
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns the hyperbolic tangent of a complex number.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    Complex          The hyperbolic tangent of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     * @throws    \InvalidArgumentException    If function would result in a division by zero
+     */
+    public static function tanh($complex): Complex
+    {
+        $complex = Complex::validateComplexArgument($complex);
+        $real = $complex->getReal();
+        $imaginary = $complex->getImaginary();
+        $divisor = \cos($imaginary) * \cos($imaginary) + \sinh($real) * \sinh($real);
+        if ($divisor == 0.0) {
+            throw new InvalidArgumentException('Division by zero');
+        }
+
+        return new Complex(
+            \sinh($real) * \cosh($real) / $divisor,
+            0.5 * \sin(2 * $imaginary) / $divisor,
+            $complex->getSuffix()
+        );
+    }
+
+    /**
+     * Returns the theta of a complex number.
+     *   This is the angle in radians from the real axis to the representation of the number in polar coordinates.
+     *
+     * @param     Complex|mixed    $complex    Complex number or a numeric value.
+     * @return    float            The theta value of the complex argument.
+     * @throws    Exception        If argument isn't a valid real or complex number.
+     */
+    public static function theta($complex): float
+    {
+        $complex = Complex::validateComplexArgument($complex);
+
+        if ($complex->getReal() == 0.0) {
+            if ($complex->isReal()) {
+                return 0.0;
+            } elseif ($complex->getImaginary() < 0.0) {
+                return M_PI / -2;
+            }
+            return M_PI / 2;
+        } elseif ($complex->getReal() > 0.0) {
+            return \atan($complex->getImaginary() / $complex->getReal());
+        } elseif ($complex->getImaginary() < 0.0) {
+            return -(M_PI - \atan(\abs($complex->getImaginary()) / \abs($complex->getReal())));
+        }
+
+        return M_PI - \atan($complex->getImaginary() / \abs($complex->getReal()));
+    }
+}

vendor/markbaker/complex/classes/src/Operations.php

@@ -0,0 +1,210 @@
+<?php
+
+namespace Complex;
+
+use InvalidArgumentException;
+
+class Operations
+{
+    /**
+     * Adds two or more complex numbers
+     *
+     * @param     array of string|integer|float|Complex    $complexValues   The numbers to add
+     * @return    Complex
+     */
+    public static function add(...$complexValues): Complex
+    {
+        if (count($complexValues) < 2) {
+            throw new \Exception('This function requires at least 2 arguments');
+        }
+
+        $base = array_shift($complexValues);
+        $result = clone Complex::validateComplexArgument($base);
+
+        foreach ($complexValues as $complex) {
+            $complex = Complex::validateComplexArgument($complex);
+
+            if ($result->isComplex() && $complex->isComplex() &&
+                $result->getSuffix() !== $complex->getSuffix()) {
+                throw new Exception('Suffix Mismatch');
+            }
+
+            $real = $result->getReal() + $complex->getReal();
+            $imaginary = $result->getImaginary() + $complex->getImaginary();
+
+            $result = new Complex(
+                $real,
+                $imaginary,
+                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
+            );
+        }
+
+        return $result;
+    }
+
+    /**
+     * Divides two or more complex numbers
+     *
+     * @param     array of string|integer|float|Complex    $complexValues   The numbers to divide
+     * @return    Complex
+     */
+    public static function divideby(...$complexValues): Complex
+    {
+        if (count($complexValues) < 2) {
+            throw new \Exception('This function requires at least 2 arguments');
+        }
+
+        $base = array_shift($complexValues);
+        $result = clone Complex::validateComplexArgument($base);
+
+        foreach ($complexValues as $complex) {
+            $complex = Complex::validateComplexArgument($complex);
+
+            if ($result->isComplex() && $complex->isComplex() &&
+                $result->getSuffix() !== $complex->getSuffix()) {
+                throw new Exception('Suffix Mismatch');
+            }
+            if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
+                throw new InvalidArgumentException('Division by zero');
+            }
+
+            $delta1 = ($result->getReal() * $complex->getReal()) +
+                ($result->getImaginary() * $complex->getImaginary());
+            $delta2 = ($result->getImaginary() * $complex->getReal()) -
+                ($result->getReal() * $complex->getImaginary());
+            $delta3 = ($complex->getReal() * $complex->getReal()) +
+                ($complex->getImaginary() * $complex->getImaginary());
+
+            $real = $delta1 / $delta3;
+            $imaginary = $delta2 / $delta3;
+
+            $result = new Complex(
+                $real,
+                $imaginary,
+                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
+            );
+        }
+
+        return $result;
+    }
+
+    /**
+     * Divides two or more complex numbers
+     *
+     * @param     array of string|integer|float|Complex    $complexValues   The numbers to divide
+     * @return    Complex
+     */
+    public static function divideinto(...$complexValues): Complex
+    {
+        if (count($complexValues) < 2) {
+            throw new \Exception('This function requires at least 2 arguments');
+        }
+
+        $base = array_shift($complexValues);
+        $result = clone Complex::validateComplexArgument($base);
+
+        foreach ($complexValues as $complex) {
+            $complex = Complex::validateComplexArgument($complex);
+
+            if ($result->isComplex() && $complex->isComplex() &&
+                $result->getSuffix() !== $complex->getSuffix()) {
+                throw new Exception('Suffix Mismatch');
+            }
+            if ($result->getReal() == 0.0 && $result->getImaginary() == 0.0) {
+                throw new InvalidArgumentException('Division by zero');
+            }
+
+            $delta1 = ($complex->getReal() * $result->getReal()) +
+                ($complex->getImaginary() * $result->getImaginary());
+            $delta2 = ($complex->getImaginary() * $result->getReal()) -
+                ($complex->getReal() * $result->getImaginary());
+            $delta3 = ($result->getReal() * $result->getReal()) +
+                ($result->getImaginary() * $result->getImaginary());
+
+            $real = $delta1 / $delta3;
+            $imaginary = $delta2 / $delta3;
+
+            $result = new Complex(
+                $real,
+                $imaginary,
+                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
+            );
+        }
+
+        return $result;
+    }
+
+    /**
+     * Multiplies two or more complex numbers
+     *
+     * @param     array of string|integer|float|Complex    $complexValues   The numbers to multiply
+     * @return    Complex
+     */
+    public static function multiply(...$complexValues): Complex
+    {
+        if (count($complexValues) < 2) {
+            throw new \Exception('This function requires at least 2 arguments');
+        }
+
+        $base = array_shift($complexValues);
+        $result = clone Complex::validateComplexArgument($base);
+
+        foreach ($complexValues as $complex) {
+            $complex = Complex::validateComplexArgument($complex);
+
+            if ($result->isComplex() && $complex->isComplex() &&
+                $result->getSuffix() !== $complex->getSuffix()) {
+                throw new Exception('Suffix Mismatch');
+            }
+
+            $real = ($result->getReal() * $complex->getReal()) -
+                ($result->getImaginary() * $complex->getImaginary());
+            $imaginary = ($result->getReal() * $complex->getImaginary()) +
+                ($result->getImaginary() * $complex->getReal());
+
+            $result = new Complex(
+                $real,
+                $imaginary,
+                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
+            );
+        }
+
+        return $result;
+    }
+
+    /**
+     * Subtracts two or more complex numbers
+     *
+     * @param     array of string|integer|float|Complex    $complexValues   The numbers to subtract
+     * @return    Complex
+     */
+    public static function subtract(...$complexValues): Complex
+    {
+        if (count($complexValues) < 2) {
+            throw new \Exception('This function requires at least 2 arguments');
+        }
+
+        $base = array_shift($complexValues);
+        $result = clone Complex::validateComplexArgument($base);
+
+        foreach ($complexValues as $complex) {
+            $complex = Complex::validateComplexArgument($complex);
+
+            if ($result->isComplex() && $complex->isComplex() &&
+                $result->getSuffix() !== $complex->getSuffix()) {
+                throw new Exception('Suffix Mismatch');
+            }
+
+            $real = $result->getReal() - $complex->getReal();
+            $imaginary = $result->getImaginary() - $complex->getImaginary();
+
+            $result = new Complex(
+                $real,
+                $imaginary,
+                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
+            );
+        }
+
+        return $result;
+    }
+}

vendor/markbaker/complex/classes/src/functions/abs.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex abs() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the absolute value (modulus) of a complex number.
- * Also known as the rho of the complex number, i.e. the distance/radius
- *   from the centrepoint to the representation of the number in polar coordinates.
- *
- * This function is a synonym for rho()
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    float            The absolute (or rho) value of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- *
- * @see    rho
- *
- */
-if (!function_exists(__NAMESPACE__ . '\\abs')) {
-    function abs($complex): float
-    {
-        return rho($complex);
-    }
-}

vendor/markbaker/complex/classes/src/functions/acos.php

@@ -1,40 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex acos() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse cosine of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse cosine of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\acos')) {
-    function acos($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        $square = clone $complex;
-        $square = multiply($square, $complex);
-        $invsqrt = new Complex(1.0);
-        $invsqrt = subtract($invsqrt, $square);
-        $invsqrt = sqrt($invsqrt);
-        $adjust = new Complex(
-            $complex->getReal() - $invsqrt->getImaginary(),
-            $complex->getImaginary() + $invsqrt->getReal()
-        );
-        $log = ln($adjust);
-
-        return new Complex(
-            $log->getImaginary(),
-            -1 * $log->getReal()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/acosh.php

@@ -1,36 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex acosh() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse hyperbolic cosine of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse hyperbolic cosine of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\acosh')) {
-    function acosh($complex)
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->isReal() && ($complex->getReal() > 1)) {
-            return new Complex(\acosh($complex->getReal()));
-        }
-
-        $acosh = acos($complex)
-            ->reverse();
-        if ($acosh->getReal() < 0.0) {
-            $acosh = $acosh->invertReal();
-        }
-
-        return $acosh;
-    }
-}

vendor/markbaker/complex/classes/src/functions/acot.php

@@ -1,27 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex acot() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse cotangent of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse cotangent of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\acot')) {
-    function acot($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        return atan(inverse($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/acoth.php

@@ -1,27 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex acoth() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse hyperbolic cotangent of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse hyperbolic cotangent of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\acoth')) {
-    function acoth($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        return atanh(inverse($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/acsc.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex acsc() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse cosecant of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse cosecant of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\acsc')) {
-    function acsc($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
-            return new Complex(INF);
-        }
-
-        return asin(inverse($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/acsch.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex acsch() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse hyperbolic cosecant of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse hyperbolic cosecant of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\acsch')) {
-    function acsch($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
-            return new Complex(INF);
-        }
-
-        return asinh(inverse($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/argument.php

@@ -1,30 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex argument() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the argument of a complex number.
- * Also known as the theta of the complex number, i.e. the angle in radians
- *   from the real axis to the representation of the number in polar coordinates.
- *
- * This function is a synonym for theta()
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    float            The argument (or theta) value of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- *
- * @see    theta
- */
-if (!function_exists(__NAMESPACE__ . '\\argument')) {
-    function argument($complex): float
-    {
-        return theta($complex);
-    }
-}

vendor/markbaker/complex/classes/src/functions/asec.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex asec() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse secant of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse secant of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\asec')) {
-    function asec($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
-            return new Complex(INF);
-        }
-
-        return acos(inverse($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/asech.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex asech() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse hyperbolic secant of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse hyperbolic secant of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\asech')) {
-    function asech($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
-            return new Complex(INF);
-        }
-
-        return acosh(inverse($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/asin.php

@@ -1,39 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex asin() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse sine of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse sine of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\asin')) {
-    function asin($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        $square = multiply($complex, $complex);
-        $invsqrt = new Complex(1.0);
-        $invsqrt = subtract($invsqrt, $square);
-        $invsqrt = sqrt($invsqrt);
-        $adjust = new Complex(
-            $invsqrt->getReal() - $complex->getImaginary(),
-            $invsqrt->getImaginary() + $complex->getReal()
-        );
-        $log = ln($adjust);
-
-        return new Complex(
-            $log->getImaginary(),
-            -1 * $log->getReal()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/asinh.php

@@ -1,35 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex asinh() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse hyperbolic sine of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse hyperbolic sine of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\asinh')) {
-    function asinh($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->isReal() && ($complex->getReal() > 1)) {
-            return new Complex(\asinh($complex->getReal()));
-        }
-
-        $asinh = clone $complex;
-        $asinh = $asinh->reverse()
-            ->invertReal();
-        $asinh = asin($asinh);
-        return $asinh->reverse()
-            ->invertImaginary();
-    }
-}

vendor/markbaker/complex/classes/src/functions/atan.php

@@ -1,47 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex atan() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-//include_once 'Math/Complex.php';
-//include_once 'Math/ComplexOp.php';
-
-/**
- * Returns the inverse tangent of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse tangent of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\atan')) {
-    function atan($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->isReal()) {
-            return new Complex(\atan($complex->getReal()));
-        }
-
-        $t1Value = new Complex(-1 * $complex->getImaginary(), $complex->getReal());
-        $uValue = new Complex(1, 0);
-
-        $d1Value = clone $uValue;
-        $d1Value = subtract($d1Value, $t1Value);
-        $d2Value = add($t1Value, $uValue);
-        $uResult = $d1Value->divideBy($d2Value);
-        $uResult = ln($uResult);
-
-        return new Complex(
-            (($uResult->getImaginary() == M_PI) ? -M_PI : $uResult->getImaginary()) * -0.5,
-            $uResult->getReal() * 0.5,
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/atanh.php

@@ -1,40 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex atanh() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse hyperbolic tangent of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse hyperbolic tangent of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\atanh')) {
-    function atanh($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->isReal()) {
-            $real = $complex->getReal();
-            if ($real >= -1.0 && $real <= 1.0) {
-                return new Complex(\atanh($real));
-            } else {
-                return new Complex(\atanh(1 / $real), (($real < 0.0) ? M_PI_2 : -1 * M_PI_2));
-            }
-        }
-
-        $iComplex = clone $complex;
-        $iComplex = $iComplex->invertImaginary()
-            ->reverse();
-        return atan($iComplex)
-            ->invertReal()
-            ->reverse();
-    }
-}

vendor/markbaker/complex/classes/src/functions/conjugate.php

@@ -1,30 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex conjugate() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the complex conjugate of a complex number
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The conjugate of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\conjugate')) {
-    function conjugate($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        return new Complex(
-            $complex->getReal(),
-            -1 * $complex->getImaginary(),
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/cos.php

@@ -1,36 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex cos() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the cosine of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The cosine of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\cos')) {
-    function cos($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->isReal()) {
-            return new Complex(\cos($complex->getReal()));
-        }
-
-        return conjugate(
-            new Complex(
-                \cos($complex->getReal()) * \cosh($complex->getImaginary()),
-                \sin($complex->getReal()) * \sinh($complex->getImaginary()),
-                $complex->getSuffix()
-            )
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/cosh.php

@@ -1,34 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex cosh() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the hyperbolic cosine of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The hyperbolic cosine of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\cosh')) {
-    function cosh($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->isReal()) {
-            return new Complex(\cosh($complex->getReal()));
-        }
-
-        return new Complex(
-            \cosh($complex->getReal()) * \cos($complex->getImaginary()),
-            \sinh($complex->getReal()) * \sin($complex->getImaginary()),
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/cot.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex cot() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the cotangent of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The cotangent of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\cot')) {
-    function cot($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
-            return new Complex(INF);
-        }
-
-        return inverse(tan($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/coth.php

@@ -1,26 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex coth() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the hyperbolic cotangent of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The hyperbolic cotangent of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\coth')) {
-    function coth($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-        return inverse(tanh($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/csc.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex csc() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the cosecant of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The cosecant of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\csc')) {
-    function csc($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
-            return new Complex(INF);
-        }
-
-        return inverse(sin($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/csch.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex csch() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the hyperbolic cosecant of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The hyperbolic cosecant of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\csch')) {
-    function csch($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
-            return new Complex(INF);
-        }
-
-        return inverse(sinh($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/exp.php

@@ -1,36 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex exp() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the exponential of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The exponential of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\exp')) {
-    function exp($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if (($complex->getReal() == 0.0) && (\abs($complex->getImaginary()) == M_PI)) {
-            return new Complex(-1.0, 0.0);
-        }
-
-        $rho = \exp($complex->getReal());
-
-        return new Complex(
-            $rho * \cos($complex->getImaginary()),
-            $rho * \sin($complex->getImaginary()),
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/inverse.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex inverse() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the inverse of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The inverse of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\inverse')) {
-    function inverse($complex): Complex
-    {
-        $complex = clone Complex::validateComplexArgument($complex);
-
-        if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
-            throw new \InvalidArgumentException('Division by zero');
-        }
-
-        return $complex->divideInto(1.0);
-    }
-}

vendor/markbaker/complex/classes/src/functions/ln.php

@@ -1,35 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex ln() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the natural logarithm of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The natural logarithm of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException  If the real and the imaginary parts are both zero
- */
-if (!function_exists(__NAMESPACE__ . '\\ln')) {
-    function ln($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if (($complex->getReal() == 0.0) && ($complex->getImaginary() == 0.0)) {
-            throw new \InvalidArgumentException();
-        }
-
-        return new Complex(
-            \log(rho($complex)),
-            theta($complex),
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/log10.php

@@ -1,34 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex log10() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the common logarithm (base 10) of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The common logarithm (base 10) of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException  If the real and the imaginary parts are both zero
- */
-if (!function_exists(__NAMESPACE__ . '\\log10')) {
-    function log10($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if (($complex->getReal() == 0.0) && ($complex->getImaginary() == 0.0)) {
-            throw new \InvalidArgumentException();
-        } elseif (($complex->getReal() > 0.0) && ($complex->getImaginary() == 0.0)) {
-            return new Complex(\log10($complex->getReal()), 0.0, $complex->getSuffix());
-        }
-
-        return ln($complex)
-            ->multiply(\log10(Complex::EULER));
-    }
-}

vendor/markbaker/complex/classes/src/functions/log2.php

@@ -1,34 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex log2() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the base-2 logarithm of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The base-2 logarithm of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException  If the real and the imaginary parts are both zero
- */
-if (!function_exists(__NAMESPACE__ . '\\log2')) {
-    function log2($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if (($complex->getReal() == 0.0) && ($complex->getImaginary() == 0.0)) {
-            throw new \InvalidArgumentException();
-        } elseif (($complex->getReal() > 0.0) && ($complex->getImaginary() == 0.0)) {
-            return new Complex(\log($complex->getReal(), 2), 0.0, $complex->getSuffix());
-        }
-
-        return ln($complex)
-            ->multiply(\log(Complex::EULER, 2));
-    }
-}

vendor/markbaker/complex/classes/src/functions/negative.php

@@ -1,33 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex negative() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the negative of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The negative value of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- *
- * @see    rho
- *
- */
-if (!function_exists(__NAMESPACE__ . '\\negative')) {
-    function negative($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        return new Complex(
-            -1 * $complex->getReal(),
-            -1 * $complex->getImaginary(),
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/pow.php

@@ -1,42 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex pow() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns a complex number raised to a power.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @param     float|integer    $power      The power to raise this value to
- * @return    Complex          The complex argument raised to the real power.
- * @throws    Exception        If the power argument isn't a valid real
- */
-if (!function_exists(__NAMESPACE__ . '\\pow')) {
-    function pow($complex, $power): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if (!is_numeric($power)) {
-            throw new Exception('Power argument must be a real number');
-        }
-
-        if ($complex->getImaginary() == 0.0 && $complex->getReal() >= 0.0) {
-            return new Complex(\pow($complex->getReal(), $power));
-        }
-
-        $rValue = \sqrt(($complex->getReal() * $complex->getReal()) + ($complex->getImaginary() * $complex->getImaginary()));
-        $rPower = \pow($rValue, $power);
-        $theta = $complex->argument() * $power;
-        if ($theta == 0) {
-            return new Complex(1);
-        }
-
-        return new Complex($rPower * \cos($theta), $rPower * \sin($theta), $complex->getSuffix());
-    }
-}

vendor/markbaker/complex/classes/src/functions/rho.php

@@ -1,30 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex rho() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the rho of a complex number.
- * This is the distance/radius from the centrepoint to the representation of the number in polar coordinates.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    float            The rho value of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\rho')) {
-    function rho($complex): float
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        return \sqrt(
-            ($complex->getReal() * $complex->getReal()) +
-            ($complex->getImaginary() * $complex->getImaginary())
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/sec.php

@@ -1,27 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex sec() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the secant of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The secant of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\sec')) {
-    function sec($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        return inverse(cos($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/sech.php

@@ -1,27 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex sech() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the hyperbolic secant of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The hyperbolic secant of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\sech')) {
-    function sech($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        return inverse(cosh($complex));
-    }
-}

vendor/markbaker/complex/classes/src/functions/sin.php

@@ -1,34 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex sin() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the sine of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The sine of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\sin')) {
-    function sin($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->isReal()) {
-            return new Complex(\sin($complex->getReal()));
-        }
-
-        return new Complex(
-            \sin($complex->getReal()) * \cosh($complex->getImaginary()),
-            \cos($complex->getReal()) * \sinh($complex->getImaginary()),
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/sinh.php

@@ -1,34 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex sinh() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the hyperbolic sine of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The hyperbolic sine of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\sinh')) {
-    function sinh($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->isReal()) {
-            return new Complex(\sinh($complex->getReal()));
-        }
-
-        return new Complex(
-            \sinh($complex->getReal()) * \cos($complex->getImaginary()),
-            \cosh($complex->getReal()) * \sin($complex->getImaginary()),
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/sqrt.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex sqrt() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the square root of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The Square root of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\sqrt')) {
-    function sqrt($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        $theta = theta($complex);
-        $delta1 = \cos($theta / 2);
-        $delta2 = \sin($theta / 2);
-        $rho = \sqrt(rho($complex));
-
-        return new Complex($delta1 * $rho, $delta2 * $rho, $complex->getSuffix());
-    }
-}

vendor/markbaker/complex/classes/src/functions/tan.php

@@ -1,42 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex tan() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the tangent of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The tangent of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\tan')) {
-    function tan($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->isReal()) {
-            return new Complex(\tan($complex->getReal()));
-        }
-
-        $real = $complex->getReal();
-        $imaginary = $complex->getImaginary();
-        $divisor = 1 + \pow(\tan($real), 2) * \pow(\tanh($imaginary), 2);
-        if ($divisor == 0.0) {
-            throw new \InvalidArgumentException('Division by zero');
-        }
-
-        return new Complex(
-            \pow(sech($imaginary)->getReal(), 2) * \tan($real) / $divisor,
-            \pow(sec($real)->getReal(), 2) * \tanh($imaginary) / $divisor,
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/tanh.php

@@ -1,37 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex tanh() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the hyperbolic tangent of a complex number.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    Complex          The hyperbolic tangent of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- * @throws    \InvalidArgumentException    If function would result in a division by zero
- */
-if (!function_exists(__NAMESPACE__ . '\\tanh')) {
-    function tanh($complex): Complex
-    {
-        $complex = Complex::validateComplexArgument($complex);
-        $real = $complex->getReal();
-        $imaginary = $complex->getImaginary();
-        $divisor = \cos($imaginary) * \cos($imaginary) + \sinh($real) * \sinh($real);
-        if ($divisor == 0.0) {
-            throw new \InvalidArgumentException('Division by zero');
-        }
-
-        return new Complex(
-            \sinh($real) * \cosh($real) / $divisor,
-            0.5 * \sin(2 * $imaginary) / $divisor,
-            $complex->getSuffix()
-        );
-    }
-}

vendor/markbaker/complex/classes/src/functions/theta.php

@@ -1,40 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex theta() function
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Returns the theta of a complex number.
- *   This is the angle in radians from the real axis to the representation of the number in polar coordinates.
- *
- * @param     Complex|mixed    $complex    Complex number or a numeric value.
- * @return    float            The theta value of the complex argument.
- * @throws    Exception        If argument isn't a valid real or complex number.
- */
-if (!function_exists(__NAMESPACE__ . '\\theta')) {
-    function theta($complex): float
-    {
-        $complex = Complex::validateComplexArgument($complex);
-
-        if ($complex->getReal() == 0.0) {
-            if ($complex->isReal()) {
-                return 0.0;
-            } elseif ($complex->getImaginary() < 0.0) {
-                return M_PI / -2;
-            }
-            return M_PI / 2;
-        } elseif ($complex->getReal() > 0.0) {
-            return \atan($complex->getImaginary() / $complex->getReal());
-        } elseif ($complex->getImaginary() < 0.0) {
-            return -(M_PI - \atan(\abs($complex->getImaginary()) / \abs($complex->getReal())));
-        }
-
-        return M_PI - \atan($complex->getImaginary() / \abs($complex->getReal()));
-    }
-}

vendor/markbaker/complex/classes/src/operations/add.php

@@ -1,48 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex addition operation
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Adds two or more complex numbers
- *
- * @param     array of string|integer|float|Complex    $complexValues   The numbers to add
- * @return    Complex
- */
-if (!function_exists(__NAMESPACE__ . '\\add')) {
-    function add(...$complexValues): Complex
-    {
-        if (count($complexValues) < 2) {
-            throw new \Exception('This function requires at least 2 arguments');
-        }
-
-        $base = array_shift($complexValues);
-        $result = clone Complex::validateComplexArgument($base);
-
-        foreach ($complexValues as $complex) {
-            $complex = Complex::validateComplexArgument($complex);
-
-            if ($result->isComplex() && $complex->isComplex() &&
-                $result->getSuffix() !== $complex->getSuffix()) {
-                throw new Exception('Suffix Mismatch');
-            }
-
-            $real = $result->getReal() + $complex->getReal();
-            $imaginary = $result->getImaginary() + $complex->getImaginary();
-
-            $result = new Complex(
-                $real,
-                $imaginary,
-                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
-            );
-        }
-
-        return $result;
-    }
-}

vendor/markbaker/complex/classes/src/operations/divideby.php

@@ -1,58 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex division operation
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Divides two or more complex numbers
- *
- * @param     array of string|integer|float|Complex    $complexValues   The numbers to divide
- * @return    Complex
- */
-if (!function_exists(__NAMESPACE__ . '\\divideby')) {
-    function divideby(...$complexValues): Complex
-    {
-        if (count($complexValues) < 2) {
-            throw new \Exception('This function requires at least 2 arguments');
-        }
-
-        $base = array_shift($complexValues);
-        $result = clone Complex::validateComplexArgument($base);
-
-        foreach ($complexValues as $complex) {
-            $complex = Complex::validateComplexArgument($complex);
-
-            if ($result->isComplex() && $complex->isComplex() &&
-                $result->getSuffix() !== $complex->getSuffix()) {
-                throw new Exception('Suffix Mismatch');
-            }
-            if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
-                throw new \InvalidArgumentException('Division by zero');
-            }
-
-            $delta1 = ($result->getReal() * $complex->getReal()) +
-                ($result->getImaginary() * $complex->getImaginary());
-            $delta2 = ($result->getImaginary() * $complex->getReal()) -
-                ($result->getReal() * $complex->getImaginary());
-            $delta3 = ($complex->getReal() * $complex->getReal()) +
-                ($complex->getImaginary() * $complex->getImaginary());
-
-            $real = $delta1 / $delta3;
-            $imaginary = $delta2 / $delta3;
-
-            $result = new Complex(
-                $real,
-                $imaginary,
-                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
-            );
-        }
-
-        return $result;
-    }
-}

vendor/markbaker/complex/classes/src/operations/divideinto.php

@@ -1,58 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex division operation
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Divides two or more complex numbers
- *
- * @param     array of string|integer|float|Complex    $complexValues   The numbers to divide
- * @return    Complex
- */
-if (!function_exists(__NAMESPACE__ . '\\divideinto')) {
-    function divideinto(...$complexValues): Complex
-    {
-        if (count($complexValues) < 2) {
-            throw new \Exception('This function requires at least 2 arguments');
-        }
-
-        $base = array_shift($complexValues);
-        $result = clone Complex::validateComplexArgument($base);
-
-        foreach ($complexValues as $complex) {
-            $complex = Complex::validateComplexArgument($complex);
-
-            if ($result->isComplex() && $complex->isComplex() &&
-                $result->getSuffix() !== $complex->getSuffix()) {
-                throw new Exception('Suffix Mismatch');
-            }
-            if ($result->getReal() == 0.0 && $result->getImaginary() == 0.0) {
-                throw new \InvalidArgumentException('Division by zero');
-            }
-
-            $delta1 = ($complex->getReal() * $result->getReal()) +
-                ($complex->getImaginary() * $result->getImaginary());
-            $delta2 = ($complex->getImaginary() * $result->getReal()) -
-                ($complex->getReal() * $result->getImaginary());
-            $delta3 = ($result->getReal() * $result->getReal()) +
-                ($result->getImaginary() * $result->getImaginary());
-
-            $real = $delta1 / $delta3;
-            $imaginary = $delta2 / $delta3;
-
-            $result = new Complex(
-                $real,
-                $imaginary,
-                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
-            );
-        }
-
-        return $result;
-    }
-}

vendor/markbaker/complex/classes/src/operations/multiply.php

@@ -1,50 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex multiplication operation
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Multiplies two or more complex numbers
- *
- * @param     array of string|integer|float|Complex    $complexValues   The numbers to multiply
- * @return    Complex
- */
-if (!function_exists(__NAMESPACE__ . '\\multiply')) {
-    function multiply(...$complexValues): Complex
-    {
-        if (count($complexValues) < 2) {
-            throw new \Exception('This function requires at least 2 arguments');
-        }
-
-        $base = array_shift($complexValues);
-        $result = clone Complex::validateComplexArgument($base);
-
-        foreach ($complexValues as $complex) {
-            $complex = Complex::validateComplexArgument($complex);
-
-            if ($result->isComplex() && $complex->isComplex() &&
-                $result->getSuffix() !== $complex->getSuffix()) {
-                throw new Exception('Suffix Mismatch');
-            }
-
-            $real = ($result->getReal() * $complex->getReal()) -
-                ($result->getImaginary() * $complex->getImaginary());
-            $imaginary = ($result->getReal() * $complex->getImaginary()) +
-                ($result->getImaginary() * $complex->getReal());
-
-            $result = new Complex(
-                $real,
-                $imaginary,
-                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
-            );
-        }
-
-        return $result;
-    }
-}

vendor/markbaker/complex/classes/src/operations/subtract.php

@@ -1,48 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the complex subtraction operation
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Complex;
-
-/**
- * Subtracts two or more complex numbers
- *
- * @param     array of string|integer|float|Complex    $complexValues   The numbers to subtract
- * @return    Complex
- */
-if (!function_exists(__NAMESPACE__ . '\\subtract')) {
-    function subtract(...$complexValues): Complex
-    {
-        if (count($complexValues) < 2) {
-            throw new \Exception('This function requires at least 2 arguments');
-        }
-
-        $base = array_shift($complexValues);
-        $result = clone Complex::validateComplexArgument($base);
-
-        foreach ($complexValues as $complex) {
-            $complex = Complex::validateComplexArgument($complex);
-
-            if ($result->isComplex() && $complex->isComplex() &&
-                $result->getSuffix() !== $complex->getSuffix()) {
-                throw new Exception('Suffix Mismatch');
-            }
-
-            $real = $result->getReal() - $complex->getReal();
-            $imaginary = $result->getImaginary() - $complex->getImaginary();
-
-            $result = new Complex(
-                $real,
-                $imaginary,
-                ($imaginary == 0.0) ? null : max($result->getSuffix(), $complex->getSuffix())
-            );
-        }
-
-        return $result;
-    }
-}

vendor/markbaker/complex/composer.json

@@ -11,63 +11,26 @@
             "email": "mark@lange.demon.co.uk"
         }
     ],
+    "config": {
+        "sort-packages": true,
+        "allow-plugins": {
+            "dealerdirect/phpcodesniffer-composer-installer": true,
+            "markbaker/ukraine": true
+        }
+    },
     "require": {
         "php": "^7.2 || ^8.0"
     },
     "require-dev": {
-        "phpunit/phpunit": "^7.0 || ^8.0 || ^9.3",
-        "squizlabs/php_codesniffer": "^3.4",
-        "phpcompatibility/php-compatibility": "^9.0",
-        "dealerdirect/phpcodesniffer-composer-installer": "^0.7.0"
+        "phpunit/phpunit": "^7.0 || ^8.0 || ^9.0",
+        "squizlabs/php_codesniffer": "^3.7",
+        "phpcompatibility/php-compatibility": "^9.3",
+        "dealerdirect/phpcodesniffer-composer-installer": "dev-master"
     },
     "autoload": {
         "psr-4": {
             "Complex\\": "classes/src/"
-        },
-        "files": [
-            "classes/src/functions/abs.php",
-            "classes/src/functions/acos.php",
-            "classes/src/functions/acosh.php",
-            "classes/src/functions/acot.php",
-            "classes/src/functions/acoth.php",
-            "classes/src/functions/acsc.php",
-            "classes/src/functions/acsch.php",
-            "classes/src/functions/argument.php",
-            "classes/src/functions/asec.php",
-            "classes/src/functions/asech.php",
-            "classes/src/functions/asin.php",
-            "classes/src/functions/asinh.php",
-            "classes/src/functions/atan.php",
-            "classes/src/functions/atanh.php",
-            "classes/src/functions/conjugate.php",
-            "classes/src/functions/cos.php",
-            "classes/src/functions/cosh.php",
-            "classes/src/functions/cot.php",
-            "classes/src/functions/coth.php",
-            "classes/src/functions/csc.php",
-            "classes/src/functions/csch.php",
-            "classes/src/functions/exp.php",
-            "classes/src/functions/inverse.php",
-            "classes/src/functions/ln.php",
-            "classes/src/functions/log2.php",
-            "classes/src/functions/log10.php",
-            "classes/src/functions/negative.php",
-            "classes/src/functions/pow.php",
-            "classes/src/functions/rho.php",
-            "classes/src/functions/sec.php",
-            "classes/src/functions/sech.php",
-            "classes/src/functions/sin.php",
-            "classes/src/functions/sinh.php",
-            "classes/src/functions/sqrt.php",
-            "classes/src/functions/tan.php",
-            "classes/src/functions/tanh.php",
-            "classes/src/functions/theta.php",
-            "classes/src/operations/add.php",
-            "classes/src/operations/subtract.php",
-            "classes/src/operations/multiply.php",
-            "classes/src/operations/divideby.php",
-            "classes/src/operations/divideinto.php"
-        ]
+        }
     },
     "scripts": {
         "style": "phpcs --report-width=200 --standard=PSR2 --report=summary,full classes/src/ unitTests/classes/src -n",

vendor/markbaker/complex/examples/complexTest.php

@@ -2,7 +2,7 @@
 
 use Complex\Complex as Complex;
 
-include('../classes/Bootstrap.php');
+include(__DIR__ . '/../vendor/autoload.php');
 
 echo 'Create', PHP_EOL;
 

vendor/markbaker/complex/examples/testFunctions.php

@@ -2,7 +2,7 @@
 
 namespace Complex;
 
-include('../classes/Bootstrap.php');
+include(__DIR__ . '/../vendor/autoload.php');
 
 echo 'Function Examples', PHP_EOL;
 
@@ -39,7 +39,7 @@ $functions = array(
 for ($real = -3.5; $real <= 3.5; $real += 0.5) {
     for ($imaginary = -3.5; $imaginary <= 3.5; $imaginary += 0.5) {
         foreach ($functions as $function) {
-            $complexFunction = __NAMESPACE__ . '\\' . $function;
+            $complexFunction = __NAMESPACE__ . '\\Functions::' . $function;
             $complex = new Complex($real, $imaginary);
             try {
                 echo $function, '(', $complex, ') = ', $complexFunction($complex), PHP_EOL;

vendor/markbaker/complex/examples/testOperations.php

@@ -1,8 +1,9 @@
 <?php
 
 use Complex\Complex as Complex;
+use Complex\Operations;
 
-include('../classes/Bootstrap.php');
+include(__DIR__ . '/../vendor/autoload.php');
 
 $values = [
     new Complex(123),
@@ -16,19 +17,19 @@ foreach ($values as $value) {
 
 echo 'Addition', PHP_EOL;
 
-$result = \Complex\add(...$values);
+$result = Operations::add(...$values);
 echo '=> ', $result, PHP_EOL;
 
 echo PHP_EOL;
 
 echo 'Subtraction', PHP_EOL;
 
-$result = \Complex\subtract(...$values);
+$result = Operations::subtract(...$values);
 echo '=> ', $result, PHP_EOL;
 
 echo PHP_EOL;
 
 echo 'Multiplication', PHP_EOL;
 
-$result = \Complex\multiply(...$values);
+$result = Operations::multiply(...$values);
 echo '=> ', $result, PHP_EOL;

vendor/markbaker/matrix/README.md

@@ -5,7 +5,11 @@ PHPMatrix
 
 PHP Class for handling Matrices
 
-[![Build Status](https://travis-ci.org/MarkBaker/PHPMatrix.png?branch=2.0)](http://travis-ci.org/MarkBaker/PHPMatrix)
+[![Build Status](https://github.com/MarkBaker/PHPMatrix/workflows/main/badge.svg)](https://github.com/MarkBaker/PHPMatrix/actions)
+[![Total Downloads](https://img.shields.io/packagist/dt/markbaker/matrix)](https://packagist.org/packages/markbaker/matrix)
+[![Latest Stable Version](https://img.shields.io/github/v/release/MarkBaker/PHPMatrix)](https://packagist.org/packages/markbaker/matrix)
+[![License](https://img.shields.io/github/license/MarkBaker/PHPMatrix)](https://packagist.org/packages/markbaker/matrix)
+
 
 [![Matrix Transform](https://imgs.xkcd.com/comics/matrix_transform.png)](https://xkcd.com/184/)
 
@@ -60,6 +64,24 @@ and classes for
 
 ---
 
+# Installation
+
+```shell
+composer require markbaker/matrix:^3.0
+```
+
+# Important BC Note
+
+If you've previously been using procedural calls to functions and operations using this library, then from version 3.0 you should use [MarkBaker/PHPMatrixFunctions](https://github.com/MarkBaker/PHPMatrixFunctions) instead (available on packagist as [markbaker/matrix-functions](https://packagist.org/packages/markbaker/matrix-functions)).
+
+You'll need to replace `markbaker/matrix`in your `composer.json` file with the new library, but otherwise there should be no difference in the namespacing, or in the way that you have called the Matrix functions in the past, so no actual code changes are required.
+
+```shell
+composer require markbaker/matrix-functions:^1.0
+```
+
+You should not reference this library (`markbaker/matrix`) in your `composer.json`, composer wil take care of that for you.
+
 # Usage
 
 To create a new Matrix object, provide an array as the constructor argument
@@ -105,7 +127,7 @@ $matrix2 = new Matrix\Matrix([
 
 var_dump($matrix1->multiply($matrix2)->toArray());
 ```
-or pass all values to the appropriate function
+or pass all values to the appropriate static method
 ```php
 $matrix1 = new Matrix\Matrix([
     [2, 7, 6],
@@ -118,7 +140,7 @@ $matrix2 = new Matrix\Matrix([
     [7, 8, 9],
 ]);
 
-var_dump(Matrix\multiply($matrix1, $matrix2)->toArray());
+var_dump(Matrix\Operations::multiply($matrix1, $matrix2)->toArray());
 ```
 You can pass in the arguments as Matrix objects, or as arrays.
 
@@ -139,30 +161,7 @@ $matrix = new Matrix\Matrix($grid);
 
 echo $matrix->trace();
 ```
-or you can call the function as you would in procedural code, passing the Matrix object as an argument 
-```php
-$grid = [
-    [16,  3,  2, 13],
-    [ 5, 10, 11,  8],
-    [ 9,  6,  7, 12],
-    [ 4, 15, 14,  1],
-];
-
-$matrix = new Matrix\Matrix($grid);
-echo Matrix\trace($matrix);
-```
-When called procedurally using the function, you can pass in the argument as a Matrix object, or as an array.
-```php
-$grid = [
-    [16,  3,  2, 13],
-    [ 5, 10, 11,  8],
-    [ 9,  6,  7, 12],
-    [ 4, 15, 14,  1],
-];
-
-echo Matrix\trace($grid);
-```
-As an alternative, it is also possible to call the method directly from the `Functions` class.
+or you can call the static method, passing the Matrix object or array as an argument 
 ```php
 $grid = [
     [16,  3,  2, 13],
@@ -174,7 +173,16 @@ $grid = [
 $matrix = new Matrix\Matrix($grid);
 echo Matrix\Functions::trace($matrix);
 ```
-Used this way, methods must be called statically, and the argument must be the Matrix object, and cannot be an array.
+```php
+$grid = [
+    [16,  3,  2, 13],
+    [ 5, 10, 11,  8],
+    [ 9,  6,  7, 12],
+    [ 4, 15, 14,  1],
+];
+
+echo Matrix\Functions::trace($grid);
+```
 
 ## Decomposition
 

vendor/markbaker/matrix/classes/src/Functions.php

@@ -4,6 +4,25 @@ namespace Matrix;
 
 class Functions
 {
+    /**
+     * Validates an array of matrix, converting an array to a matrix if required.
+     *
+     * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
+     * @return Matrix The new matrix
+     * @throws Exception If argument isn't a valid matrix or array.
+     */
+    private static function validateMatrix($matrix)
+    {
+        if (is_array($matrix)) {
+            $matrix = new Matrix($matrix);
+        }
+        if (!$matrix instanceof Matrix) {
+            throw new Exception('Must be Matrix or array');
+        }
+
+        return $matrix;
+    }
+
     /**
      * Calculate the adjoint of the matrix
      *
@@ -25,12 +44,14 @@ class Functions
      * The adjugate has sometimes been called the "adjoint", but today the "adjoint" of a matrix normally refers
      *     to its corresponding adjoint operator, which is its conjugate transpose.
      *
-     * @param Matrix $matrix The matrix whose adjoint we wish to calculate
+     * @param Matrix|array $matrix The matrix whose adjoint we wish to calculate
      * @return Matrix
      * @throws Exception
      **/
-    public static function adjoint(Matrix $matrix)
+    public static function adjoint($matrix)
     {
+        $matrix = self::validateMatrix($matrix);
+
         if (!$matrix->isSquare()) {
             throw new Exception('Adjoint can only be calculated for a square matrix');
         }
@@ -67,13 +88,15 @@ class Functions
     /**
      * Return the cofactors of this matrix
      *
-     * @param Matrix $matrix The matrix whose cofactors we wish to calculate
+     * @param Matrix|array $matrix The matrix whose cofactors we wish to calculate
      * @return Matrix
      *
      * @throws Exception
      */
-    public static function cofactors(Matrix $matrix)
+    public static function cofactors($matrix)
     {
+        $matrix = self::validateMatrix($matrix);
+
         if (!$matrix->isSquare()) {
             throw new Exception('Cofactors can only be calculated for a square matrix');
         }
@@ -141,12 +164,14 @@ class Functions
     /**
      * Return the determinant of this matrix
      *
-     * @param Matrix $matrix The matrix whose determinant we wish to calculate
+     * @param Matrix|array $matrix The matrix whose determinant we wish to calculate
      * @return float
      * @throws Exception
      **/
-    public static function determinant(Matrix $matrix)
+    public static function determinant($matrix)
     {
+        $matrix = self::validateMatrix($matrix);
+
         if (!$matrix->isSquare()) {
             throw new Exception('Determinant can only be calculated for a square matrix');
         }
@@ -157,12 +182,14 @@ class Functions
     /**
      * Return the diagonal of this matrix
      *
-     * @param Matrix $matrix The matrix whose diagonal we wish to calculate
+     * @param Matrix|array $matrix The matrix whose diagonal we wish to calculate
      * @return Matrix
      * @throws Exception
      **/
-    public static function diagonal(Matrix $matrix)
+    public static function diagonal($matrix)
     {
+        $matrix = self::validateMatrix($matrix);
+
         if (!$matrix->isSquare()) {
             throw new Exception('Diagonal can only be extracted from a square matrix');
         }
@@ -181,12 +208,14 @@ class Functions
     /**
      * Return the antidiagonal of this matrix
      *
-     * @param Matrix $matrix The matrix whose antidiagonal we wish to calculate
+     * @param Matrix|array $matrix The matrix whose antidiagonal we wish to calculate
      * @return Matrix
      * @throws Exception
      **/
-    public static function antidiagonal(Matrix $matrix)
+    public static function antidiagonal($matrix)
     {
+        $matrix = self::validateMatrix($matrix);
+
         if (!$matrix->isSquare()) {
             throw new Exception('Anti-Diagonal can only be extracted from a square matrix');
         }
@@ -207,12 +236,14 @@ class Functions
      * The identity matrix, or sometimes ambiguously called a unit matrix, of size n is the n × n square matrix
      *   with ones on the main diagonal and zeros elsewhere
      *
-     * @param Matrix $matrix The matrix whose identity we wish to calculate
+     * @param Matrix|array $matrix The matrix whose identity we wish to calculate
      * @return Matrix
      * @throws Exception
      **/
-    public static function identity(Matrix $matrix)
+    public static function identity($matrix)
     {
+        $matrix = self::validateMatrix($matrix);
+
         if (!$matrix->isSquare()) {
             throw new Exception('Identity can only be created for a square matrix');
         }
@@ -225,12 +256,14 @@ class Functions
     /**
      * Return the inverse of this matrix
      *
-     * @param Matrix $matrix The matrix whose inverse we wish to calculate
+     * @param Matrix|array $matrix The matrix whose inverse we wish to calculate
      * @return Matrix
      * @throws Exception
      **/
-    public static function inverse(Matrix $matrix, string $type = 'inverse')
+    public static function inverse($matrix, string $type = 'inverse')
     {
+        $matrix = self::validateMatrix($matrix);
+
         if (!$matrix->isSquare()) {
             throw new Exception(ucfirst($type) . ' can only be calculated for a square matrix');
         }
@@ -281,12 +314,14 @@ class Functions
      *     calculating matrix cofactors, which in turn are useful for computing both the determinant and inverse of
      *     square matrices.
      *
-     * @param Matrix $matrix The matrix whose minors we wish to calculate
+     * @param Matrix|array $matrix The matrix whose minors we wish to calculate
      * @return Matrix
      * @throws Exception
      **/
-    public static function minors(Matrix $matrix)
+    public static function minors($matrix)
     {
+        $matrix = self::validateMatrix($matrix);
+
         if (!$matrix->isSquare()) {
             throw new Exception('Minors can only be calculated for a square matrix');
         }
@@ -299,12 +334,14 @@ class Functions
      * The trace is defined as the sum of the elements on the main diagonal (the diagonal from the upper left to the lower right)
      *     of the matrix
      *
-     * @param Matrix $matrix The matrix whose trace we wish to calculate
+     * @param Matrix|array $matrix The matrix whose trace we wish to calculate
      * @return float
      * @throws Exception
      **/
-    public static function trace(Matrix $matrix)
+    public static function trace($matrix)
     {
+        $matrix = self::validateMatrix($matrix);
+
         if (!$matrix->isSquare()) {
             throw new Exception('Trace can only be extracted from a square matrix');
         }
@@ -321,11 +358,13 @@ class Functions
     /**
      * Return the transpose of this matrix
      *
-     * @param Matrix $matrix The matrix whose transpose we wish to calculate
+     * @param Matrix|\a $matrix The matrix whose transpose we wish to calculate
      * @return Matrix
      **/
-    public static function transpose(Matrix $matrix)
+    public static function transpose($matrix)
     {
+        $matrix = self::validateMatrix($matrix);
+
         $array = array_values(array_merge([null], $matrix->toArray()));
         $grid = call_user_func_array(
             'array_map',

vendor/markbaker/matrix/classes/src/Functions/adjoint.php

@@ -1,32 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix adjoint() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-/**
- * Returns the adjoint of a matrix or an array.
- *
- * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
- * @return Matrix The new matrix
- * @throws Exception If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\adjoint')) {
-    function adjoint($matrix): Matrix
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::adjoint($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Functions/antidiagonal.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix antidiagonal() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-namespace Matrix;
-
-/**
- * Returns the antidiagonal of a matrix or an array.
- *
- * @param     Matrix|array     $matrix    Matrix or an array to treat as a matrix.
- * @return    Matrix           The new matrix
- * @throws    Exception        If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\antidiagonal')) {
-    function antidiagonal($matrix): Matrix
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::antidiagonal($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Functions/cofactors.php

@@ -1,32 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix cofactors() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-/**
- * Returns the cofactors of a matrix or an array.
- *
- * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
- * @return Matrix The new matrix
- * @throws Exception If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\cofactors')) {
-    function cofactors($matrix): Matrix
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::cofactors($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Functions/determinant.php

@@ -1,32 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix determinant() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-/**
- * Returns the determinant of a matrix or an array.
- *
- * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
- * @return float Matrix determinant
- * @throws Exception If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\determinant')) {
-    function determinant($matrix): float
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::determinant($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Functions/diagonal.php

@@ -1,32 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix diagonal() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-/**
- * Returns the diagonal of a matrix or an array.
- *
- * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
- * @return Matrix The new matrix
- * @throws Exception If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\diagonal')) {
-    function diagonal($matrix): Matrix
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::diagonal($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Functions/identity.php

@@ -1,32 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix identity() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-/**
- * Returns the identity of a matrix or an array.
- *
- * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
- * @return Matrix The identity matrix
- * @throws Exception If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\identity')) {
-    function identity($matrix): Matrix
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::identity($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Functions/inverse.php

@@ -1,32 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix inverse() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-/**
- * Returns the inverse of a matrix or an array.
- *
- * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
- * @return Matrix The new matrix
- * @throws Exception If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\inverse')) {
-    function inverse($matrix): Matrix
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::inverse($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Functions/minors.php

@@ -1,32 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix minors() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-/**
- * Returns the minors of a matrix or an array.
- *
- * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
- * @return Matrix The new matrix
- * @throws Exception If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\minors')) {
-    function minors($matrix): Matrix
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::minors($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Functions/trace.php

@@ -1,32 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix trace() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-/**
- * Returns the trace of a matrix or an array.
- *
- * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
- * @return float The trace of the matrix
- * @throws Exception If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\trace')) {
-    function trace($matrix): float
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::trace($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Functions/transpose.php

@@ -1,32 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix transpose() function
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-/**
- * Returns the transpose of a matrix or an array.
- *
- * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
- * @return Matrix The transposed matrix
- * @throws Exception If argument isn't a valid matrix or array.
- */
-if (!function_exists(__NAMESPACE__ . '\\transpose')) {
-    function transpose($matrix): Matrix
-    {
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Must be Matrix or array');
-        }
-
-        return Functions::transpose($matrix);
-    }
-}

vendor/markbaker/matrix/classes/src/Matrix.php

@@ -28,7 +28,6 @@ use Matrix\Decomposition\QR;
  * @method Matrix diagonal()
  * @method Matrix identity()
  * @method Matrix inverse()
- * @method Matrix pseudoInverse()
  * @method Matrix minors()
  * @method float trace()
  * @method Matrix transpose()
@@ -411,12 +410,13 @@ class Matrix
     {
         $functionName = strtolower(str_replace('_', '', $functionName));
 
-        if (in_array($functionName, self::$functions, true) || in_array($functionName, self::$operations, true)) {
-            $functionName = "\\" . __NAMESPACE__ . "\\{$functionName}";
-            if (is_callable($functionName)) {
-                $arguments = array_values(array_merge([$this], $arguments));
-                return call_user_func_array($functionName, $arguments);
-            }
+        // Test for function calls
+        if (in_array($functionName, self::$functions, true)) {
+            return Functions::$functionName($this, ...$arguments);
+        }
+        // Test for operation calls
+        if (in_array($functionName, self::$operations, true)) {
+            return Operations::$functionName($this, ...$arguments);
         }
         throw new Exception('Function or Operation does not exist');
     }

vendor/markbaker/matrix/classes/src/Operations.php

@@ -0,0 +1,157 @@
+<?php
+
+namespace Matrix;
+
+use Matrix\Operators\Addition;
+use Matrix\Operators\DirectSum;
+use Matrix\Operators\Division;
+use Matrix\Operators\Multiplication;
+use Matrix\Operators\Subtraction;
+
+class Operations
+{
+    public static function add(...$matrixValues): Matrix
+    {
+        if (count($matrixValues) < 2) {
+            throw new Exception('Addition operation requires at least 2 arguments');
+        }
+
+        $matrix = array_shift($matrixValues);
+
+        if (is_array($matrix)) {
+            $matrix = new Matrix($matrix);
+        }
+        if (!$matrix instanceof Matrix) {
+            throw new Exception('Addition arguments must be Matrix or array');
+        }
+
+        $result = new Addition($matrix);
+
+        foreach ($matrixValues as $matrix) {
+            $result->execute($matrix);
+        }
+
+        return $result->result();
+    }
+
+    public static function directsum(...$matrixValues): Matrix
+    {
+        if (count($matrixValues) < 2) {
+            throw new Exception('DirectSum operation requires at least 2 arguments');
+        }
+
+        $matrix = array_shift($matrixValues);
+
+        if (is_array($matrix)) {
+            $matrix = new Matrix($matrix);
+        }
+        if (!$matrix instanceof Matrix) {
+            throw new Exception('DirectSum arguments must be Matrix or array');
+        }
+
+        $result = new DirectSum($matrix);
+
+        foreach ($matrixValues as $matrix) {
+            $result->execute($matrix);
+        }
+
+        return $result->result();
+    }
+
+    public static function divideby(...$matrixValues): Matrix
+    {
+        if (count($matrixValues) < 2) {
+            throw new Exception('Division operation requires at least 2 arguments');
+        }
+
+        $matrix = array_shift($matrixValues);
+
+        if (is_array($matrix)) {
+            $matrix = new Matrix($matrix);
+        }
+        if (!$matrix instanceof Matrix) {
+            throw new Exception('Division arguments must be Matrix or array');
+        }
+
+        $result = new Division($matrix);
+
+        foreach ($matrixValues as $matrix) {
+            $result->execute($matrix);
+        }
+
+        return $result->result();
+    }
+
+    public static function divideinto(...$matrixValues): Matrix
+    {
+        if (count($matrixValues) < 2) {
+            throw new Exception('Division operation requires at least 2 arguments');
+        }
+
+        $matrix = array_pop($matrixValues);
+        $matrixValues = array_reverse($matrixValues);
+
+        if (is_array($matrix)) {
+            $matrix = new Matrix($matrix);
+        }
+        if (!$matrix instanceof Matrix) {
+            throw new Exception('Division arguments must be Matrix or array');
+        }
+
+        $result = new Division($matrix);
+
+        foreach ($matrixValues as $matrix) {
+            $result->execute($matrix);
+        }
+
+        return $result->result();
+    }
+
+    public static function multiply(...$matrixValues): Matrix
+    {
+        if (count($matrixValues) < 2) {
+            throw new Exception('Multiplication operation requires at least 2 arguments');
+        }
+
+        $matrix = array_shift($matrixValues);
+
+        if (is_array($matrix)) {
+            $matrix = new Matrix($matrix);
+        }
+        if (!$matrix instanceof Matrix) {
+            throw new Exception('Multiplication arguments must be Matrix or array');
+        }
+
+        $result = new Multiplication($matrix);
+
+        foreach ($matrixValues as $matrix) {
+            $result->execute($matrix);
+        }
+
+        return $result->result();
+    }
+
+    public static function subtract(...$matrixValues): Matrix
+    {
+        if (count($matrixValues) < 2) {
+            throw new Exception('Subtraction operation requires at least 2 arguments');
+        }
+
+        $matrix = array_shift($matrixValues);
+
+        if (is_array($matrix)) {
+            $matrix = new Matrix($matrix);
+        }
+        if (!$matrix instanceof Matrix) {
+            throw new Exception('Subtraction arguments must be Matrix or array');
+        }
+
+        $result = new Subtraction($matrix);
+
+        foreach ($matrixValues as $matrix) {
+            $result->execute($matrix);
+        }
+
+        return $result->result();
+    }
+}

vendor/markbaker/matrix/classes/src/Operations/add.php

@@ -1,46 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix addition operation
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-use Matrix\Operators\Addition;
-
-/**
- * Adds two or more matrices
- *
- * @param array<int, mixed> $matrixValues The matrices to add
- * @return Matrix
- * @throws Exception
- */
-if (!function_exists(__NAMESPACE__ . '\\add')) {
-    function add(...$matrixValues): Matrix
-    {
-        if (count($matrixValues) < 2) {
-            throw new Exception('Addition operation requires at least 2 arguments');
-        }
-
-        $matrix = array_shift($matrixValues);
-
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Addition arguments must be Matrix or array');
-        }
-
-        $result = new Addition($matrix);
-
-        foreach ($matrixValues as $matrix) {
-            $result->execute($matrix);
-        }
-
-        return $result->result();
-    }
-}

vendor/markbaker/matrix/classes/src/Operations/directsum.php

@@ -1,46 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix direct sum operation
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-use Matrix\Operators\DirectSum;
-
-/**
- * Adds two or more matrices
- *
- * @param array<int, mixed> $matrixValues The matrices to add
- * @return Matrix
- * @throws Exception
- */
-if (!function_exists(__NAMESPACE__ . '\\directsum')) {
-    function directsum(...$matrixValues): Matrix
-    {
-        if (count($matrixValues) < 2) {
-            throw new Exception('DirectSum operation requires at least 2 arguments');
-        }
-
-        $matrix = array_shift($matrixValues);
-
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('DirectSum arguments must be Matrix or array');
-        }
-
-        $result = new DirectSum($matrix);
-
-        foreach ($matrixValues as $matrix) {
-            $result->execute($matrix);
-        }
-
-        return $result->result();
-    }
-}

vendor/markbaker/matrix/classes/src/Operations/divideby.php

@@ -1,46 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix division operation
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPComplex)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-use Matrix\Operators\Division;
-
-/**
- * Divides two or more matrix numbers
- *
- * @param array<int, mixed> $matrixValues The matrices to divide
- * @return Matrix
- * @throws Exception
- */
-if (!function_exists(__NAMESPACE__ . '\\divideby')) {
-    function divideby(...$matrixValues): Matrix
-    {
-        if (count($matrixValues) < 2) {
-            throw new Exception('Division operation requires at least 2 arguments');
-        }
-
-        $matrix = array_shift($matrixValues);
-
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Division arguments must be Matrix or array');
-        }
-
-        $result = new Division($matrix);
-
-        foreach ($matrixValues as $matrix) {
-            $result->execute($matrix);
-        }
-
-        return $result->result();
-    }
-}

vendor/markbaker/matrix/classes/src/Operations/divideinto.php

@@ -1,47 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix division operation
- *
- * @copyright  Copyright (c) 2013-2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-use Matrix\Operators\Division;
-
-/**
- * Divides two or more matrix numbers
- *
- * @param array<int, mixed> $matrixValues The numbers to divide
- * @return Matrix
- * @throws Exception
- */
-if (!function_exists(__NAMESPACE__ . '\\divideinto')) {
-    function divideinto(...$matrixValues): Matrix
-    {
-        if (count($matrixValues) < 2) {
-            throw new Exception('Division operation requires at least 2 arguments');
-        }
-
-        $matrix = array_pop($matrixValues);
-        $matrixValues = array_reverse($matrixValues);
-
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Division arguments must be Matrix or array');
-        }
-
-        $result = new Division($matrix);
-
-        foreach ($matrixValues as $matrix) {
-            $result->execute($matrix);
-        }
-
-        return $result->result();
-    }
-}

vendor/markbaker/matrix/classes/src/Operations/multiply.php

@@ -1,46 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix multiplication operation
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-use Matrix\Operators\Multiplication;
-
-/**
- * Multiplies two or more matrices
- *
- * @param array<int, mixed> $matrixValues The matrices to multiply
- * @return Matrix
- * @throws Exception
- */
-if (!function_exists(__NAMESPACE__ . '\\multiply')) {
-    function multiply(...$matrixValues): Matrix
-    {
-        if (count($matrixValues) < 2) {
-            throw new Exception('Multiplication operation requires at least 2 arguments');
-        }
-
-        $matrix = array_shift($matrixValues);
-
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Multiplication arguments must be Matrix or array');
-        }
-
-        $result = new Multiplication($matrix);
-
-        foreach ($matrixValues as $matrix) {
-            $result->execute($matrix);
-        }
-
-        return $result->result();
-    }
-}

vendor/markbaker/matrix/classes/src/Operations/subtract.php

@@ -1,46 +0,0 @@
-<?php
-
-/**
- *
- * Function code for the matrix subtraction operation
- *
- * @copyright  Copyright (c) 2018 Mark Baker (https://github.com/MarkBaker/PHPMatrix)
- * @license    https://opensource.org/licenses/MIT    MIT
- */
-
-namespace Matrix;
-
-use Matrix\Operators\Subtraction;
-
-/**
- * Subtracts two or more matrices
- *
- * @param array<int, mixed> $matrixValues The matrices to subtract
- * @return Matrix
- * @throws Exception
- */
-if (!function_exists(__NAMESPACE__ . '\\subtract')) {
-    function subtract(...$matrixValues): Matrix
-    {
-        if (count($matrixValues) < 2) {
-            throw new Exception('Subtraction operation requires at least 2 arguments');
-        }
-
-        $matrix = array_shift($matrixValues);
-
-        if (is_array($matrix)) {
-            $matrix = new Matrix($matrix);
-        }
-        if (!$matrix instanceof Matrix) {
-            throw new Exception('Subtraction arguments must be Matrix or array');
-        }
-
-        $result = new Subtraction($matrix);
-
-        foreach ($matrixValues as $matrix) {
-            $result->execute($matrix);
-        }
-
-        return $result->result();
-    }
-}

vendor/markbaker/matrix/composer.json

@@ -11,12 +11,6 @@
             "email": "mark@demon-angel.eu"
         }
     ],
-    "config": {
-        "sort-packages": true,
-        "allow-plugins": {
-            "dealerdirect/phpcodesniffer-composer-installer": true
-        }
-    },
     "require": {
         "php": "^7.1 || ^8.0"
     },
@@ -33,48 +27,12 @@
     "autoload": {
         "psr-4": {
             "Matrix\\": "classes/src/"
-        },
-        "files": [
-            "classes/src/Functions/adjoint.php",
-            "classes/src/Functions/antidiagonal.php",
-            "classes/src/Functions/cofactors.php",
-            "classes/src/Functions/determinant.php",
-            "classes/src/Functions/diagonal.php",
-            "classes/src/Functions/identity.php",
-            "classes/src/Functions/inverse.php",
-            "classes/src/Functions/minors.php",
-            "classes/src/Functions/trace.php",
-            "classes/src/Functions/transpose.php",
-            "classes/src/Operations/add.php",
-            "classes/src/Operations/directsum.php",
-            "classes/src/Operations/subtract.php",
-            "classes/src/Operations/multiply.php",
-            "classes/src/Operations/divideby.php",
-            "classes/src/Operations/divideinto.php"
-        ]
+        }
     },
     "autoload-dev": {
         "psr-4": {
             "MatrixTest\\": "unitTests/classes/src/"
-        },
-        "files": [
-            "classes/src/Functions/adjoint.php",
-            "classes/src/Functions/antidiagonal.php",
-            "classes/src/Functions/cofactors.php",
-            "classes/src/Functions/determinant.php",
-            "classes/src/Functions/diagonal.php",
-            "classes/src/Functions/identity.php",
-            "classes/src/Functions/inverse.php",
-            "classes/src/Functions/minors.php",
-            "classes/src/Functions/trace.php",
-            "classes/src/Functions/transpose.php",
-            "classes/src/Operations/add.php",
-            "classes/src/Operations/directsum.php",
-            "classes/src/Operations/subtract.php",
-            "classes/src/Operations/multiply.php",
-            "classes/src/Operations/divideby.php",
-            "classes/src/Operations/divideinto.php"
-        ]
+        }
     },
     "scripts": {
         "style": "phpcs --report-width=200 --standard=PSR2 --report=summary,full classes/src/ unitTests/classes/src -n",
@@ -85,5 +43,10 @@
         "versions": "phpcs --report-width=200 --standard=PHPCompatibility --report=summary,full classes/src/ --runtime-set testVersion 7.2- -n",
         "coverage": "phpunit -c phpunit.xml.dist --coverage-text --coverage-html ./build/coverage"
     },
-    "minimum-stability": "dev"
-}
+    "minimum-stability": "dev",
+    "config": {
+        "allow-plugins": {
+            "dealerdirect/phpcodesniffer-composer-installer": true
+        }
+    }
+}

vendor/markbaker/matrix/examples/test.php

@@ -6,13 +6,13 @@ use Matrix\Decomposition\QR;
 include __DIR__ . '/../vendor/autoload.php';
 
 $grid = [
-    [1, 2],
-    [3, 4],
+    [0, 1],
+    [-1, 0],
 ];
 
 $targetGrid = [
     [-1],
-    [-2],
+    [2],
 ];
 
 $matrix = new Matrix($grid);