Returns true if greater than or equal to
@param  CryptoQuantity|int $other quantity to compare to
@return boolean
485767
public function gte($other)
    {
        if (!($other instanceof self)) {
            $other = new BigInt($other);
        }
        return ($this->compare($other) >= 0);
    }
1247828
public function equals(LatLngBounds $other)
    {
        if (!$this->getNorthEast()->equals($other->getNorthEast())) {
            return false;
        }

        return $this->getSouthWest()->equals($other->getSouthWest());
    }
812569
public function equals(CurrencyPair $other)
    {
        return
            $this->baseCurrency->equals($other->baseCurrency)
            && $this->counterCurrency->equals($other->counterCurrency)
            && $this->conversionRatio === $other->conversionRatio
        ;
    }
677980
public function Compare($other)
	{
	    switch ( $other->GetValueCode() )
	    {
	        case SByteProxyFactory::Code:
	            return 0;

	        case ByteProxyFactory::Code:
	        case UShortProxyFactory::Code:
	        case UIntProxyFactory::Code:
	        case ULongProxyFactory::Code:
	        case ShortProxyFactory::Code:
	        case IntProxyFactory::Code:
	        case LongProxyFactory::Code:
	        case IntegerProxyFactory::Code:
	        case DecimalProxyFactory::Code:
	        case FloatProxyFactory::Code:
	        case DoubleProxyFactory::Code:
	            return -1;

	        default:
	            return -2;
	    }
	}
1251089
final public function equals($other)
    {
        if ($other instanceof $this) {
            if ($other === $this) {
                return true;
            }
            $other = $other->toArray();
        } elseif (!is_array($other)) {
            return false;
        }
        
        $me = $this->toArray();
    
        if (count($me) !== count($other)) {
            return false;
        }
    
        foreach ($me as $key => $value) {
            if (!array_key_exists($key, $other) || $value !== $other[$key]) {
                return false;
            }
        }
        
        return true;
    }
1371041
private function hasSameColumnLengths(self $other) : bool
    {
        $filter = static function (?int $length) : bool {
            return $length !== null;
        };

        return array_filter($this->options['lengths'] ?? [], $filter)
            === array_filter($other->options['lengths'] ?? [], $filter);
    }
117657
public static function greaterThanOrEqual(Expr $left, Expr $right) : BinOp
    {
        return new BinOp($left, BinOp::GREATER_THAN_OR_EQUAL, $right);
    }
466823
public function equals($other)
    {
        $value = $other instanceof Value ? $other->getValue() : $other;

        return $this->getValue() === $value;
    }
612567
public function equal($other)
    {
        $this->doCheck(function ($value) use ($other) {
            $this->throwExceptionIfFalse(
                $value == $other,
                'Value "%s" is not equal to "%s"', $value, $other
            );
        });

        return $this;
    }
395958
public function compareTo($other)
    {
        if ($other === null) {
            return false;
        }
        if (!($other instanceof VariableNode)) {
            return false;
        }

        return $this->getName() == $other->getName();
    }
799127
public function dist($other) {
        return sqrt(pow($this->x - $other->x, 2) + pow($this->y - $other->y, 2));
    }
175654
public function lessThanOrEqual($other)
    {
        $this->doCheck(function ($value) use ($other) {
            $this->throwExceptionIfFalse(
                $value <= $other,
                'Failed assertion that %s is less than %s', $value, $other
            );
        });

        return $this;
    }
339192
protected function matches($other): bool
    {
        if (is_array($other)) {
            $success = null;
            foreach ($other as $item) {
                $currentSuccess = $this->matchesSection($item);
                $success = ($success === null ? $currentSuccess : $success || $currentSuccess);
            }
            return !empty($success);
        } else {
            return $this->matchesSection($other);
        }
    }
365657
public function equals($other) {
		if ($other instanceof UrlQuery) {
			return ($this->isEmpty() && $other->isEmpty()) || ($this->__toString() === $other->__toString() );
		}
		if (is_null($other)) {
			return $this->isEmpty();
		}
		return false;
	}
895988
public boolean matches(T other) {
    if (matchAny) {
      return true;
    } else if (other == null) {
      return negation ? value != null : value == null;
    } else {
      if (value instanceof byte[]) {
        boolean equal = Arrays.equals((byte[]) value, (byte[]) other);
        return negation ? !equal : equal;
      }
      return negation ? !Objects.equals(value, other) : Objects.equals(value, other);
    }
572492
public function equals(AttributeTypeAndValue $other): bool
    {
        // check that attribute types match
        if ($this->oid() !== $other->oid()) {
            return false;
        }
        $matcher = $this->_value->equalityMatchingRule();
        $result = $matcher->compare($this->_value->stringValue(),
            $other->_value->stringValue());
        // match
        if ($result) {
            return true;
        }
        // no match or Undefined
        return false;
    }
859255
public function within(Geometry $other): bool {
        $event = new SpatialRelationshipOpEvent($this, ['other' => $other]);
        $this->fireOperationEvent(SpatialRelationshipOpEvent::WITHIN_EVENT, $event);
        return $event->getResults();
    }