Gets a Geometry object that represents all Points whose distance from this
Geometry is less than or equal to <code>$radius</code>.

@param float $radius
@return \Nasumilu\Geometry\Geometry
327308
public function buffer(float $radius): Geometry {
        $event = new ProcessOpEvent($this, ['radius' => $radius]);
        $this->fireOperationEvent(ProcessOpEvent::BUFFER_EVENT, $event);
        return $event->getResults();
    }
1342895
public function getClosest(array $points)
    {
        foreach ($points as $point) {
            $distance = $this->getDistanceWith($point, false);

            if (!isset($minDistance)) {
                $minDistance = $distance;
                $minPoint = $point;
                continue;
            }

            if ($distance < $minDistance) {
                $minDistance = $distance;
                $minPoint = $point;
            }
        }

        return $minPoint;
    }
1051992
public function geoWithinCenterSphere(float $x, float $y, float $radius) : self
    {
        $this->query->geoWithinCenterSphere($x, $y, $radius);

        return $this;
    }
594129
public NumberExpression<Double> distanceSpheroid(Expression<? extends Geometry> geometry) {
        return Expressions.numberOperation(Double.class, SpatialOps.DISTANCE_SPHEROID, mixin, geometry);
    }
759628
public static function rounded($radius, $sides = null, $antialias = null)
	{
		return static::instance()->rounded($radius, $sides, $antialias);
	}
1122773
public function relativePosition(Size $size)
    {
        $x = $this->pivot->x - $size->pivot->x;
        $y = $this->pivot->y - $size->pivot->y;

        return new Point($x, $y);
    }
419261
public function geometryN(int $n) : Geometry
    {
        if (! isset($this->geometries[$n - 1])) {
            throw new NoSuchGeometryException('There is no Geometry in this GeometryCollection at index ' . $n);
        }

        return $this->geometries[$n - 1];
    }
415820
public function getBoundary(): Geometry {
        $event = new AccessorOpEvent($this);
        $this->fireOperationEvent(AccessorOpEvent::BOUNDARY_EVENT, $event);
        return $event->getResults();
    }
664572
private static function computeAngleBetween($from, $to) {
        return self::distanceRadians(deg2rad($from['lat']), deg2rad($from['lng']),
                               deg2rad($to['lat']), deg2rad($to['lng']));
    }
942307
def within_radius(self, x, y, radius):
        
        return QueryExpression({
            self : {'$within' : {
                    '$center' : [[x, y], radius],
                }}
            })
1332310
public Geometry getGeometryN(int n) {
		if (isEmpty()) {
			return null;
		}
		if (n >= 0 && n < points.length) {
			return points[n];
		}
		throw new ArrayIndexOutOfBoundsException(n);
		// return this;
	}
172961
public function slReseplanerare2Geometry($ref) {
        $url = $this->SlReseplanerare2URL.'/geometry.json';

        $params = [
            'key' => $this->slReseplanerare2key,
            'ref' => $ref
        ];

        $request = $this->client->request('GET', $url, [
            'query' => $params
        ]);

        $json = json_decode($request->getBody(), true);
        return $json;
    }
1166728
@Pure
	public IntegerProperty radiusProperty() {
		if (this.radius == null) {
			this.radius = new SimpleIntegerProperty(this, MathFXAttributeNames.RADIUS) {
				@Override
				protected void invalidated() {
					if (get() < 0) {
						set(0);
					}
				}
			};
		}
		return this.radius;
	}
57942
def _geoid_radius(latitude: float) -> float:
    
    lat = deg2rad(latitude)
    return sqrt(1/(cos(lat) ** 2 / Rmax_WGS84 ** 2 + sin(lat) ** 2 / Rmin_WGS84 ** 2))
764659
def within_radius_sphere(self, x, y, radius):
        
        return QueryExpression({
            self : {'$within' : {
                    '$centerSphere' : [[x, y], radius],
                }}
            })
1289502
public function getRadiusSettings(): float
    {
	    return (float)$this->_scopeConfig->getValue(self::RADIUS_CONFIG_PATH, ScopeInterface::SCOPE_STORE);
    }
8725
public function arcsec(int $scale = null): Decimal
    {
        if($this->comp(DecimalConstants::one(), $scale + 2) === -1 && $this->comp(DecimalConstants::negativeOne(), $scale + 2) === 1) {
            throw new \DomainException(
                "The arcsecant of this number is undefined."
            );
        }

        $piOverTwo = DecimalConstants::pi()->div(Decimal::fromInteger(2), $scale + 2)->round($scale);

        if ($this->round($scale)->equals(DecimalConstants::one())) {
            return DecimalConstants::zero();
        }
        if ($this->round($scale)->equals(DecimalConstants::negativeOne())) {
            return DecimalConstants::pi()->round($scale);
        }

        $scale = ($scale === null) ? 32 : $scale;

        return $piOverTwo->sub(
            self::powerSerie(
                DecimalConstants::one()->div($this, $scale + 2),
                DecimalConstants::zero(),
                $scale + 2
            )
        )->round($scale);
    }