Set the geographic coordinates associated with this concept tag.
<p/>
latitude longitude

@param geo latitude longitude

@see #setLatitude(String)
@see #setLongitude(String)
432605
public void setGeo(String geo) {
    if(geo != null) {
      geo = geo.trim();
    }

    if(StringUtils.isBlank(geo)) {
      this.geo = geo;
      setLatitude(Constants.DEFAULT_LATITUDE);
      setLongitude(Constants.DEFAULT_LONGITUDE);
      return;
    }

    String[] split = geo.split("\\s+");
    if(split != null && split.length == 2) {
      this.geo = split[0].trim() + " " + split[1];
      setLatitude(split[0]);
      setLongitude(split[1]);
    }
  }
1238517
public final void setLocation(String loc) {
        if (location == null && loc == null) {
            // no unnecessary property creation if everything is null
            return;
        }
        locationProperty().set(loc);
    }
97912
function setGeomAttrList(params) {
    for(var param in params) {
      if(params.hasOwnProperty(param)) {
        if(typeof params[param] === 'string') {
          geomAttrs.push(params[param]);
        } else if (typeof params[param] === 'object') { // Array of coordinates for Point
          geomAttrs.push(params[param][0]);
          geomAttrs.push(params[param][1]);
        }
      }
    }

    if(geomAttrs.length === 0) { throw new Error('No geometry attributes specified'); }
  }
493690
public static final Geoshape point(final float latitude, final float longitude) {
        Preconditions.checkArgument(isValidCoordinate(latitude,longitude),"Invalid coordinate provided");
        return new Geoshape(new float[][]{ new float[]{latitude}, new float[]{longitude}});
    }
185772
public void setTickLabelLocation(final TickLabelLocation LOCATION) {
        if (null == tickLabelLocation) {
            _tickLabelLocation = LOCATION;
            fireUpdateEvent(REDRAW_EVENT);
        } else {
            tickLabelLocation.set(LOCATION);
        }
    }
1265721
public static void formatLongitude(Appendable out, double longitude, UnitType unit)
    {
        formatLongitude(out, Locale.getDefault(), longitude, unit);
    }
973291
public void add(final double latitude, final double longitude) {
        ensureCapacity(size + 1);
        this.longitude[size] = longitude;
        this.latitude[size] = latitude;
        ++size;
    }
654202
public void setLongitude(final String longitude) {
    if(StringUtils.isBlank(longitude)) {
      return;
    }
    try {
      setLongitude(Double.parseDouble(longitude.trim()));
    }
    catch(Exception e) {
      // nothing is set
    }
  }
460392
void setPosition(Point2D<?, ?> position) {
		this.location = position == null ? null : new SoftReference<>(Point2d.convert(position));
	}
1268632
def set_query_latlon(self):
        '''
        
        '''

        if (isinstance(self.longitude, list) and
                isinstance(self.latitude, list)):
            self.lbox = True
            # west, east, south, north
            self.query.lonlat_box(self.longitude[0], self.longitude[1],
                                  self.latitude[0], self.latitude[1])
        else:
            self.lbox = False
            self.query.lonlat_point(self.longitude, self.latitude)
384512
@Override
    public void setCenter(LatLong latLong) {
        synchronized (this) {
            setCenterInternal(latLong.latitude, latLong.longitude);
        }
        notifyObservers();
    }
475314
public void setLocation(double location)
    {
        if(Double.isNaN(location) || Double.isInfinite(location))
            throw new ArithmeticException("location must be a real number");
        this.location = location;
    }
452939
public BoundingBox extendCoordinates(double latitude, double longitude) {
        if (contains(latitude, longitude)) {
            return this;
        }

        double minLat = Math.max(MercatorProjection.LATITUDE_MIN, Math.min(this.minLatitude, latitude));
        double minLon = Math.max(-180, Math.min(this.minLongitude, longitude));
        double maxLat = Math.min(MercatorProjection.LATITUDE_MAX, Math.max(this.maxLatitude, latitude));
        double maxLon = Math.min(180, Math.max(this.maxLongitude, longitude));

        return new BoundingBox(minLat, minLon, maxLat, maxLon);
    }
474202
protected void setDefaultInfoWindowLocation(){
        int s = mOriginalPoints.size();
        if (s > 0)
            mInfoWindowLocation = mOriginalPoints.get(s/2);
        else
            mInfoWindowLocation = new GeoPoint(0.0, 0.0);
    }
397752
public void setLocations(java.util.Collection<Location> locations) {
        if (locations == null) {
            this.locations = null;
            return;
        }

        this.locations = new com.amazonaws.internal.SdkInternalList<Location>(locations);
    }
1352051
@JsonIgnore
    public GeoLocationRequest getGeoLocation() {
        val request = new GeoLocationRequest();
        request.setAccuracy(get("geoAccuracy"));
        request.setTimestamp(get("geoTimestamp"));
        request.setLongitude(get("geoLongitude"));
        request.setLatitude(get("geoLatitude"));
        return request;
    }
28286
public function searchByLocation($lat, $long){
        if($lat != null && $long != null){
            $this->addParam("lat", $lat);
            $this->addParam("lng", $long);
        }
    }