# doc-cache created by Octave 4.0.3
# name: cache
# type: cell
# rows: 3
# columns: 48
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
azimuth


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 786
 -- 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: 6
deg2km


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 584
 -- 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: km2deg.



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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 180
 -- 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: 10
degrees2dm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1160
 -- 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: 1277
 -- 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: 180
 -- 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: 797
 -- 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 the



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 561
 -- 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: 686
 -- 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: 12
extractfield


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 946
 -- 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, 1] => [ 1   2   3 ]
          [1, 2] => [ 4   5   6 ]

          s(1).field = "text";
          s(2).field = 1:3;
          extractfield (s, "field")
          [1, 1] => text
          [1, 2] => [ 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: 11
fromDegrees


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 444
 -- 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])
          a1=>  [ 3.1416 ]
          a2=>  [ 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: 434
 -- 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])
          a1=>  [ 180 ]
          a2=>  [ 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: 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: 6
km2deg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 584
 -- 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.



# 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: 127
 -- 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: 616
 -- 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: 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
km2sm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 146
 -- 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: 28
Convert kilometers into U.S.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3644
 -- 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: 3281
 -- 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: 6
nm2deg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 674
 -- 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: 127
 -- 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: 674
 -- 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: 150
 -- 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: 32
Convert nautical miles into U.S.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 180
 -- 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: 6
rad2km


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 618
 -- 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: km2rad.



# 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: 8
radtodeg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 180
 -- 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
rasterdraw


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1915
 -- 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: 303
 -- 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, raster 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 833
 -- 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).

     Outpur 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
reckon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 626
 -- 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: 24
removeExtraNanSeparators


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 594
 -- 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])
          x => [3 4 5 NaN 8 NaN]
          y => [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: 326
 -- 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: 2397
 -- 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: 945
 -- 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: 7155
 -- 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 gestruct 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):

    `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 may work to some extent but can lead to unpredictable
          results; this is especially true for MultiPatch shape types.
          For M and Z type polylines and polygons, the M and Z values
          are linearly interpolated for segments crossing the bounding
          box.  As no M and Z values can be computed for "new" corner
          nodes, NaN values are inserted there.  For clipping polylines
          and polygons the Octave-Forge geometry and octclip packages
          need 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' are replaced by 'Long' and
          'Lat'. The default value is 'false' (return a mapstruct').

     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: 1371
 -- Function File: STATUS = shapewrite (SHPSTR, FNAME)
     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 polylines and polygons vertices of each subfeature
     (if present) should be separated by NaN entries.

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

     shapewrite produces 2 or 3 files, i.e. a .shp file (the actual
     shape file), a .shx file (index file), and if SHPSTR contained
     additional fields, a .dbf file (dBase type 3) with the contents of
     those additional fields.

     STATUS is 1 if the shape file set was written successfully, 0
     otherwise.

     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: 672
 -- 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: 146
 -- 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: 12
Convert U.S.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
 -- 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: 12
Convert U.S.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 672
 -- 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: 445
 -- 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])
          deg1=>  [ 180 ]
          deg2=>  [ 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: 453
 -- 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])
          rad1=>  [ 3.1416 ]
          rad2=>  [ 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: 667
 -- 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")
          ratio => 100

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

     This allows for easy conversion between units, for example:

          unitsratio ("mile", "km") * 156
          156 km in miles =>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: 18
validateLengthUnit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1859
 -- 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: 9
wrapTo180


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 583
 -- 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: 644
 -- 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: 592
 -- 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: 643
 -- 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





