Identifies the coordinate system used by a geospatial path index.
@method
@since 1.0
@memberof queryBuilder#
@param {string} coord - the name of the coordinate system
@returns {queryBuilder.CoordSystem} a coordinate system identifier
765188
function coordSystem() {
  var args = mlutil.asArray.apply(null, arguments);
  switch(args.length) {
  case 0:
    throw new Error('missing identifier for coordinate system');
  case 1:
    return new CoordSystemDef(args[0]);
  default:
    throw new Error('too many arguments for coordinate system identifier: '+args.length);
  }
}
144303
function(node) {
            var nodeList = this.getElementsByTagNameNS(node, this.internalns,
                                                       "coordinates");
            var coords = [];
            if(nodeList.length > 0) {
                var coordString = nodeList[0].firstChild.nodeValue;
                coordString = coordString.replace(this.regExes.removeSpace, "");
                coords = coordString.split(",");
            }

            var point = null;
            if(coords.length > 1) {
                // preserve third dimension
                if(coords.length == 2) {
                    coords[2] = null;
                }
                point = new OpenLayers.Geometry.Point(coords[0], coords[1],
                                                      coords[2]);
            } else {
                throw "Bad coordinate string: " + coordString;
            }
            return point;
        }
105910
function (coords) {
        return _.isObject(coords) && !((this.position === coords.position) && (this.iteration === coords.iteration));
    }
582910
public Point3d getGridPointFrom3dCoordinates(Point3d coord) throws Exception {
        Point3d gridPoint = new Point3d();

        if (coord.x >= minx & coord.x <= maxx) {
            gridPoint.x = (int) Math.round(Math.abs(minx - coord.x) / latticeConstant);
        } else {
            throw new Exception("CDKGridError: Given coordinates are not in grid");
        }
        if (coord.y >= miny & coord.y <= maxy) {
            gridPoint.y = (int) Math.round(Math.abs(miny - coord.y) / latticeConstant);
        } else {
            throw new Exception("CDKGridError: Given coordinates are not in grid");
        }
        if (coord.z >= minz & coord.z <= maxz) {
            gridPoint.z = (int) Math.round(Math.abs(minz - coord.z) / latticeConstant);
        } else {
            throw new Exception("CDKGridError: Given coordinates are not in grid");
        }

        return gridPoint;
    }
181724
function(data) {
        var toLat = coordinate.format(data.to.lat, 'lat');
        var toLon = coordinate.format(data.to.lon, 'lon');

        var parts = ["IIRMB",
            "A",
            data.xte.toFixed(2),
            data.dts,
            data.to.name,
            data.from.name,
            toLat[0],
            toLat[1],
            toLon[0],
            toLon[1],
            data.dtw.toFixed(1),
            data.btw.toFixed(0),
            data.vmgw.toFixed(2),
            'V'
        ];

        return parts.join(',');
    }
439416
function(geometry) {
        var node = this.createElementNS(this.namespaces.gpx, "wpt");
        node.setAttribute("lon", geometry.x);
        node.setAttribute("lat", geometry.y);
        return node;
    }
929365
def coord_to_tilepath(self, lat, lon, zoom):
		'''
		'''
		tile = self.coord_to_tile(lat, lon, zoom)
		return self.tile_to_path(tile)
1138422
private Point asPoint(List coords, CrsId crsId) throws IOException {
        if (coords != null && coords.size() >= 2) {
            ArrayList<List> coordinates = new ArrayList<List>();
            coordinates.add(coords);
            return new Point(getPointSequence(coordinates, crsId));
        } else {
            throw new IOException("A point must has exactly one coordinate (an x, a y and possibly a z value). Additional numbers in the coordinate are permitted but ignored.");
        }
    }
138896
function orderCoords(coords){
  if (config.coordinateOrder){
    return coords;
  }
  if (coords[2]){
    return [coords[1], coords[0], coords[2]];
  }
  return coords.reverse();
}
385136
private Coordinate getOrigin(HumanInputEvent<?> event) {
		// Get the original location for the lastly selected index:
		if (lastSelection != null) {
			try {
				return service.getIndexService().getVertex(service.getGeometry(), lastSelection);
			} catch (GeometryIndexNotFoundException e) {
			}
		}

		// Backup plan: mouse location.
		return getLocation(event, RenderSpace.SCREEN);
	}
1186965
def _map_center(self, coord, val):
        '''  '''

        if self.ppd in [4, 16, 64, 128]:
            res = {'lat': 0, 'long': 360}
            return res[coord] / 2.0
        elif self.ppd in [256]:
            res = {'lat': 90, 'long': 180}
            c = (val // res[coord] + 1) * res[coord]
            return c - res[coord], c
        elif self.ppd in [512]:
            res = {'lat': 45, 'long': 90}
            c = (val // res[coord] + 1) * res[coord]
            return c - res[coord], c
        elif self.ppd in [1024]:
            res = {'lat': 15, 'long': 30}
            c = (val // res[coord] + 1) * res[coord]
            return c - res[coord], c
1043071
public function get($coord) {
        $coord = rad2deg($coord);
        $degrees = (integer) $coord;
        $compass = '';
        if ($this->direction == N::LAT) {
            if ($degrees < 0)
                $compass = 'S';
            elseif ($degrees > 0)
                $compass = 'N';
        }elseif ($this->direction == N::LONG) {
            if ($degrees < 0)
                $compass = 'W';
            elseif ($degrees > 0)
                $compass = 'E';
        }
        $minutes = $coord - $degrees;
        if ($minutes < 0)
            $minutes -= (2 * $minutes);
        if ($degrees < 0)
            $degrees -= (2 * $degrees);

        $minutes = $minutes * 60;
        $seconds = $minutes - (integer) $minutes;
        $minutes = (integer) $minutes;
        $seconds = (float) $seconds * 60;

        $coordinate = sprintf($this->output_format, $degrees, $minutes, $seconds, $compass);
        return $coordinate;
    }
1278191
function(coords) {

			var dist = 0, last;
			for (var i = 0, l = coords.length; i < l; ++i) {
				if(last) {
					dist += geolib.getDistance(coords[i], last);
				}
				last = coords[i];
			}

			return dist;

		}
514054
public function setLat($coord)
    {
        if ($coord === null) {
            $this->lat = $coord;
            return $this;
        }

        if (!is_numeric($coord)) {
            throw new InvalidArgumentException(
                'The "lat" must be a number'
            );
        }

        $this->lat = (float)$coord;

        return $this;
    }
32090
public boolean contains(Coordinate coord) {
		if (coord.getX() < this.getX()) {
			return false;
		}
		if (coord.getY() < this.getY()) {
			return false;
		}
		if (coord.getX() > this.getEndPoint().getX()) {
			return false;
		}
		if (coord.getY() > this.getEndPoint().getY()) {
			return false;
		}
		return true;
	}
1222527
def sort_coords(coord):
    
    import iris
    order = {'T': -2, 'Z': -1, 'X': 1, 'Y': 2}
    axis = iris.util.guess_coord_axis(coord)
    return (order.get(axis, 0), coord and coord.name())
1187861
def lat_id(self, line):
        ''' 
        '''
        if self.grid == 'WAC':
            lat = ((1 + self.LINE_PROJECTION_OFFSET - line) *
                   self.MAP_SCALE * 1e-3 / self.A_AXIS_RADIUS)
            return lat * 180 / np.pi
        else:
            lat = float(self.CENTER_LATITUDE) - \
                (line - float(self.LINE_PROJECTION_OFFSET) - 1)\
                / float(self.MAP_RESOLUTION)
            return lat