Test equality of this matrix with another
mA == mB iff
- mA->rows() == mB->rows()
- mA->columns() == mB->columns()
- mA->get(i,j) ==[=] mB->get(i,j)

@param \Chippyash\Matrix\Matrix $mB
@param boolean $strict Check type and value

@return boolean
184674
public function equality(Matrix $mB, $strict = true)
    {
        if ($this->rows() != $mB->rows()) {
            return false;
        }
        if ($this->columns() != $mB->columns()) {
            return false;
        }

        return $this->checkEntryEquality($mB, $strict);
    }
1119634
function strictEqual(actual, expected, message) {
    if (actual === expected) {
      this.pass(message);
    }
    else {
      this.fail({
        actual: actual,
        expected: expected,
        message: message,
        operator: "==="
      });
    }
  }
761017
public function contains($value, bool $strict = false): bool
    {
        return (bool) in_array($this->storage, $value, $strict);
    }
78323
public static function match($value, $expect, $strict = true)
    {
        if ($strict) {
            if (!array_search((string)$expect, (new static)->getConstList())) {
                return false;
            }
        }

        return (string)$value === (string)$expect;
    }
603869
public static function eq($val, $expected, $strict = true): bool
    {
        return $strict ? $val === $expected : $val == $expected;
    }
472673
public function compare($strict = false)
    {
        return CompareHelper::compare($this->compare1, $this->operator, $this->compare2, $strict);
    }
913226
public function where($key, $value, bool $strict = true): ArrayCollection
    {
        return $this->filter(function ($item) use ($key, $value, $strict) {
            if (!isset($item[$key])) {
                return false;
            }

            return $strict ? $item[$key] === $value : $item[$key] == $value;
        });
    }
199323
public static function ucfirst(&$str, bool $strict=false) {
		if (\is_array($str)) {
			foreach ($str as $k=>$v) {
				static::ucfirst($str[$k], $strict);
			}
		}
		elseif (! $strict || \is_string($str)) {
			cast::string($str, true);

			if ($str) {
				if (
					\function_exists('mb_substr') &&
					(
						! \function_exists('mb_check_encoding') ||
						! \mb_check_encoding($str, 'ASCII')
					)
				) {
					$first = v_mb::substr($str, 0, 1);
					static::strtoupper($first, false);
					$str = $first . v_mb::substr($str, 1, null);
				}
				else {
					$str = \ucfirst($str);
				}
			}
		}
	}
1157803
public function isOneOf(array $allowedValues, bool $strict = false): bool
    {
        if (!is_array($this->value)) {
            return in_array($this->value, $allowedValues, $strict);
        }

        foreach ($this->value as $value) {
            if (!in_array($value, $allowedValues, $strict)) {
                return false;
            }
        }

        return true;
    }
647959
public function is(Matrix $mA)
    {
        $r = $mA->rows();
        $c = $mA->columns();

        return (($r > 1 && $c > 1) && ($r != $c));
    }
931522
public static function ucfirst($str, bool $strict=false) {
		ref\mb::ucfirst($str, $strict);
		return $str;
	}
721092
public static function isAlpha(array $set, $strict = true) {
        return static::every($set, function($value) use ($strict) {
            if (!is_string($value)) {
                return false;
            }

            if ($strict) {
                if (is_string($value) && is_numeric($value)) {
                    return false;
                }
            }

            return true;
        });
    }
333144
public function contains($element, bool $strict = true): bool
    {
        return \in_array($element, $this->data, $strict);
    }
745524
public function search($value, bool $strict = false)
    {
        if (!$strict) {
            /** @var Collection $values */
            $values = $this->copy();
            $values->apply(function ($value) {
                if (is_string($value)) {
                    return strtolower($value);
                }

                return $value;
            });

            $value = strtolower($value);
        } else {
            $values = $this;
        }

        return array_search($value, $values->toArray(), $strict);
    }
1135168
public static function equal ($array, $strict = false)
		{
			if (is_array($array))
			{
				if ($strict)
				{
					$data = array_values($array);
					for ($i = 0; $i < count($data); $i++)
					{
						for ($j = $i + 1; $j < count($data); $j++)
							if ($data[ $i ] !== $data[ $j ])
								return false;
					}

					return true;
				}
				else
					return ( count(array_unique($array)) === 1 );
			}
			else
				return null;
		}
314551
public function matchValues(int $values, bool $strict = false)
    {
        while (count($this->values) < $values) {
            array_push($this->values, 0);
        }

        if ($strict) {
            $this->values = array_slice($this->values, 0, $values);
        }
    }
968199
function get( $row, $col )
    {
        $pos = $row * $this->Cols + $col;
        $pos = base_convert( $pos, 10, 36 );
        return isset( $this->Matrix["*$pos"] ) ? $this->Matrix["*$pos"] : 0;
    }