octave-mapping 1.2.1-1+b1 / usr / share / octave / packages / mapping-1.2.1 / doc-cache

# 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: 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: 6
deg2km


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


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



# 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).

     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: 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: 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: 7142
 -- 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: 1370
 -- 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: 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: 12
Convert U.S.



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



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