@param $x
@param $y

@return string
190880
public function getPixel($x, $y)
    {
        $result = '';
        $rgb = $this->getRGB($x, $y);

        foreach ($rgb as $value) {
            $result .= substr(decbin($value), -1, 1);
        }

        return $result;
    }
648484
public function getXsltLocation(string $version): string
    {
        if (array_key_exists($version, $this->xsltLocations)) {
            return $this->xsltLocations[$version];
        }
        return '';
    }
1296228
public function getValueOfXForY($yValue) {
		return pow((($yValue + $this->_Yoffset) / $this->getIntersect()),(1 / $this->getSlope()));
	}
610353
public static function POWER($x = 0, $y = 2)
    {
        $x    = PHPExcel_Calculation_Functions::flattenSingleValue($x);
        $y    = PHPExcel_Calculation_Functions::flattenSingleValue($y);

        // Validate parameters
        if ($x == 0.0 && $y == 0.0) {
            return PHPExcel_Calculation_Functions::NaN();
        } elseif ($x == 0.0 && $y < 0.0) {
            return PHPExcel_Calculation_Functions::DIV0();
        }

        // Return
        $result = pow($x, $y);
        return (!is_nan($result) && !is_infinite($result)) ? $result : PHPExcel_Calculation_Functions::NaN();
    }
263046
public function lineTo($x,$y)
	{
		
		$imageResource = $this->_imageResource;
		
		$_x = (int)$x;
		$_y = (int)$y;
		if($this->_beganFill){
			$this->_polygonPath[] = $_x;
			$this->_polygonPath[] = $_y;
		}else{
			imageline(
				$imageResource,
				$this->_oldX,
				$this->_oldY,
				$_x,
				$_y,
				$this->_lineDmColor->imagecolorallocatealpha($imageResource)
			);
		}
		$this->_oldX = $_x;
		$this->_oldY = $_y;
		return $this;
	}
375802
public function apply(float $x, float $y) : array
    {
        return [
            $x * $this->values[0] + $y * $this->values[2] + $this->values[4],
            $x * $this->values[2] + $x * $this->values[3] + $this->values[5],
        ];
    }
638954
public static String pointToString (double x, double y) {
        return MathUtil.toString(x) + MathUtil.toString(y);
    }
838605
public function isValidBound($x, $y) {
        list($r, $g, $b) = $this->shapeImage->getRGB($x, $y);
        return $r < 240 || $g < 240 || $b < 240;
    }
786654
protected function getThumbFileName($x, $y, $width, $height)
    {
        return Filesystem::removeExtension($this->file)                 .
               $this->addPrefixToThumbFileName($x, $y, $width, $height) . 
               Filesystem::getExtension($this->file, true);
    }
1245241
public static function div($x, $y)
    {
        $X = static::parse($x);
        $Y = static::parse($y);

        if ($Y->p == 0) throw new DivisionByZeroException();

        $resp = $X->p * $Y->q;
        $resq = $X->q * $Y->p;

        return new Rational($resp, $resq);
    }
876035
public function is_out_of_bounds($x, $y)
    {
        return (
            $x < 0 ||
            $y < 0 ||
            $x > ($this->width - 1) ||
            $y > ($this->height - 1)
        );
    }
946124
public function multiplyPoint($x, $y) 
    {
        return new Point(
            $this->a * $x + $this->c * $y + $this->e,
            $this->b * $x + $this->d * $y + $this->f
        );
    }
1112816
public static function getInstance($x, $y)
    {
        if($x === 0 && $y === 0)
        {
            if(self::$zero === null)
            {
                self::$zero = new self(0, 0);
            }
            
            return self::$zero;
        }

        return new self($x, $y);
    }
7397
public function rescale($x, $y) {
		if(is_object($x) && $x instanceof Dimensions) {
			$y = $x->height;
			$x = $x->width;
		}
		$newImage = imagecreatetruecolor($this->width * $x, $this->height * $y);
		$x = imagesx($newImage);
		$y = imagesy($newImage);
		imagecopyresampled($newImage, $this->image, 0, 0, 0, 0, $x, $y, $this->width, $this->height);
		$this->image = $newImage;
		$this->getSize();
		return $this;
	}
1344318
public function Compare( $x, $y )
	{
		$nav1 = $x instanceof XPathNavigator
			? $x
			: null;
		$nav2 = $y instanceof XPathNavigator
			? $y
			: null;
		/**
		 * @var XPathNavigator $nav1
		 * @var XPathNavigator $nav2
		 */
		if ( ! is_null( $nav1 ) && ! is_null( $nav2 ) )
		{
			switch ( $nav1->ComparePosition( $nav2, $this->useLineNo ) )
			{
				case XmlNodeOrder::Before:
					return -1;

				case XmlNodeOrder::After:
					return 1;

				case XmlNodeOrder::Same:
					return 0;

				default:

					// It appears to be correct to return -1 every time because $nav1
					// will always appear before $nav2 because that's the order in which
					// they are presented in the XPath query.
					return -1;

					/**
					 * Below is an implementation of the C# version which appears to be wrong
					 * because the value of spl_object_hash (or getHashCode in C# is random
					 * so the result here is likely to be random.
					 * @var XPathNavigator $root1
					 * @var XPathNavigator $root2
					 */
					$root1 = $nav1->CloneInstance();
					$root1->MoveToRoot();
					$root2 = $nav2->CloneInstance();
					$root2->MoveToRoot();

					$hashCode1 = spl_object_hash( $root1 );
					$hashCode2 = spl_object_hash( $root2 );

					if ( $hashCode1 < $hashCode2 )
					{
						return -1;
					}
					else if ( $hashCode1 > $hashCode2 )
					{
						return 1;
					}
					else
					{
						throw new InvalidOperationException();
					}
			}
		}
		else
			throw XPath2Exception::withErrorCodeAndParams( "XPTY0004", Resources::XPTY0004,
				array(
					"xs:anyAtomicType",
					"node()* in function op:union,op:intersect and op:except"
				)
			);
	}
963857
public function getValue( $x )
	{
		$y = 0;
		for( $i = $this->getRank() - 1; $i >= 0; $i-- )
			$y	= $this->coefficients[$i] + $y * $x;
		return $y;
	}
78973
public function between($x, $y)
    {
        $value = $this->type('numeric')->value();

        if ($value === null) {
            return $this;
        }

        $alpha = min($x, $y);
        $omega = max($x, $y);

        if ($value < $alpha || $value > $omega) {
            throw new \Hail\Image\Exception\InvalidArgumentException(
                sprintf('Argument %d must be between %s and %s.', $this->key, $x, $y)
            );
        }

        return $this;
    }