# doc-cache created by Octave 5.2.0
# name: cache
# type: cell
# rows: 3
# columns: 87
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
aer2ecef


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1586
 -- Function File: X, Y, Z = aer2ecef (AZ,EL, SLANTRANGE, LAT0, LON0,
          ALT0)
 -- Function File: X, Y, Z = aer2ecef (AZ,EL, SLANTRANGE, LAT0, LON0,
          ALT0, SPHEROID)
 -- Function File: X, Y, Z = aer2ecef (AZ,EL, SLANTRANGE, LAT0, LON0,
          ALT0, SPHEROID, ANGLEUNIT)
     Convert azimuth, elevation, range to target from observer to ECEF
     coordinates.

     Inputs:

     AZ, EL, SLANTRANGE: look angles and distance to point under
     consideration (degrees, degrees, meters).  Vectors values are
     accepted if they have equal dimensions.

     LAT0, LON0, ALT0: ellipsoid geodetic coordinates of
     observer/reference (degrees, degrees, meters).  This must be just
     one position.

     SPHEROID: referenceEllipsoid parameter struct; default is wgs84.  A
     string value describing the spheroid is also accepted.

     ANGLEUNIT: string for angular units ('degrees' or 'radians',
     case-insensitive, just the first charachter will do).  Default is
     'degrees'.

     Outputs:

     X, Y, Z: Earth Centered Earth Fixed (ECEF) coordinates.

     Example
          [x, y, z] = aer2ecef (33, 70, 1e3, 42, -82, 200)
          x =    6.6057e+05
          y =   -4.7002e+06
          z =    4.2450e+06

     With radians
          [x, y, z] = aer2ecef (pi/6, pi/3, 1e3, pi/4, -pi/2, 200, "wgs84", "radians")
          x =  250.00
          y =   -4.5180e+06
          z =    4.4884e+06

     Note: aer2ecef is a mere wrapper for functions geodetic2ecef,
     aer2enu and enu2uvw.

     See also: geodetic2ecef, aer2enu, enu2uvw, referenceEllipsoid.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Convert azimuth, elevation, range to target from observer to ECEF
coordinates.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
aer2enu


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 988
 -- Function File: E, N, U = aer2enu (AZ, EL, SLANTRANGE)
 -- Function File: E, N, U = aer2enu (AZ, EL, SLANTRANGE, ANGLEUNIT)
     Converts spherical azimuth, elevation and range coordinates into
     Cartesian ENU coordinates.

     Inputs:
        * AZ, EL, SLANTRANGE: look angles and distance to point
          (degrees, degrees, meters).

        * AZ: azimuth angle clockwise from local north.

        * EL: elevation angle above local horizon.

        * SLANTRANGE: distance from origin in local spherical system.

        * (Optional) angleUnit: string for angular units (radians or
          degrees).  Default is 'd': degrees

     Outputs:

          E, N, U: East, North, Up Cartesian coordinates (meters).

     Example:
          [e, n, u] = aer2enu (33, 70, 1e3)
          e =  186.28
          n =  286.84
          u =  939.69

     In radians
          [e, n, u] = aer2enu (pi/4, pi/3,1e3, "radians")
          e =  353.55
          n =  353.55
          u =  866.03


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Converts spherical azimuth, elevation and range coordinates into
Cartesian EN...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
aer2geodetic


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1621
 -- Function File: LAT1, LON1, ALT1 = aer2geodetic (AZ,EL, SLANTRANGE,
          LAT0, LON0, ALT0)
 -- Function File: LAT1, LON1, ALT1 = aer2geodetic (AZ,EL, SLANTRANGE,
          LAT0, LON0, ALT0, SPHEROID)
 -- Function File: LAT1, LON1, ALT1 = aer2geodetic (AZ,EL, SLANTRANGE,
          LAT0, LON0, ALT0, SPHEROID, ANGLEUNIT)
     Convert azimuth, elevation and range of target from observer to
     geodetic coordinates.

     Inputs:

     AZ, EL, SLANTRANGE: look angles and distance to point under
     consideration (degrees, degrees, meters).  Vectors values are
     accepted if they have equal dimensions.

     LAT0, LON0, ALT0: ellipsoid geodetic coordinates of
     observer/reference (degrees, degrees, meters).  This must be just
     one position.

     SPHEROID: referenceEllipsoid parameter struct or name (string
     value) of referenceEllipsoid; default is 'wgs84'.

     ANGLEUNIT: string for angular units ('degrees' or 'radians',
     case-insensitive, just first character will suffice).  Default is
     'degrees'.

     Outputs:

     LAT1, LON1, ALT1: geodetic coordinates of points (degrees, degrees,
     meters).

     Example
          [x, y, z] = aer2geodetic (33, 70, 1e3, 42, -82, 200)
          x =  42.000
          y = -82.000
          z = 1139.7

     With radians
          [x, y, z] = aer2geodetic (pi/6, pi/3, 1e3, pi/4, -pi/2, 200, "wgs84", "radians")
          x =  0.78547
          y = -1.5707
          z =  1066.0

     Note: aer2geodetic is a mere wrapper for functions aer2ecef
     followed by ecef2geodetic.

     See also: aer2ecef, ecef2geodetic, referenceEllipsoid.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Convert azimuth, elevation and range of target from observer to geodetic
coor...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
aer2ned


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 818
 -- Function File: N, E, D = aer2ned (AZ, EL, SLANTRANGE)
 -- Function File: N, E, D = aer2ned (AZ, EL, SLANTRANGE, ANGLEUNIT)
     Convert azimuth, elevation and range to NED coordinates.

     Inputs:

     AZ, EL, SLANTRANGE: look angles and distance to point under
     consideration (degrees, degrees, meters).

     ANGLEUNIT: string for angular units ('degrees' or 'radians',
     case-insensitive, lust the first character will do).  Default is
     'degrees'.

     Outputs:

     N, E, D: North, East, Down coordinates of points.  (meters)

     Examples:
          [n, e, d] = aer2ned (33, 70, 1e3)
          n =  286.84
          e =  186.28
          d = -939.69

     With radians
          [n, e, d] = aer2ned (pi/4, pi/3,1e3, "radians")
          n =  353.55
          e =  353.55
          d = -866.03


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Convert azimuth, elevation and range to NED coordinates.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
antipode


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 412
 -- LAT_O, LON_O = antipode (LAT_I, LON_I)
 -- LAT_O, LON_O = antipode (LAT_I, LON_I, UNIT)
     Compute antipode (opposite point on globe).

     LAT_I and LON_I (numeric values) are input latitude and longitude,
     optionally vectors.

     Optional character argument UNIT (case-insensitive) can be one of
     'Degrees' or 'Radians' and can be used to specify the input units.
     Just 'd' or 'r' will do.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Compute antipode (opposite point on globe).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
axes2ecc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 998
 -- Function File: ECC = axes2ecc (SEMIMAJOR, SEMIMINOR)
 -- Function File: ECC = axes2ecc (AXES)
     Calculates the eccentricity from semimajor and semiminor axes.

     SEMIMAJOR and SEMIMINOR are scalars or vectors of semimajor and
     semiminor axes, resp.  Alternatively, they can also be supplied as
     coordinate (row) vectors or a N2 matrix with each row consisting of
     a (semimajor, semiminor) pair.

     Output arg ECC is a scalar or column vector of eccentricities.

     Examples:

     Scalar input:
             format long
             axes2ecc (6378137, 6356752.314245)
             => 0.0818191908429654

     Row vector (semimajor, semiminor):
           axes2ecc ([6378137, 6356752.314245])
           =>  0.0818191908429654

     Multivectors:
             axes2ecc ([     71492, 66854; ...
                           6378137, 6356752.314245])
             ans =
                0.3543163789650412
                0.0818191908429654

     See also: (ecc2flat,flat2ecc).


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Calculates the eccentricity from semimajor and semiminor axes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
azimuth


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 782
 -- Function File: AZ = azimuth(LAT1,LON1,LAT2,LON2)
 -- Function File: AZ = azimuth(LAT1,LON1,LAT2,LON2,UNITS)
 -- Function File: AZ = azimuth(PT1, PT2)
 -- Function File: AZ = azimuth(PT1, PT2,UNITS)

     Calculates the great circle azimuth from a point 1 to a point 2.
     The latitude and longitude of these two points can either be given
     independently or as columns of the matrices PT1 and PT2 in the form
     [latitude longitude].

     The units for the input coordinates and output angles can be
     "degrees" (the default) or "radians".

          >> azimuth([10,10], [10,40])
          ans = 87.336
          >> azimuth([0,10], [0,40])
          ans = 90
          >> azimuth(pi/4,0,pi/4,-pi/2,"radians")
          ans = 5.3279

     See also: elevation,distance.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Calculates the great circle azimuth from a point 1 to a point 2.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
closePolygonParts


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1468
 -- Function File: [XO, YO, ... ] = closePolygonParts (XI, YI, ...)
 -- Function File: [XO, YO, ... ] = closePolygonParts (XI, YI, ...,
          ANGUNIT)
     Ensure that (each part of a multipart) polygon is a closed ring.

     For each (part of a) polygon, closePolygonParts checks if the
     vertices of that part form a closed ring, i.e., if first and last
     vertices coincide.  If the polygon or polygon parts (the latter
     separated separated by NaNs) do not form a closed ring, the first
     vertex coordinates of each open part are appended after its last
     vertex.  Input polygons need not be multipart.

     XI and YI (plus optionally, ZI and/or MI) are input vectors of X
     and Y or Longitude and Latitude (plus optionally Z or Height,
     and/or M) vectors of vertex coordinates (and measure values) of an
     input polygon.  If a vector of measures is given as argument, it
     should always be the last vector.

     Optional last argument ANGUNIT can be one of 'Degrees' or 'Radians'
     (case-insensitive, only the first 3 characters need to match).  If
     this argument is given and if the first two input vectors are
     longitude/latitude vectors rather than X/Y vectors, it indicates
     that the longitudes of those first and last vectors need only
     coincide modulo 360 degrees or 2*pi radians.

     The number of output vectors XO, YO, ...  matches the number of
     input vectors.

     See also: isShapeMultiPart.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Ensure that (each part of a multipart) polygon is a closed ring.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
deg2km


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 668
 -- Function File: KM = deg2km (DEG)
 -- Function File: KM = deg2km (DEG, RADIUS)
 -- Function File: KM = deg2km (DEG, SPHERE)
     Convert angle to distance.

     Calculates the distances KM in a sphere with RADIUS (also in
     kilometers) for the angles DEG.  If unspecified, radius defaults to
     6371, the mean radius of Earth.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object mean
     radius.

     See also: deg2km, deg2sm, km2rad, km2deg, nm2deg, nm2rad, rad2km,
     rad2nm, rad2sm, sm2deg, sm2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Convert angle to distance.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
deg2nm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 745
 -- Function File: NM = deg2nm (DEG)
 -- Function File: NM = deg2nm (DEG, RADIUS)
 -- Function File: NM = deg2nm (DEG, SPHERE)
     Converts angle in degrees to distance in nautical miles by
     multiplying angle with radius.

     Calculates the distances NM in a sphere with RADIUS (also in
     nautical miles) for the angles DEG.  If unspecified, radius
     defaults to 3440 nm, the mean radius of Earth.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object's mean
     radius.

     See also: deg2km, deg2sm, km2rad, km2deg, nm2deg, nm2rad, rad2km,
     rad2nm, rad2sm, sm2deg, sm2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Converts angle in degrees to distance in nautical miles by multiplying
angle ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
deg2sm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 742
 -- Function File: SM = deg2sm (DEG)
 -- Function File: SM = deg2sm (DEG, RADIUS)
 -- Function File: SM = deg2sm (DEG, SPHERE)
     Converts angle n degrees to distance in statute miles by
     multiplying angle with radius.

     Calculates the distances SM in a sphere with RADIUS (also in
     statute miles) for the angles DEG.  If unspecified, radius defaults
     to 3958 sm, the mean radius of Earth.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object's mean
     radius.

     See also: deg2km, deg2nm, km2rad, km2deg, nm2deg, nm2rad, rad2km,
     rad2nm, rad2sm, sm2deg, sm2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Converts angle n degrees to distance in statute miles by multiplying
angle wi...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
degrees2dm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1158
 -- Function File: degrees2dm (DEG)
     Convert decimal degrees to its degrees and minutes components.

     Separates the fractional part of an angle in decimal degrees and
     converts it into minutes.  Each row of the output corresponds to
     one angle, the first column to the degree component (an integer),
     and the second to the minutes (which may have a fractional part).

          degrees2dm (10 + 20/60)
          =>  [ 10   20 ]

          degrees2dm (10 + pi)
          =>  [ 10   8.4956 ]

     The sign of the first non-zero component indicates the sign of the
     angle, i.e., if the degree component is zero, the sign of the
     minutes indicates the sign of the angle, but if the degree
     component is non-zero, the minute component will be positive
     independently of the sign of the angle.  For example:

          angles = [  10.5
                     -10.5
                      -0.5
                       0.5 ];
          degrees2dm (angless)
            =>
                   10   30
                  -10   30
                   -0  -30
                    0   30

     See also: degrees2dms, dm2degrees, dms2degrees.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Convert decimal degrees to its degrees and minutes components.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
degrees2dms


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1275
 -- Function File: degrees2dms (DEG)
     Convert decimal degrees to its degrees, minutes, and seconds
     components.

     Separates the fractional part of an angle in decimal degrees and
     converts it into minutes and seconds.  Each row of the output
     corresponds to one angle the first and second column to the degree
     and minute component (both integers), and the third to the seconds
     (which may have a fractional part).

          degrees2dms (10 + 20/60 + 20/3600)
          =>  [ 10   20   20 ]

          degrees2dms (10 + 20/60 + pi)
          =>  [ 10   28   29.734 ]

     The sign of the first non-zero component indicates the sign of the
     angle, i.e., if the degree and minute components are zero, the sign
     of the seconds indicates the sign of the angle, but if the degree
     component is non-zero, both the minute and second components will
     be positive independently of the sign of the angle.

          angles = [  10.5
                     -10.5
                      -0.5
                       0.5 ];
          degrees2dms (angles)
            =>
                   10   30   0
                  -10   30   0
                   -0  -30   0
                    0   30   0

     See also: degrees2dm, dm2degrees, dms2degrees.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Convert decimal degrees to its degrees, minutes, and seconds components.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
degtorad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 177
 -- Function File: deg2rad (ANGLIN)
 -- Function File: degtorad (ANGLIN)
     Converts angles input in degrees to the equivalent in radians.

     See also: rad2deg, unitsratio.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Converts angles input in degrees to the equivalent in radians.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
distance


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 809
 -- Function File: [DIST, AZ] = distance(PT1, PT2)
 -- Function File: [DIST, AZ] = distance(PT1, PT2,UNITS)
 -- Function File: [DIST, AZ] = distance(LAT1, LON1, LAT2, LON2)
 -- Function File: [DIST, AZ] = distance(LAT1, LON1, LAT2, LON2, UNITS)

     Calculates the great circle distance DIST between PT1 and PT2 and
     optionally the azimuth AZ.

     PT1 and PT2 are two-column matrices of the form [latitude
     longitude].  The coordinates can also be given by the parameters
     LAT1, LON1, LAT2 and LON2.  Units can be either 'degrees' (the
     default) or 'radians'.

          >> distance([37,-76], [37,-9])
          ans = 52.309
          >> distance([37,-76], [67,-76])
          ans = 30.000
          >> distance(0,0, 0,pi,'radians')
          ans = 3.1416

     See also: azimuth,elevation.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Calculates the great circle distance DIST between PT1 and PT2 and
optionally ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
dm2degrees


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 559
 -- Function File: dm2degrees (DM)
     Convert degrees, minutes, and seconds components into decimal
     degrees.

     DM must be a 2 column matrix with one row per angle, each column
     correspoding to its degrees (an integer), and minutes (a less than
     60 value, possibly fractional) components.

     The sign of the angle must be defined on its first non-zero
     component only, i.e., if an angle is negative, the minutes
     component must be positive unless its degrees component is zero.

     See also: degrees2dm, degree2dms, dms2degrees.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Convert degrees, minutes, and seconds components into decimal degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
dms2degrees


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 684
 -- Function File: dms2degrees (DMS)
     Convert degrees, and minutes components into decimal degrees.

     DMS must be a 3 column matrix with one row per angle, and each
     column correspoding to its degrees (an integer), minutes (a less
     than 60 integer, and seconds (a less than 60 value, possibly
     fractional) components.

     The sign of the angle must be defined on its first non-zero
     component only, i.e., if an angle is negative, the seconds
     component must be positive unless both minutes and degrees are
     zero, and the minutes component must be positive unless the degrees
     component is zero.

     See also: degrees2dm, degree2dms, dm2degrees.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Convert degrees, and minutes components into decimal degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
dxfdraw


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1242
 -- [H] = dxfdraw (DXF)
 -- [H] = dxfdraw (DXF, CLR)
 -- [H] = dxfdraw (..., NAME, VALUE, ...)
     Draw a map of a DXF file based on a DXF cell array or DXF drawing
     struct.

     Input argument DXF is the name of a DXF cell array (see dxfread.m),
     or the name of a DXF file, or a DXF drawing struct made by
     dxfparse.

     CLR is the color used to draw the DXF contents.  All lines and arcs
     are drawn in the same color; similar for all filled surfaces.  For
     points, lines and polylines this can be a 3x1 RGB vector or a color
     code.  For polygons it can be a 2x1 vector of color codes or a 2x3
     double array of RGB entries.  The default is [0.7 0.7 0.7; 0.8 0.9
     0.99].

     In addition several graphics properties can be specified, e.g.,
     linestyle and linewidth.  No checks are performed whether these are
     valid for the entities present in the DXF cell array or file.

     Currently the following entities are supported: POINT, LINE,
     POLYLINE, LWPOLYLINE, CIRCLE, ARC and 3DFACE. For drawing CIRCLE
     and ARC entities functions from the geometry packge are required.

     Optional output argument H is the graphics handle of the resulting
     map.

     See also: dxfread, dxfparse.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Draw a map of a DXF file based on a DXF cell array or DXF drawing
struct.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
dxfparse


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1038
 -- DXFO = dxfparse (DXFI)
 -- DXFO = dxfparse (DXFI, OUTSTYLE)
     Parse a DXF struct (read by dxfread) into a DXF drawing struct or
     into a mapstruct.

     Input arg DXFI can be a DXF cell array produced by dxfread, or a
     DXF file name (dxfparse will invoke dfread to read it).

     Optional numeric input argument OUTSTYLE can be used to select a
     desired output format:

        * 0 (default) Return an output struct optimized for fast drawing
          with dxfdraw.m

        * 1 Return an output struct containing 2D (Matlab-compatible)
          mapstructs like those returned by shaperead.m.  The output
          struct contains a "dxfpl" Polyline mapstruct for LINEs and
          open POLYLINEs and LWPOLYLINE entities; a "dxfpt" Point
          mapstruct for POINT entities; and a "dxfpg" Polygon mapstucts
          for closed POLYLINE and LWPOLYLINE entities.

        * 2 If the DXF file is 3D, return a 3D mapstruct as returned by
          shaperead.m with Z coordinates.

     See also: dxfread, dxfdraw.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Parse a DXF struct (read by dxfread) into a DXF drawing struct or into a
maps...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
dxfread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 576
 -- DXF = dxfread (FNAME)
     Read a DXF file (text file) into a Nx3 cell array.

     FNAME is the file name or full path name of a text format (not
     binary) DXF file, with or without "dxf" extension.

     Output variable DXF is a cell array with DXF codes in column 1, the
     corresponding DXF text info (or empty string) in column 2, and
     corresponding numeric values (or NaN) in column 3.  Use dxfparse
     for converting the output into a DXF drawing struct or separate
     mapstructs for each ENTITY type in the DXF file.

     See also: dxfparse, dxfdraw.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Read a DXF file (text file) into a Nx3 cell array.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
earthRadius


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 291
 -- Function File: earthRadius (UNIT)
     Converts the Earth's radius into other units.

     Input argument UNITS can be one of the units of validateLengthUnit.
     The default is meters.

          earthRadius ('km')
          => ans = 6371

     See also: validateLengthUnit,unitsratio.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Converts the Earth's radius into other units.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ecc2flat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 441
 -- Function File: FLAT = flat2ecc (ECC)
     Return flattening given an eccentricity

     Exmples:

     Scalar input:
           e_earth = .081819221456;
           f_earth = ecc2flat (e_earth)
           => f_earth = 0.0033528

     Vector input:
           ec = 0 : .01 : .05;
           f = ecc2flat (ec)
           => f =
                 0.0000000   0.0000500   0.0002000   0.0004501   0.0008003   0.0012508

     See also: flat2ecc.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Return flattening given an eccentricity



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ecc2n


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 413
 -- Function File: N = ecc2n (ECC)
     This returns the third flattening given an eccentricity.

     Examples:

     Scalar input:
           e_earth = 0.081819221456;
           n_earth = ecc2n (e_earth)
           => n_earth = 0.0016792

     Vector input:
           e_vec = [ 0.081819221456  0.3543164 ]
           n = ecc2n (e_vec)
           => n =
          	 0.0016792    0.033525

     See also: n2ecc.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
This returns the third flattening given an eccentricity.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
ecef2geodetic


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1292
 -- Function File: LAT, LON, ALT = ecef2geodetic (SPHEROID, X, Y, Z)
 -- Function File: LAT, LON, ALT = ecef2geodetic (X, Y, Z)
 -- Function File: LAT, LON, ALT = ecef2geodetic (..., ANGLEUNIT)
     Converts from ecef coordinate frame to geodetic coordinate frame.

     Optional argument SPHEROID can be an ellipsoid vector or spheroid
     (see help for referenceEllipsoid.m).  If omitted or if an empty
     string is supplied the WGS84 ellipsoid is taken.

     X, Y and Z are Earth-Centered Earth Fixed coordinates in meters.
     They can be scalars, vectors or matrices but they must all have the
     same size and dimensions.

     The default LAT and LON output is in degrees; specify "radians" for
     optional last argument ANGLEUNIT to return coordinates in radians.
     ALT is always in meters.  The size and dimension(s) of LAT, LON and
     ALT are the same as X, Y and Z.

          Aalborg GPS Centre
          X =     3426949.39675307
          Y =     601195.852419885
          Z =     5327723.99358255
          lat = 57.02929569;
          lon = 9.950248114;
          h = 56.95; # meters

          >> [lat, lon, alt] = geodetic2ecef ("", X, Y, Z)
          lat = 57.029
          lon = 9.9502
          alt = 56.95

     See also: geodetic2ecef, referenceEllipsoid.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Converts from ecef coordinate frame to geodetic coordinate frame.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
enu2aer


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 925
 -- Function File: AZ, EL, SLANTRANGE = enu2aer (EAST, N, UP)
 -- Function File: AZ, EL, SLANTRANGE = enu2aer (..., ANGLEUNIT)
     Converts ENU coordinates to azimuth, elevation, slantrange

     Inputs:
        * EAST, N, UP: East, North, Up coordinates of test points
          (meters)

        * (Optional) angleUnit: string for angular units ('radians' or
          'degrees', case-insensitive, only first character is
          significant).  Default is 'd': degrees

     Outputs:
        * AZ, EL, SLANTRANGE: look angles and distance to point under
          test (degrees, degrees, meters)

     Example:
          [az, el, slantrange] = enu2aer (186.28, 286.84, 939.69)
          az =  33.001
          el =  70.000
          slantrange = 1000.00

     With radians
          [az, el, slantrange] = enu2aer (353.55, 353.55, 866.03,"r")
          az =  0.78540
          el =  1.0472
          slantrange =  1000.0


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Converts ENU coordinates to azimuth, elevation, slantrange



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
enu2uvw


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 584
 -- Function File: U, V, W = enu2uvw (EAST, NORTH, UP, LAT0, LON0)
 -- Function File: U, V, W = enu2uvw (EAST, NORTH, UP, LAT0, LON0,
          ANGLEUNIT)
     Convert ENU coordinates to UVW coordinates.

     Inputs:

     EAST, NORTH, UP: East, North, Up: coordinates of point(s) (meters)

     LAT0, LON0: geodetic coordinates of observer/reference point
     (degrees)

     ANGLEUNIT: string for angular units ('degrees' or 'radians',
     case-insensitive, first character will suffice).  Default =
     'degrees'.

     Outputs:

     U, V, W: coordinates of point(s) (meters).


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Convert ENU coordinates to UVW coordinates.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
extractfield


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 916
 -- Function File: extractfield (S, FIELD)
     Extract field values from struct array.

     Concatenates all the values from the field member FIELD in the
     structure array S.  The values are all concatenated into a row
     vector of the same type as the values.

          s(1).field = 1:3;
          s(2).field = 4:9;
          extractfield (s, "field")
          => [ 1   2   3   4   5   6   7   8   9 ]

     If any of the values is a string, or if the class is not the same
     for all the elements, a cell array with the intact elements is
     returned instead.

          s(1).field = 1:3;
          s(2).field = uint8 (4:6);
          extractfield (s, "field")
          => [ 1   2   3 ]
          => [ 4   5   6 ]

          s(1).field = "text";
          s(2).field = 1:3;
          extractfield (s, "field")
          => text
          => [ 1   2   3 ]

     See also: cell2mat, cellfun, getfield.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Extract field values from struct array.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
flat2ecc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 418
 -- Function File: ECC = flat2ecc (FLAT)
     Return the eccentricity given a flattening

     Examples:

     Scalar input:
             f_earth = 0.0033528;
             flat2ecc (f_earth)
             => 0.081819

     Vector input:
             flat = 0 : .01 : .05;
             flat2ecc (flat)
             ans =
                0.00000   0.14107   0.19900   0.24310   0.28000   0.31225

     See also: ecc2flat.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Return the eccentricity given a flattening



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
fromDegrees


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 438
 -- Function File: [A1, A2, ...] = fromDegrees (TOUNIT, DEG1, DEG2, ...)
     Convert angles from radians.

     Converts any number of input arguments, DEG1, DEG2, ... with angles
     in degrees, into TOUNIT which may be "radians" or "degrees".

          [a1, a2] = fromDegrees ("radians", 180, [180 360])
          =>  [ 3.1416 ]
          =>  [ 3.1416  6.2832 ]

     See also: deg2rad, fromRadians, toDegrees, toRadians, unitsratio.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Convert angles from radians.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
fromRadians


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 428
 -- Function File: [A1, A2, ...] = fromRadians (TOUNIT, RAD1, RAD2, ...)
     Convert angles from radians.

     Converts any number of input arguments, RAD1, RAD2, ... with angles
     in radians, into TOUNIT which may be "radians" or "degrees".

          [a1, a2] = fromRadians ("degrees", pi, [pi 2*pi])
          =>  [ 180 ]
          =>  [ 180  360 ]

     See also: fromDegrees, rad2deg, toDegrees, toRadians, unitsratio.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Convert angles from radians.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
geocentricLatitude


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 964
 -- Function File: PSI = geocentricLatitude (PHI, FLATTENING)
 -- Function File: PSI = geocentricLatitude (PHI, FLATTENING, ANGLEUNIT)
     Return geocentric latitude (psi) given geodetic latitude (phi) and
     flattening.

     The default input and output is in degrees; use optional third
     parameter ANGLEUNIT for radians.  PHI can be a scalar, vector,
     matrix or any ND array.  FLATTENING must be a scalar value in the
     interval [0..1).

     Examples Scalar input:
          psi = geocentricLatitude (45, 0.0033528)
          => psi =
           44.8076

     Also can use radians:
          psi = geocentricLatitude (pi/4, 0.0033528, "radians")
          => psi =
           0.78204

     Vector Input:
          phi = 35:5:45;
          psi = geocentricLatitude (phi, 0.0033528)
          => psi =
           34.819      39.811      44.808

     See also: parametricLatitude, geodeticLatitudeFromGeocentric,
     geodeticLatitudeFromParametric.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Return geocentric latitude (psi) given geodetic latitude (phi) and
flattening.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
geodetic2ecef


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1340
 -- Function File: X, Y, Z = geodetic2ecef (LAT, LON, ALT)
 -- Function File: X, Y, Z = geodetic2ecef (SPHEROID, LAT, LON, ALT)
 -- Function File: X, Y, Z = geodetic2ecef (..., ANGLEUNIT)
 -- Function File: X, Y, Z = geodetic2ecef (LAT, LON, ALT, SPHEROID)
     Converts from geodetic coordinate frame to ECEF coordinate frame.

     LAT, LON and ALT (latitude, longitude and height, respectively) can
     each be scalars, vectors or matrices but must all have the exact
     same size and dimension(s).

     SPHEROID ia user-specified sheroid (see referenceEllipsoid); it can
     be omitted or given as an ampty string, in which cases WGS84 will
     be the default spheroid.

     ANGLEUNIT can be "degrees" (= default) or "radians".  In the last
     calling fom, with SPHEROID as 4th input argument, ANGLEUNIT is in
     degrees and cannot be changed.

     The output arguments X, Y, Z (Earth-Centered Earth Fixed
     coordinates) are in meters and have the same sizes and dimensions
     as input arguments LAT, LON and ALT.

          Aalborg GPS Centre
          lat=57.02929569;
          lon=9.950248114;
          h= 56.95; # meters
          >> [X, Y, Z] = geodetic2ecef ("", lat, lon, h)
          X =     3426949.39675307
          Y =     601195.852419885
          Z =     5327723.99358255

     See also: ecef2geodetic.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Converts from geodetic coordinate frame to ECEF coordinate frame.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
geodeticLatitudeFromGeocentric


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1032
 -- Function File: PHI = geodeticLatitudeFromGeocentric (PSI,
          FLATTENING)
 -- Function File: PHI = geodeticLatitudeFromGeocentric (PSI,
          FLATTENING, ANGLEUNIT)
     Return geodetic latitude (phi) given geocentric latitude (psi) and
     flattening.

     The default input and output is in degrees; use optional third
     parameter ANGLEUNIT for radians.  PSI can be a scalar, vector,
     matrix or any ND array.  FLATTENING must be a scalar value in the
     interval [0..1).

     Examples Scalar input:
          phi = geodeticLatitudeFromGeocentric (45, 0.0033528)
          => phi =
            45.192

     Also can use radians:
          phi = geodeticLatitudeFromGeocentric (pi/4, 0.0033528, "radians")
          => phi =
           0.78876

     Vector Input:
          psi = 35:5:45;
          phi = geodeticLatitudeFromGeocentric (psi, 0.0033528)
          => phi =
           35.181       40.19      45.192

     See also: geocentricLatitude, geodeticLatitudeFromGeocentric,
     parametricLatitude.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Return geodetic latitude (phi) given geocentric latitude (psi) and
flattening.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
geodeticLatitudeFromParametric


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1100
 -- Function File: PHI = geodeticLatitudeFromParametric (BETA,
          FLATTENING)
 -- Function File: PHI = geodeticLatitudeFromParametric (BETA,
          FLATTENING, ANGLEUNIT)
     Returns geodetic latitude (phi) given parametric latitude and
     flattening.

     Parametric latitude (BETA) is also known as a reduced latitude.
     The default input and output is in degrees; use optional third
     parameter ANGLEUNIT for radians.  BETA can be a scalar, vector,
     matrix or any ND array.  FLATTENING must be a scalar value in the
     interval [0..1).

     Examples: Scalar input:
          phi = geodeticLatitudeFromParametric (45, 0.0033528)
          => phi =
           45.096

     Also can use radians:
          phi = geodeticLatitudeFromParametric (pi/4, 0.0033528, "radians")
          => phi =
           0.78708

     Vector Input:
          beta = 35:5:45;
          phi = geodeticLatitudeFromParametric (beta, 0.0033528)
          => phi =
           35.09      40.095      45.096

     See also: geocentricLatitude, geodeticLatitudeFromGeocentric,
     parametricLatitude.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Returns geodetic latitude (phi) given parametric latitude and
flattening.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
geoshow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 536
 -- Function File: geoshow (SHPS)
 -- Function File: geoshow (SHPS, CLR)
     Plot a mapstruct created by shaperead.

     SHPS is the name of a geostruct created by shaperead.

     Optional argument CLR can be a predefined color ("k", "c", etc.),
     an RGB triplet, or a 2 X 1 column vector of RGB triplets (each row
     containing a triplet).  The uppermost row will be used for points
     and lines, the lowermost row for solid shape features (not yet
     implemented).

     See also: mapshow, shapedraw, shapeinfo, shaperead.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Plot a mapstruct created by shaperead.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
gmlread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1495
 -- GML = gmlread (FNAME, DOTS)
     Read a .gml (Geographic Markup Language) file.

     gmlread only reads coordinates, no attributes.

     Required input argument FNAME is the name of a .gml file.  If no
     other arguments are specified all features in the entire .gml file
     will be read.

     The following optional property/value pairs (all case-insensitive)
     can be specified to select only some feature types and/or features
     limited to a certain area:

        * "FeatureType" (Just one "f" will do) Only read a certain
          feature type; the value can be one of "Points", "LineStrings"
          or "Polygons" (only the first three characters matter).
          Multiple feature types can be selected by specifying multiple
          FeatureType property/value pairs.

        * BoundingBox (just one "b" suffices) Only read features that
          lie entirely within a coordinate rectangle specified as a 2x2
          matrix containing [minX minY; maxX maxY].

     In addition verbose output can be obtained by specifying the
     following property/value pair:

        * Debug (a "d" will do) followed by a numeric value of 1 (or
          true) specifies verbose output; a numeric value of 0 (or
          false) suppresses verbose output.

     The output of gmlread comprises a struct containing up to three
     mapstructs (MultiPoint and/or Polyline and/or Polygon mapstructs),
     depending on optional featuretype selection.

     See also: shaperead.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Read a .gml (Geographic Markup Language) file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
gpxread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1921
 -- OUT = gpxread (FNAME)
 -- OUT = gpxread (FNAME, ...)
     Read data from a gpx file.

     Input argument FNAME (a character string) can be a valid file name
     or a valid URL.

     If no other input arguments are given gpxread will read all data in
     FNAME into one output struct OUT.  The data to be read can be
     selected and/or limited by specifying one or more of the following
     optional property/value pairs (all case-insensitive):

        * "FeatureType' This option (a mere "f" suffices) can be one of:
               "WayPoint or simply "w": Read waypoints.

               "Track" or "t": read tracks.

               "Route" or "t": read routes.

               "Auto" or "a" (default value): read all data.

          Multiple FeatureType property/value pairs can be specified.

        * "Index" The ensuing Index value should be a numeric value, or
          numeric vector, of indices of the features to be read.

     Output argument OUT is a struct array with field names Name, Lat,
     Lon, Ele, Time, and -in case of routes- Names.  "Name" refers to
     the name of the waypoints, tracks or routes that have been read.
     "Lat", "Lon" and "Ele" refer to the latitude, longitude and
     elevation of the various features, in case of tracks field "Time"
     refers to the time of the trackpoint.  In case of tracks and routes
     these are vectors, each element corresponding to one track point.
     For each individual track multiple track segments are separated by
     NaNs.  For routes the field "Names" contains a cell array holding
     the names of the individual route points.

     Examples:

            A = gpxread ("trip2.gpx", "feature", "track", "index", 2);
            (which returns data from the second track in file "trip1.gpx")

            B = gpxread ("trip2.gpx", "f", "t", "f", "r");
            (which returns track and route data from file "trip2.gpx")


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Read data from a gpx file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
isShapeMultipart


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 393
 -- MP = isShapeMultipart (X, Y)
     Checks if a polygon or polyline consists of multiple parts
     separated by NaN rows.

     X and Y must be vectors with the same orientation (either row
     vectors of column vectors).

     Output argument MP is zero (false) if the shape contains no NaN
     rows, otherwise it equals the number of polygon/polyline shape
     parts.

     See also: .


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Checks if a polygon or polyline consists of multiple parts separated by
NaN r...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
km2deg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 668
 -- Function File: DEG = km2deg (KM)
 -- Function File: DEG = km2deg (KM, RADIUS)
 -- Function File: DEG = km2deg (KM, SPHERE)
     Convert distance to angle.

     Calculates the angles DEG for the distances KM in a sphere with
     RADIUS (also in kilometers).  If unspecified, radius defaults to
     6371, the mean radius of Earth.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object mean
     radius.

     See also: deg2km, deg2sm, km2rad, km2deg, nm2deg, nm2rad, rad2km,
     rad2nm, rad2sm, sm2deg, sm2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Convert distance to angle.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
km2nm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 125
 -- Function File: km2nm (KM)
     Convert kilometers into nautical miles.

     See also: km2sm, nm2km, nm2sm, sm2km, sm2nm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Convert kilometers into nautical miles.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
km2rad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 700
 -- Function File: RAD = km2rad (KM)
 -- Function File: RAD = km2rad (KM, RADIUS)
 -- Function File: RAD = km2rad (KM, SPHERE)
     Converts distance to angle by dividing distance by radius.

     Calculates the angles RAD for the distances KM in a sphere with
     RADIUS (also in kilometers).  If unspecified, radius defaults to
     6371, the mean radius of Earth.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object mean
     radius.

     See also: deg2km, deg2sm, km2rad, km2deg, nm2deg, nm2rad, rad2km,
     rad2nm, rad2sm, sm2deg, sm2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Converts distance to angle by dividing distance by radius.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
km2sm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 144
 -- Function File: km2sm (KM)
     Convert kilometers into U.S. survey miles (statute miles).

     See also: km2nm, nm2km, nm2sm, sm2km, sm2nm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Convert kilometers into U.S. survey miles (statute miles).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
kmlread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 334
 -- KML = kmlread (FNAME)
     (EXPERIMENTAL) Read a Google kml file and return its contents in a
     struct.

     NAME is the name of a .kml file.  Currently kmlread can read Point,
     LineString, Polygon, Track nd Multitrack entries.

     KML is a struct with fields Type, Lat, Lon, Ele, Time and Name.

     See also: kmzread.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
(EXPERIMENTAL) Read a Google kml file and return its contents in a
struct.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
kmzread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 186
 -- RETVAL = kmzread (FNAME, ...)
     Read a compressed Google kmz file and return its contents in a
     struct.

     See 'help kmlread' for more information.

     See also: kmlread.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Read a compressed Google kmz file and return its contents in a struct.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
majaxis


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 657
 -- Function File: SEMIMAJORAXIS = majaxis (SEMIMINORAXIS, ECC)
     Return the semimajor axis given the semiminoraxis (b) and
     eccentricity (e).

     Examples

     Scalar input:
           earth_b = 6356752.314245;  ## meter
           earth_ecc = 0.081819221456;
           a = majaxis (earth_b, earth_ecc)
           => a =
            6.3781e+06

     Vector input:
           planets_b = [ 6356752.314245 ; 66854000 ]; ## meter
           planets_ecc = [ 0.081819221456 ; 0.3543164 ];
           planets_a = majaxis ( planets_b , planets_ecc )
           => planets_a =
               6.3781e+06
               7.1492e+07

     See also: minaxis.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Return the semimajor axis given the semiminoraxis (b) and eccentricity
(e).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
makesymbolspec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3652
 -- Function File: SYMSPEC = makesymbolspec (GEOMETRY, RULE#1...RULE#N)
 -- Function File: SYMSPEC = makesymbolspec (GEOMETRY, {"Default",
          PROPERTY1, VALUE1, ...})
 -- Function File: SYMSPEC = makesymbolspec (GEOMETRY, {ATTR, ATTVAL,
          PROPERTY1, VALUE1, ...})
     Create a symbol specification structure for use with mapshow.

     Each symbolspec refers to one geometry type.  GEOMETRY can be one
     of "Point", "MultiPoint", "Line", "PolyLine", "Polygon", or
     "Patch".  The following argument(s) are rules.  Each rule is a
     separate cell array.  The first entry of a rule must be the string
     "Default" of an attribute/value pair.  The attribute ATTR should
     conform to the attributes of the map feature to be drawn with the
     symbolspec; often these are the attributes of shapefiles.  The
     value ATTVAL can be a:

        * Numeric value or range of values (row vector).  Map features
          with attribute ATTR values equal to, or in the range ATTVAL
          (end points inclusive) will be drawn with the propety/value
          pairs in the rest of the rule.  These include X and Y
          coordinates.

        * Logical value.  The map features with values for attribute
          ATTR equal to ATTVAL will be drawn with the propety/value
          pairs in the rest of the rule.

        * Character string.  Those map features with ATTR text strings
          corresponding to ATTVAL will be drawn with the propety/value
          pairs in the rest of the rule.

     In case of oct-type structs (see shaperead.m) additional attributes
     are available:

     'X'
     'Y'
     'Z'
     'M'
          X, Y, Z or M-values of vertices of polylines / polygons /
          multipatches are used to indicate the matching shape features
          are to be drawn.  A matching value of just one sigle vertex of
          poit in the specified range suffices to match a shape feature.

     'npt'
          npt encodes for the number of vertices for each multipoint,
          polygon, polyline or multipatch shape feature in the original
          shapefile.

     'npr'
          npr encodes for the number of parts of each shape feature.

     The property/value pairs for each rule should conform to the
     geometry type.  That is, for (Multi)Point features only marker
     properties may be specified, similarly for Lines/Polylines (line
     properties) and Polygons/Patches (patch and fill properties).

     The case of input geometries and properties does not matter;
     makesymbolspec will turn them into the "official" casing.

            symsp1 = makesymbolspec ("Line", {"TAG1", "road", ...
                                               "color", "b"})
            (draw polylines tagged "road" as blue lines)

            symsp2 = makesymbolspec ...
                     ("Line", {"TAG1", "road", "color", "b", ...
                               "linestyle", "-", "linewidth", 3} ...
                              {"TAG1", "rail", "color", ...
                                [0.7 0.5 0.2], ...
                               "linestyle", "--", "linewidth", 2})
            (like above, but with polylines tagged "rail" as dashed
             light brown lines)

            symsp3 = makesymbolspec
                     ("Polygon", {"M", [ 0    10], "Facecolor", "c"}, ...
                                 {"M", [10.01 20], "Facecolor", "b"}, ...
                                 {"M", [20.01 30], "Facecolor", "m"})
            (Note: only possible with oct-style shapestructs; create a
             symbolspec using M-values in three classes)

     See also: mapshow, geoshow.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Create a symbol specification structure for use with mapshow.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
mapshow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3282
 -- Function File: H = mapshow (DATA)
 -- Function File: H = mapshow (DATA, CLR)
 -- Function File: H = mapshow (DATA, CLR, ...)
 -- Function File: H = mapshow (DATA, ...)
 -- Function File: H = mapshow (X, Y)
 -- Function File: H = mapshow (X, Y, CLR)
     Draw a map based on raster or shapefile data.

     DATA can be:

        * The filename of a GIS raster file (any file supported by the
          GDAL library) or of an ArcGIS shapefile.  mapshow will invoke
          rasterread.m and rasterdraw.m.

        * A raster band struct created by rasterread.m; in that case the
          corresponding raster info struct (also made by rasterread.m)
          is required as second input argument.

        * A struct created by shaperead.m.  DATA can be a mapstruct or
          an Octave-style shape struct.

        * The base name or full file name of an ArcGis shape file.
          mapshow will invoke shaperead.m and shapedraw.m

     If the first two arguments to mapshow.m contain numeric vectors,
     mapshow will simply draw the vectors as XY lines.  The vectors can
     contain NaNs (in identical positions) to separate parts.

     For raster maps currently no further input arguments are
     recognized.  For shapefile data, optional argument CLR can be a
     predefined color ("k", "c", etc.), and RGB triplet, or a 2 X 1
     column vector of predefined colors or RGB triplets (each row
     containing a predefined color or triplet).  The upper row will be
     used for points and lines, the lower row for solid shape features.
     For XY data, only the first row is used.  One-character color codes
     can be preceded by one-character linestyle indicators (":", "-",
     "-", "-.")  to modify the linestyle for polylines, or marker styles
     ("o", "*", ".", "+", "," ">", "<", "s", "d", "h", "v", "^") for
     points.

     Any other arguments are considered graphics properties for
     (multi-)points, polylines and polygons and will be conveyed as-is
     to the actual plotting routines.

     Additionally, if the first argument is a shape struct, mapshow
     accepts a property-value pair "symbolspec" (minimum abbreviation
     "symb") with a value comprising a cell array containing
     instructions on how to display the shape contents.  Multiple
     sympolspec property/value pairs can be specified.

     Return argument H is a handle to the plot figure.

     Examples:

            H = mapshow ("/full/path/to/map")
            (draws a raster map and returns the figure handle in H)

            H = mapshow ("shape.shp", ":g")
            H = mapshow ("shape.shp", "color", "g", "linestyle", ":")
            (draws a polygon shapefile "shape.shp" with green
             dotted lines and return figure handle in H)

            mapshow (X, Y, "k")
            (plot vectors X and Y in black color)

            mapshow (X, Y, "-.r", "linewidth", 5)
            (plot vectors X and Y as a dashdotted thick red line)

            mapshow (data, "symbolspec", symsp1, "symb", symsp2)
            (draw contents of shapestruct (or mapstruct) data
             according to the symbolspecs symsp1 and symsp2)

     See also: geoshow, shapedraw, shapeinfo, shaperead, shapewrite,
     makesymbolspec, rasterread, rasterdraw, rasterinfo.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Draw a map based on raster or shapefile data.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
meridianarc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 722
 -- Function File: S = meridianarc (PHI, PHI_2, SPHEROID, ANGLEUNIT)
     Returns the meridian arch length given two latitudes PHI and PHI_2.

     If phi_2 is larger than phi the value will be negative.

     If no spheroid is given the default is wgs84.  The angleunit can be
     degrees or radians (the latter is default).

     Examples Full options:
          s = meridianarc (0, 56, "int24", "degrees")
          => s =
          6.2087e+06
     Short version:
          s = meridianarc (0, pi/4)
          => s =
          4.9849e+06
     If want different units:
          s = meridianarc (0, 56, referenceEllipsoid ("int24", "km"), "degrees")
          => s =
          6208.7

     See also: referenceEllipsoid.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Returns the meridian arch length given two latitudes PHI and PHI_2.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
minaxis


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 644
 -- Function File: SEMIMINORAXIS = minaxis (SEMIMAJORAXIS, ECC)
     Return the semiminor axis given the semimmajor axis (a) and
     eccentricity (ecc).

     Examples

     Scalar input:
           earth_a = 6378137; %m
           earth_ecc = 0.081819221456;
           earth_b = minaxis (earth_a, earth_ecc)
           => earth_b =
               6.3568e+06

     Vector input:
           planets_a = [ 6378137 ; 66854000 ];
           planets_ecc = [ 0.081819221456 ; 0.3543164 ];
           planets_b = minaxis (planets_a , planets_ecc)
           => planets_b =
               6.3568e+06
               6.2517e+07

     See also: majaxis.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 79
Return the semiminor axis given the semimmajor axis (a) and eccentricity
(ecc).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
n2ecc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 413
 -- Function File: ECC = n2ecc (N)
     This returns the eccentricity given the third flattening (n).

     Examples:

     Scalar input:
           n_earth = 0.0016792;
           ecc_earth = n2ecc (n_earth)
           => ecc_earth = 0.081819

     Vector input:
           n_vec = [ 0.0016792 0.033525 ];
           ecc = n2ecc (n_vec)
           => ecc =
          	 0.081819     0.35432

     See also: n2ecc.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
This returns the eccentricity given the third flattening (n).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
nm2deg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 673
 -- Function File: DEG = nm2deg (NM)
 -- Function File: DEG = nm2deg (NM, RADIUS)
 -- Function File: DEG = nm2deg (NM, SPHERE)
     Converts distance to angle by dividing distance by radius.

     Calculates the angles DEG for the distances NM in a sphere with
     RADIUS (also in nautical miles).  If unspecified, radius defaults
     to 6371 km, the mean radius of Earth and is converted to nautical
     miles internally.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object mean
     radius.

     See also: km2deg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Converts distance to angle by dividing distance by radius.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
nm2km


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 125
 -- Function File: nm2km (NM)
     Convert nautical miles into kilometers.

     See also: km2nm, km2sm, nm2sm, sm2km, sm2nm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Convert nautical miles into kilometers.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
nm2rad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 673
 -- Function File: RAD = nm2rad (NM)
 -- Function File: RAD = nm2rad (NM, RADIUS)
 -- Function File: RAD = nm2rad (NM, SPHERE)
     Converts distance to angle by dividing distance by radius.

     Calculates the angles RAD for the distances NM in a sphere with
     RADIUS (also in nautical miles).  If unspecified, radius defaults
     to 6371 km, the mean radius of Earth and is converted to nautical
     miles internally.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object mean
     radius.

     See also: km2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Converts distance to angle by dividing distance by radius.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
nm2sm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 148
 -- Function File: nm2sm (NM)
     Convert nautical miles into U.S. survey miles (statute miles).

     See also: km2nm, km2sm, nm2km, sm2km, sm2nm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Convert nautical miles into U.S. survey miles (statute miles).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
parametricLatitude


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1049
 -- Function File: BETA = parametricLatitude (PHI, FLATTENING)
 -- Function File: BETA = parametricLatitude (PHI, FLATTENING,
          ANGLEUNIT)
     Returns parametric latitude given geodetic latitude (phi) and
     flattening.

     The parametric latitude BETA is also known as a reduced latitude.
     The default input and output is in degrees; use optional third
     parameter ANGLEUNIT for radians.  PHI can be a scalar, vector,
     matrix or any ND array.  FLATTENING must be a scalar value in the
     interval [0..1).

     Examples: Scalar input:
          beta = parametricLatitude (45, 0.0033528)
          => beta =
           44.904

     Also can use radians:
          beta = parametricLatitude (pi/4, 0.0033528, "radians")
          => beta =
           0.78372

     Vector Input:
          phi = 35:5:45;
          beta = parametricLatitude (phi, 0.0033528)
          => beta =
           34.91      39.905      44.904

     See also: geocentricLatitude , geodeticLatitudeFromGeocentric ,
     geodeticLatitudeFromParametric.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Returns parametric latitude given geodetic latitude (phi) and
flattening.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
polycut


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1237
 -- Function File: [XO, YO] = polycut (XI, YI)
 -- Function File: [XO, YO, ZO] = polycut (XI, YI, ZI)
 -- Function File: [XY_O] = polycut (XY_I)
     Reorder nested multipart polygons in such a way that branch cuts
     aren't drawn when using the patch command.

     Normally when drawing multipart nested polygons (with holes and
     other polygons inside the holes; polygon parts separated by NaNs)
     holes will be filled.  Connecting the polygon parts by deleting the
     NaNs leads to edges of some polygon parts to be drawn across
     neighboring polygon parts.  polycut reorders the polygon parts such
     that the last vertices of polygon parts have minimum distance to
     the first vertices of the next parts, avoiding the connecting lines
     ("branch cuts") to show up in the drawing.

     Input consists of separate X, Y, and -optionally- Z vectors, or an
     Nx2 or Nx3 matrix of vertex coordinates (X, Y) or (X, Y, Z). If
     individual X and Y vectors were input, the output consists of the
     same number of vectors.  If an Nx 2 or Nx3 array was input, the
     output will be an Nx2 or Nx3 matrix as well.

     polycut is a mere wrapper around the function polygon2patch in the
     OF geometry package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Reorder nested multipart polygons in such a way that branch cuts aren't
drawn...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
rad2km


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 702
 -- Function File: KM = rad2km (RAD)
 -- Function File: KM = rad2km (RAD, RADIUS)
 -- Function File: KM = rad2km (RAD, SPHERE)
     Converts angle to distance by multiplying angle with radius.

     Calculates the distances KM in a sphere with RADIUS (also in
     kilometers) for the angles RAD.  If unspecified, radius defaults to
     6371, the mean radius of Earth.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object mean
     radius.

     See also: deg2km, deg2sm, km2rad, km2deg, nm2deg, nm2rad, rad2km,
     rad2nm, rad2sm, sm2deg, sm2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Converts angle to distance by multiplying angle with radius.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
rad2nm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 745
 -- Function File: NM = rad2nm (RAD)
 -- Function File: NM = rad2nm (RAD, RADIUS)
 -- Function File: NM = rad2nm (RAD, SPHERE)
     Converts angle in radians to distance in nautical miles by
     multiplying angle with radius.

     Calculates the distances NM in a sphere with RADIUS (also in
     nautical miles) for the angles RAD.  If unspecified, radius
     defaults to 3440 nm, the mean radius of Earth.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object's mean
     radius.

     See also: deg2km, deg2nm, deg2sm, km2rad, km2deg, nm2deg, nm2rad,
     rad2km, rad2sm, sm2deg, sm2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Converts angle in radians to distance in nautical miles by multiplying
angle ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
rad2sm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 743
 -- Function File: SM = rad2sm (RAD)
 -- Function File: SM = rad2sm (RAD, RADIUS)
 -- Function File: SM = rad2sm (RAD, SPHERE)
     Converts angle in radians to distance in statute miles by
     multiplying angle with radius.

     Calculates the distances SM in a sphere with RADIUS (also in
     statute miles) for the angles RAD.  If unspecified, radius defaults
     to 3958 sm, the mean radius of Earth.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object's mean
     radius.

     See also: deg2km, deg2nm, deg2sm, km2rad, km2deg, nm2deg, nm2rad,
     rad2km, rad2nm, sm2deg, sm2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Converts angle in radians to distance in statute miles by multiplying
angle w...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
radtodeg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 177
 -- Function File: rad2deg (ANGLIN)
 -- Function File: radtodeg (ANGLIN)
     Converts angles input in radians to the equivalent in degrees.

     See also: deg2rad, unitsratio.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Converts angles input in radians to the equivalent in degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
rasterclip


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 643
 -- [RBO, RIO] = rasterclip (RBI, RII, CLPBOX)
     Clip a georaster with a rectangle and return adapted bands and info
     structs.

     rasterclip is useful for extracting a part of a raster map to
     enable e.g., faster drawing RBI and RII are output structs from
     rasterread.m CLPBOX is a 2x2 matrix containing [Xmin, Ymin; Xmax,
     Ymax] of the rectangle.

     Output structs RBO and RIO contain adapted bbox, data, Width,
     Height and GeoTransformation fields.  All other fields are copied
     verbatim, except fields FileSize, FileName and FileModDate which
     are all left empty.

     See also: rasterread,rasterdraw.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Clip a georaster with a rectangle and return adapted bands and info
structs.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
rasterdraw


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1909
 -- H = rasterdraw (DATA)
 -- H = rasterdraw (DATA, RINFO)
 -- H = rasterdraw (..., PROPERTY, VALUE, ...)
     Draw a GIS raster map.

     DATA can be a file name of a GIS raster data file, or a raster data
     struct made by rasterread; in the latter case input arg RINFO, a
     raster info struct also made by rasterread, is also required.

     Optionally, property/value pairs can be specified.  Only the first
     four characters of the property need to be entered.  The following
     property/value pairs are recognized:

        * 'bands': The value should be a scalar value or vector
          indicating which band(s) will be drawn in case of multi-band
          raster data.  The default is all bands if the data contains
          three bands of integer data type, or the first band in all
          other cases.  For non-integer raster data only one raster band
          can be specified.  The number of bands must be 1 or 3.

        * 'colormap': The value should be a valid colormap to be used
          for indexed raster data.

        * 'missingvalue': A numerical value to substitute for missing
          values in the raster data.  Default is NaN (for floating point
          raster data).

     The optional output argument H is a graphics handle to the map.

     If the raster data to be plotted comprises just one band and a GDAL
     colortable, that colortable is converted to a colormap and used for
     drawing the map.  The actual raster data are converted to uint8 if
     no missing data are present.

     Behind the scenes imshow() is invoked for the actual drawing for
     integer or single-band data, or pcolor() for floating point data
     with missing values.

     Note that drawing raster data can be quite slow for big data sets.
     Drawing maps larger than ~4000x4000 pixels is therefore not
     advised.

     See also: mapshow, rasterread, rasterinfo.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Draw a GIS raster map.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
rasterinfo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 302
 -- RINFO = rasterinfo (FNAME)
     Return various info about a GIS raster file: a.o., file type, bit
     depth, raster size, projection and geotransformation.  If the
     raster file is a geotiff file, additional info is returned.

     rasterinfo needs the GDAL library.

     See also: rasterread.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Return various info about a GIS raster file: a.o., file type, bit depth,
rast...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
rasterread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 834
 -- Function File: [BANDS, INFO] = rasterread (FNAME)
     Read a GIS raster file

     FNAME can be about any type of GIS raster file recognized by the
     GDAL library.  For .adf files, either the name of the subdirectory
     containing the various component files, or the name of one of those
     component files can be specified.

     Output argument BANDS is a struct, or if multiple bands were read,
     a struct array, with data of each band: data, min, max, bbox, and
     (if present for the band) a GDAL colortable (see GDAL on-line
     reference).

     Output argument BINFO contains various info of the raster file:
     overall bounding box, geotransformation, projection, size, nr.  of
     columns and rows, datatype, nr.  of bands.

     rasterread.m needs the GDAL library.

     See also: gdalread, gdalwrite.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Read a GIS raster file



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
rcurve


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1478
 -- Function File: R = rcurve (SPHEROID, LAT)
 -- Function File: R = rcurve (TYPE, SPHEROID, LAT)
 -- Function File: R = rcurve (..., ANGLEUNIT)
     Return the length of a curve based on its type: meridian, parallel,
     or transverse.

     Optional input argument TYPE is one of "meridian", "parallel", or
     "transverse; default (when left empty or skipped) is "parallel".
     SPHEROID is the spheroid of choice (default: "wgs84").  LAT is the
     latitude at which the curve length should be computed and can be a
     numeric scalar, vector or matrix.  Output argument R will have the
     same size and dimension(s) as LAT.

     Optional input argument ANGLEUNIT can be either "radians" or
     "degrees" (= default); just "r" or "d" will do.  All character
     input is case-insensitive.

     Examples:

          r = rcurve ("parallel", "wgs84", 45)
          => r =
          4.5176e+06
          Note: this is in meters

          r = rcurve ("", 45)
          => r =
          4.5176e+06

          r = rcurve ("", "", 45)
          => r =
          4.5176e+06

          r = rcurve ("", "", pi/4, "radians")
          => r =
          4.5176e+06

          r = rcurve ("meridian", "wgs84", 45)
          => r =
          6.3674e+06

          r = rcurve ("transverse", "wgs84", 45)
          => r =
          6.3888e+06

     Also can use structures as inputs:
          r = rcurve("", referenceEllipsoid ("venus"), 45)
          => r =
          4.2793e+06


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Return the length of a curve based on its type: meridian, parallel, or
transv...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
reckon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 625
 -- Function File: [LATO,LONO] = reckon(LAT,LON,RANGE,AZIMUTH)
 -- Function File: [LATO,LONO] = reckon(LAT,LON,RANGE,AZIMUTH,UNITS)
     Compute the coordinates of the end-point of a displacement on a
     sphere.  LAT,LON are the coordinates of the starting point, RANGE
     is the covered distance of the displacements along a great circle
     and AZIMUTH is the direction of the displacement relative to the
     North.  The units of all input and output parameters can be either
     'degrees' (default) or 'radians'.

     This function can also be used to define a spherical coordinate
     system with rotated poles.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
Compute the coordinates of the end-point of a displacement on a sphere.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
referenceEllipsoid


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2591
 -- Function File: referenceEllipsoid (NAME, UNIT)
     Returns the parameters of an ellipsoid.

     NAME can be the name (e.g., "wgs84") or (integer) EPSG code of a
     reference ellipoid.  Case is not important.  If the number or code
     0 (zero) is specified, referenceEllipsoid echoes a list of
     implemented ellipsoids to the screen.

     UNIT can be the name of any unit accepted by function
     validateLengthUnit.m.  Also here case is not important.

     The output consists of a scalar struct with fields "Code" (EPSG
     code of the ellipsoid), "Name" (name of the ellipsoid),
     "LengthUnit", "SemimajorAxis", "SemiminorAxis",
     "InverseFlattening", "Eccentricity", "Flattening",
     "ThirdFlattening", "MeanRadius", "SurfaceArea", and "Volume".

     Examples:

          >> E = referenceEllipsoid ("wgs84")
          E =

           scalar structure containing the fields:

             Code =  7030
             Name = World Geodetic System 1984
             LengthUnit = meter
             SemimajorAxis =  6378137
             SemiminorAxis =    6.3568e+06
             InverseFlattening =  298.26
             Eccentricity =  0.081819
             Flattening =  0.0033528
             ThirdFlattening =  0.0016792
             MeanRadius =    6.3710e+06
             SurfaceArea =    5.1007e+14
             Volume =    1.0832e+21

     The code number can be used:

          >> E = referenceEllipsoid (7019)
          E =

           scalar structure containing the fields:

             Code =       7019
             Name = Geodetic Reference System 1980
             LengthUnit = meter
             SemimajorAxis = 6.3781e+06
             SemiminorAxis = 6.3568e+06
             InverseFlattening =     298.26
             Eccentricity =   0.081819
             Flattening =  0.0033528
             ThirdFlattening =  0.0016792
             MeanRadius =  6.371e+06
             SurfaceArea = 5.1007e+14
             Volume = 1.0832e+21

          >> E = referenceEllipsoid ("wgs84", "km")
          E =

           scalar structure containing the fields:

             Code =  7030
             Name = World Geodetic System 1984
             LengthUnit = km
             SemimajorAxis =  6378.1
             SemiminorAxis =  6356.8
             InverseFlattening =  298.26
             Eccentricity =  0.081819
             Flattening =  0.0033528
             ThirdFlattening =  0.0016792
             MeanRadius =  6371.0
             SurfaceArea =    5.1007e+08
             Volume =    1.0832e+12

     See also: validateLengthUnit, wgs84Ellipsoid.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Returns the parameters of an ellipsoid.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
removeExtraNanSeparators


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 589
 -- Function File: [X, Y, ...] = removeExtraNanSeparators (X, Y, ...)
     Remove groups of NaN and leave a single separator.

     For any number of vectors, X, Y, Z, ..., reduce groups of
     contiguous NaNs into a single NaN separator.  The vectors must all
     have the same dimensions and the NaNs must be locations.  Leading
     NaNs are removed, and trailing NaNs are reduced to one.

          removeExtraNanSeparators ([NaN NaN 3 4 5 NaN NaN 8 NaN], [NaN NaN 7 6 5 NaN NaN 2 NaN])
          => [3 4 5 NaN 8 NaN]
          => [7 6 5 NaN 2 NaN]

     See also: diff, isnan, isna.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Remove groups of NaN and leave a single separator.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
roundn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 323
 -- Function File: roundn (X)
 -- Function File: roundn (X, N)
     Round to multiples of 10.

     Returns the double nearest to multiply of 10^N, while N has to be
     an integer scalar.  N defaults to zero.

     When X is an integer, it rounds to the nearest decimal power.

     See also: round ceil floor fix roundb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
Round to multiples of 10.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
shapedraw


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2393
 -- Function File: [H] = shapedraw (SHP)
 -- Function File: [H] = shapedraw (SHP, CLR)
 -- Function File: [H] = shapedraw (SHP, CLR, ...)
 -- Function File: [H] = shapedraw (SHP, ...)
     Plot contents of a shapefile, a map-/geostruct or a struct made by
     shaperead.m.

     SHP can be a shapefile (will be read and plotted), a struct made by
     shaperead, or a mapstruct or geostruct, possibly made by some other
     function.  shapeplot.m will try to determine the type.  Points,
     MultiPoints, Polylines, Polygons and MultiPatch shape features can
     be plotted.

     The optional argument CLR can be a predefined color name ('b',
     'green', etc.)  or an RGB triplet.  The default is [0.6, 0.6, 0.6]
     which produces a grey plot.  Polygons and MultiPatches can also be
     plotted as solid patches; then CLR needs to have a second row
     indicating the fill color.  Octave does not support transparent
     fills yet.  Single-character color codes can be combined with
     linestyle indicators ":", "-", "-", "-.", ".-" and/or marker style
     indicators "*", ".", "+", "@", "v", "^", ">", "<", "d", "h", "o",
     "p", "s" to modify the linestyle for polylines.

     Other graphics properties for drawing can be supplied either
     instead of, or after the color argument and will be conveyed as-is
     to the actual drawing routines.  Depending on shapetype, the
     following proqperties are accepted:

        * All shape types: Visible, LineStyle, LineWidth, Marker,
          MarkerEdgeColor, MarkerFaceColor, MarkerSize

        * Point, MultiPoints, Line, Polyline: Color

        * Polygon, MultiPatch: FaceColor, EdgeColor

     Polygons with holes can be properly plotted provided the holes are
     separate shape feature parts comprising counterclockwise polylines;
     the first partial feature must be the clockwise outer polygon.  The
     Octave-Forge geometry package is required to assess whether
     multipart polygons have holes and to properly draw them.
     shapedraw.m will search for the geometry package the first time it
     is instructed to plot filled polygons.  To initiate a new search
     later on (e.g., after the geometry package has been loaded), simply
     invoke shapedraw without any arguments.

     Optional output argument H is the figure handle of the plot.

     See also: geoshow, mapshow, shapeinfo, shaperead.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 79
Plot contents of a shapefile, a map-/geostruct or a struct made by
shaperead.m.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
shapeinfo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 953
 -- Function File: [ INFS ] = shapeinfo (FNAME)
     Returns a struct with info on shapefile FNAME.

     Input:
     'FNAME'
          (character string).  Does not need to have a .shp suffix.

     Output: a struct with fields:

     'Filename'
          Contains the filename of the shapefile.

     'ShapeType'
          The type of shapefile.

     'ShapeTypeName'
          The name of the shape type.

     'BoundingBox'
          The minimum and maximum X and Y coordinates of all items in
          the shapefile in a 2 X 2 array, upper rox min and min Y, lower
          row max X and max Y.

     'NumFeatures'
          The number of features (items, records) in the shapefile.

     'Attributes'
          A structure with fields Name and Type (containng the names and
          types of all attributes in the shapefile).  Type can be
          Numeric, Character or Data.

     See also: geoshow, mapshow, shapedraw, shaperead, shapewrite.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Returns a struct with info on shapefile FNAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
shaperead


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7679
 -- Function File: [OUTSTRUCT ] = shaperead (SHP_FILENAME)
 -- Function File: [OUTSTRUCT ] = shaperead (SHP_FILENAME, OUTSTYLE)
 -- Function File: [OUTSTRUCT ] = shaperead (SHP_FILENAME, OUTSTYLE,
          OPTS)
 -- Function File: [OUTSTRUCT, ATTS ] = shaperead (SHP_FILENAME, ...)
     Read an ArcGis shapefile set (shp, shx and dbf).

     Depending on the value of OUTSTYLE some different output formats
     will be returned:

     '0 (numeric)'
     'ml (case-insensitive)'
     'm'
          Return a Matlab-compatible M X 1 struct with a separate entry
          for each shape feature in the shape file.  Each struct element
          contains fields "Geometry" (shape type), "BoundingBox" ([minX
          minY ; maxX maxY]), X, Y (coordinates of points in the shape
          item as row vectors).  For multi-part items, the coordinates
          of each part are separated by NaNs.  This output format
          supports neither M and Z type nor MultiPatch shape features.
          For M and Z type shape features the M and Z values will simply
          be ignored.  The struct is augmented with attributes found in
          the accompanying .dbf file, if found.

          For ML-style output, if only one output argument is requested
          the attributes in the .dbf file will be augmented to that
          struct.  If two output arguments are requested, the attributes
          will be returned separately in output struct ATTS.

     '1 (numeric)'
     'ext (case-insensitive)'
     'e'
          Same as 1 but M and Z type and MultiPatch shape features are
          accepted.  The resulting output struct is no more
          ML-compatible.  If the shapefile contains M and/or Z type
          shape features the mapstruct or geostruct has extra fields M
          and -optionally- Z. Note that MultiPatch shape features may
          not have M-values even if Z-values are present.  For
          MultiPatch shapes another field Parts is added, a Px2 array
          with zero-based indices to the first vertex of each subfeature
          in the XYZ fields in column 1 and the type of each subfeature
          in column 2; P is the number of shape feature parts.

     '2 (numeric)'
     'oct (case-insensitive)'
     'o'
          Return a struct containing a N X 6 double array "vals"
          containing the X, Y, and Z coordinates, M-values, record nr.
          and type of each point in the shape file.  If no M or Z values
          were present the relevant columns contain NaNs.  Individual
          shape features and shape parts are separated by a row of NaN
          values.  The field "idx" contains 1-based pointers into field
          vals to the first vertex of each shape feature.  Field "bbox"
          contains an 8 X M double array of XYZ coordinates of the
          bounding boxes and min/max M-values corresponding to the M
          items found in the .shp file; for point shapes these contain
          NaNs.  Field "npt" contains a 1 X M array of the number of
          points for each item.  Field "npr" contains a 1 X M cell array
          containing a row of P part indices (zero-based) for each
          Polyline, Polygon or MultiPatch part in the shape file; for
          multipatch each cell contains another row with the part types;
          for other item types (point etc.)  the cell array contains
          empty rows.  A separate field "shpbox" contains the overall
          bounding box X, Y and Z coordinates and min/max M-values in a
          4 X 2 double array.  If the shape file contains no Z or M
          values the corresponding columns are filled with NaNs.

          The struct field "fields" contains a cellstr array with names
          of the columns.  If a corresponding .dbf file was read, the
          struct array also contains a field for each attribute found in
          the .dbf file with the corresponding field name, each
          containing a 1 X M array of attribute values matching the M
          items in the .shp file.  These arrays can be double, char or
          logical, depending on the type found in the .dbf file.

     '3 (numeric)'
     'dat (case-insensitive)'
     'd'
          Same as OCT or 0 but without a row of NaN values between each
          shape file item in the VALS array.

     If a character option is given, just one character will suffice.
     The default for OUTSTYLE is "ml".

     The output of 'shaperead' can be influenced by property-value
     pairs.  The following properties are recognized (of which only the
     first three characters are significant, case doesn't matter):

     'Attributes'
          Normally all attributes associated with the shape features
          will be read and returned in the output struct(s).  To limit
          this to just some attributes, enter a value consisting of a
          cell array of attribute names to be read.  To have no
          attributes read at all, specify {}, an empty cell array.

     'BoundingBox'
          Select only those shape items (features) whose bounding box
          lies within, or intersets in at least one point with the
          limits of the BoundingBox value (a 2 X 2 double array [Minx,
          MinY; MaxX, MaxY]). No intersection or clipping with the
          BoundingBox value will be done by default!

     'Clip'
          (only useful in conjuction with the BoundingBox property) If a
          value of 1 or true is supplied, clip all shapes to the
          bounding box limits.  This option may take quite a bit of
          processing time.  If a value of "0" or false is given, do not
          perform clipping.  The default value is 0.  Clipping is merely
          meant to be performed in the XY plane.  Clipping 3D shapes is
          supported but may lead to unexpected results.  For Z and M
          type polylines and polygons including MultiPatch and
          Longitude/Latitude/Height types, Z (Height) and M values for
          each vertex in the clipped shape feature are simply copied
          over from the nearest vertex in the original shape feature.
          This implies that Z and M values of new vertices created on
          the bounding box edges may be less optimal.

          For clipping polylines and polygons the Octave-Forge geometry
          package needs to be installed and loaded.

     'Debug'
          If a value of 'true' or 1 is given, shaperead echoes the
          current record number while reading.  Can be useful for very
          big shapefiles.  The default value is 0 (no feedback).  If a
          Matlab-compatible output structarray is requested and the
          Bounding Box property is specified, the extracted shape
          feature indices are added to the field
          "___Shape_feature_nr___".

     'RecordNumbers'
          Select only those records whose numbers are listed as integer
          values in an array following RecordNumbers property.  Neither
          the size nor the class of the array matters as long as it is a
          numeric array.

     'UseGeoCoords'
          (Only applicable if a Matlab-style output struct is
          requested).  If a value of 'true' (or 1) is supplied, return a
          geostruct rather than a mapstruct.  If a value of 0 or false
          is given, return a mapstruct.  The mere difference is that in
          a geostruct the fields 'X' and 'Y' (and optionally 'Z') are
          replaced by 'Long' and 'Lat' (and 'Hght').  The default value
          is 'false' (return a mapstruct').

     Ref: http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf

     See also: geoshow, mapshow, shapedraw, shapeinfo.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Read an ArcGis shapefile set (shp, shx and dbf).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
shapewrite


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2333
 -- Function File: STATUS = shapewrite (SHPSTR, FNAME)
 -- Function File: STATUS = shapewrite (SHPSTR, FNAME, ATTS)
     Write contents of map- or geostruct to a GIS shape file.

     SHPSTR must be a valid mapstruct or geostruct, a struct array with
     an entry for each shape feature, with fields Geometry, BoundingBox,
     and X and Y (mapstruct) or Lat and Lon (geostruct).  For
     geostructs, Lat and Lon field data will be written as X and Y data.
     Field Geometry can have data values of "Point", "MultiPoint",
     "Line" or "Polygon", all case-insensitive.  For each shape feature,
     field BoundingBox should contain the minimum and maximum (X,Y)
     coordinates in a 2x2 array [minX, minY; maxX, maxY]. The X and Y
     fields should contain X (or Latitude) and Y (or Longitude)
     coordinates for each point or vertex as row vectors; for
     poly(lines) and polygons vertices of each subfeature (if present)
     should be separated by NaN entries.

     <Geometry>M or <Geometry>Z types (e.g., PointM, PolygonZ) can also
     be written; shapewrite.m just checks if fields "M" and/or "Z" are
     present in input mapstruct.

     FNAME should be a valid shape file name, optionally with a '.shp'
     suffix.

     Optional third input argument ATTS is one attribute name or a
     cellstr array containing a list of attribute names; only those
     attributes will be written to the .dbf file.  Alternatively a
     struct can be supplied with attibute names contained in field
     "FieldName" (preferrably camelcased as shown, but Octave treats
     this field's name as case-insensitive).  If argument ATTS is
     omitted all attributes will be written to the shapefile.

     shapewrite produces 3 files, i.e.  a .shp file (the actual shape
     file), a .shx file (index file), and a .dbf file (dBase type 3)
     with the contents of additional attribute fields other than
     Geometry, X/Y or Lat/Lon, M, Z, and BoundingBox.  If no additional
     attributes are present, a .dbf file is created with the shape
     feature numbers as contents of field "ID".

     Return argument STATUS is set to 1 if the complete shape file set
     was written successfully, to 0 otherwise.

     Ref: http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf

     See also: shapedraw, shapeinfo, shaperead.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Write contents of map- or geostruct to a GIS shape file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
sm2deg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 671
 -- Function File: DEG = sm2deg (SM)
 -- Function File: DEG = sm2deg (SM, RADIUS)
 -- Function File: DEG = sm2deg (SM, SPHERE)
     Converts distance to angle by dividing distance by radius.

     Calculates the angles DEG for the distances SM in a sphere with
     RADIUS (also in statute miles).  If unspecified, radius defaults to
     6371 km, the mean radius of Earth and is converted to statute miles
     internally.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object mean
     radius.

     See also: km2deg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Converts distance to angle by dividing distance by radius.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
sm2km


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 144
 -- Function File: sm2km (SM)
     Convert U.S. survey miles (statute miles) into kilometers.

     See also: km2nm, km2sm, nm2km, nm2sm, sm2nm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Convert U.S. survey miles (statute miles) into kilometers.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
sm2nm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 148
 -- Function File: sm2nm (SM)
     Convert U.S. survey miles (statute miles) into nautical miles.

     See also: km2nm, km2sm, nm2km, nm2sm, sm2km.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Convert U.S. survey miles (statute miles) into nautical miles.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
sm2rad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 671
 -- Function File: RAD = sm2rad (SM)
 -- Function File: RAD = sm2rad (SM, RADIUS)
 -- Function File: RAD = sm2rad (SM, SPHERE)
     Converts distance to angle by dividing distance by radius.

     Calculates the angles RAD for the distances SM in a sphere with
     RADIUS (also in statute miles).  If unspecified, radius defaults to
     6371 km, the mean radius of Earth and is converted to statute miles
     internally.

     Alternatively, SPHERE can be one of "sun", "mercury", "venus",
     "earth", "moon", "mars", "jupiter", "saturn", "uranus", "neptune",
     or "pluto", in which case radius will be set to that object mean
     radius.

     See also: km2rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Converts distance to angle by dividing distance by radius.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
toDegrees


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 435
 -- Function File: [DEG1, DEG2, ...] = toDegrees (FROMUNIT, A1, A2, ...)
     Convert angles into degrees.

     Converts any number of input arguments, A1, A2, ... with angles in
     FROMUNIT, into degrees.  FROMUNIT may be "radians" or "degrees".

          [deg1, deg2] = toDegrees ("radians", pi, [pi 2*pi])
          =>  [ 180 ]
          =>  [ 180  360 ]

     See also: fromDegrees, fromRadians, rad2deg, toRadians, unitsratio.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Convert angles into degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
toRadians


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 443
 -- Function File: [RAD1, RAD2, ...] = toRadians (TOUNIT, A1, A2, ...)
     Convert angles into radians.

     Converts any number of input arguments, A1, A2, ... with angles in
     FROMUNIT, into radians.  FROMUNIT may be "radians" or "degrees".

          [rad1, rad2] = toRadians ("degrees", 180, [180 360])
          =>  [ 3.1416 ]
          =>  [ 3.1416  6.2832 ]

     See also: deg2rad, fromDegrees, fromRadians, toDegrees, unitsratio.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Convert angles into radians.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
unitsratio


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 637
 -- Function File: unitsratio (TO, FROM)
     Return ratio for conversion between units.

     Returns the conversion ratio between two units, TO and FROM, so
     that:

          unitsratio ("meter", "centimeter")
          => 100

          unitsratio ("inch", "foot")
          => 12

     This allows for easy conversion between units, for example:

          unitsratio ("mile", "km") * 156
          =>96.93391

     For conversion between angle units, "degrees" and "radians" are
     supported.  For conversion between length units, supports units
     defined in 'validateLengthUnit'.

     See also: units, validateLengthUnit.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Return ratio for conversion between units.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
utmzone


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 661
 -- Function File: ZONE = utmzone (LAT , LONG)
 -- Function File: LATLON = utmzone (ZONE)
 -- Function File: LAT, LONG = utmzone (ZONE)
     Returns the zone given a latitude and longitude, or the latitude
     and longitude ranges given a zone.

     Examples:

          utmzone (43, -79)
          => ans =
          17T

     Can also handle the special zones of Norway

          utmzone (60, 5)
          => ans =
          32V

     For zones:

          utmzone ("17T")
          => ans =
           40   48
          -84  -78

          [lat, lon] = utmzone ("17T")
          =>
          lat =
             40   48
          lon =
            -84  -78


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Returns the zone given a latitude and longitude, or the latitude and
longitud...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
validateLengthUnit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1867
 -- Function File: validateLengthUnit (UNIT)
 -- Function File: validateLengthUnit (UNIT, IND)
 -- Function File: validateLengthUnit (UNIT, FUNC)
 -- Function File: validateLengthUnit (UNIT, FUNC, NAME)
 -- Function File: validateLengthUnit (UNIT, FUNC, NAME, IND)
     Check validity and standardize unit of length.

     Confirms that the argument INPUT is a valid length unit as
     described on the table below, and returns a string with its
     standard name.  If UNIT is not a valid length unit, throws an error
     with a message following the Octave guidelines.  For a more
     informative error message, the function name FUNC, the argument
     name NAME, and its position in the input IND can be defined.

     "meter"
          m, meter(s), metre(s)

     "centimeter"
          cm, centimeter(s), centimetre(s)

     "millimeter"
          mm, millimeter(s), millimetre(s)

     "micron"
          micron(s)

     "kilometer"
          km, kilometer(s), kilometre(s)

     "nautical mile"
          nm, naut mi, nautical mile(s)

     "foot"
          ft, international ft, foot, international foot, feet,
          international feet

     "inch"
          in, inch, inches

     "yard"
          yd, yds, yard(s)

     "mile"
          mi, mile(s), international mile(s)

     "U.S. survey foot"
          sf, survey ft, US survey ft, U.S. survey ft, survey foot, US
          survey foot, U.S. survey foot, survey feet, US survey feet,
          U.S. survey feet

     "U.S. survey mile (statute mile)"
          sm, survey mile(s), statute mile(s), US survey mile(s), U.S.
          survey mile(s)

     "Clarke's foot"
          Clarke's foot, Clarkes foot

     "German legal metre"
          German legal metre, German legal meter

     "Indian foot"
          Indian foot

     See also: units, unitsratio, validateattributes, validatestring.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Check validity and standardize unit of length.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
wgs84Ellipsoid


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1438
 -- Function File: wgs84Ellipsoid (UNIT)

     Returns the parameters of the wgs84 ellipsoid.  Argument UNIT is
     optional and if given, should be one of the units recognized by
     function validateLengthUnit().

     Example:
          >> E = wgs84Ellipsoid
          E =

           scalar structure containing the fields:

             Code =  7030
             Name = World Geodetic System 1984
             LengthUnit = meter
             SemimajorAxis =  6378137
             SemiminorAxis =    6.3568e+06
             InverseFlattening =  298.26
             Eccentricity =  0.081819
             Flattening =  0.0033528
             ThirdFlattening =  0.0016792
             MeanRadius =    6.3710e+06
             SurfaceArea =    5.1007e+14
             Volume =    1.0832e+21

     A unit argument is also accepted:
          >> E = wgs84Ellipsoid ("km")
          E =

           scalar structure containing the fields:

             Code =  7030
             Name = World Geodetic System 1984
             LengthUnit = km
             SemimajorAxis =  6378.1
             SemiminorAxis =  6356.8
             InverseFlattening =  298.26
             Eccentricity =  0.081819
             Flattening =  0.0033528
             ThirdFlattening =  0.0016792
             MeanRadius =  6371.0
             SurfaceArea =    5.1007e+08
             Volume =    1.0832e+12

     See also: referenceEllipsoid, validateLengthUnit.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Returns the parameters of the wgs84 ellipsoid.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
wrapTo180


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 585
 -- Function File: XWRAP = wrapTo180 (X)

     Wraps X into the [-180 to 180] interval.

     X: angle(s) in degrees (single value, vector or ND-matrix).

     XWRAP: output value(s) in the range [-180 ..  180] degrees.  The
     interval [-180 ..  180] is a closed interval: values equal to
     negative odd multiples of -180 are mapped to -180, values equal to
     an odd multiple of 180 are mapped to 180.

           wrapTo180 ([-181, -180, -50; 180, 200, 460])
           ans =
            179  -180   -50
            180  -160   100

     See also: unwrap, wrapToPi, wrapTo2Pi.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Wraps X into the [-180 to 180] interval.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
wrapTo2Pi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 646
 -- Function File: XWRAP = wrapTo2Pi (X)

     Wraps x into the [0 to 2pi] interval

     X: angle in radians (single value, vector or ND matrix).

     XWRAP: output value(s) in the range [0 ..  2*pi] radians.  The
     interval [0 ..  2*pi] is a closed interval: values equal to zero or
     negative even multiples of pi are mapped to 0, values equal to an
     even multiple of pi are mapped to 2*pi.

     Example:
          wrapTo2Pi ([-2*pi, -pi, 0, pi; 0.1, pi, 4*pi, 5*pi])
          ans =
            0.00000   3.14159   0.00000   3.14159
            0.10000   3.14159   6.28319   3.14159

     See also: wrapTo180, wrapTo360, wraptoPi.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Wraps x into the [0 to 2pi] interval



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
wrapTo360


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 594
 -- Function File: XWRAP = wrapTo360 (X)

     Wraps X into the [0 to 360] interval.

     X: angle(s) in degrees (single value, vector or ND matrix).

     XWRAP: output value(s) in the range [0 ..  360] degrees.  The
     interval [0 ..  360] is a closed interval: values equal to zero or
     negative even multiples of 360 are mapped to 0, values equal to an
     even multiple of 360 are mapped to 360.

     Example:
          wrapTo360 ([-720, -360, 0; 10, 360, 720])
          ans =
              0     0     0
             10   360   360

     See also: wrapTo180, wrapToPi, wrapTo2Pi.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Wraps X into the [0 to 360] interval.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
wrapToPi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 645
 -- Function File: XWRAP = wrapToPi (X)

     Wraps X into the [-pi to pi] interval

     X: angle(s) in radians (single value, vector or ND-matrix).

     XWRAP: output value(s) in the range [-pi ..  pi] radians.  The
     interval [-pi ..  pi] is a closed interval: values equal to
     negative odd multiples of -pi are mapped to -pi, values equal to an
     odd multiple of +pi are mapped to pi.

     Example:
          wrapToPi ([-3*pi, -pi, -pi-1, 0; pi-1, pi, pi+1, 3*pi])
          ans =
           -3.14159  -3.14159   2.14159   0.00000
            2.14159   3.14159  -2.14159   3.14159

     See also: wrapTo180, wrapTo360, wrapto2Pi.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Wraps X into the [-pi to pi] interval





