Fsharp.Gdal

Extimate walk time for routes stored in shape file

In this section I want to explore a gpx trace of a trekking I made on 10 April 2016 to one of the central Valgrande mountains named "Cima Sasso".

I want to calculate the actual duration and compare it with an extimated walk time based on trobbler's hiking function.

Then I will use the Gdal's function to access a shape file containing the foot paths to the main peaks in the Val Grande Natinal Parks and I will calculate an extimated time for all of them based on what I've learned from the gpx analysis.

I start loading the gpx file with the Xml Type Privider and see its content. To correctly instruct the provider I give a sample with two tracks two track segments for tracks and two points for each segments even if my gpx contains only one track with one track segments in it. I do this because in general a gpx can contain more then one of these elements.

1: 
2: 
3: 
4: 
5: 
6: 
7: 

type Gpx = XmlProvider<...>

let content = 
    use sr = new StreamReader (__SOURCE_DIRECTORY__ + "./data/10_04_2016 08_24_49_history.gpx")
    sr.ReadToEnd()

let gpx = Gpx.Parse(content)

The gpx sotres just one track named with the date I made the trecking:

1: 
2: 
3: 
4: 
5: 

let trackCounts = gpx.Trks.Length

let trackName = gpx.Trks.[0].Name

printfn "Number of tracks: %i\nTrack name: '%A'" trackCounts trackName

Number of tracks: 1
Track name: '10/04/2016 06:24:49'

The gpx can be converted in a linestring:

1: 
2: 
3: 
4: 
5: 
6: 

Configuration.Init() |> ignore

let line = new OGR.Geometry(OGR.wkbGeometryType.wkbLineString)

for trkpt in gpx.Trks.[0].Trksegs.[0].Trkpts do 
    line.AddPoint(trkpt.Lon |> float, trkpt.Lat |> float, trkpt.Ele |> float)

Gpx stores points in EPSG:4326 but is better to convert in EPSG:32632 to get lenghts in meters from gdal library

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 

// input SpatialReference
let inSpatialRef = new OSR.SpatialReference("")
inSpatialRef.ImportFromEPSG(4326)

// output SpatialReference
let outSpatialRef  = new OSR.SpatialReference("")
outSpatialRef.ImportFromEPSG(32632)

line.AssignSpatialReference(inSpatialRef)
let _ = line.TransformTo(outSpatialRef)

With the gpx track converted in a line string we can obtain its length with the Gdal's functions:

1: 

let length = line.Length()

11762.30269

And taking advantage of the function plot defined in Plot Geometries we can graphically visualize its shape:

1: 

line |> plot

The length of the path is an important variable to calculate an extimation of the walk time but anohter important variabile is its elevation profile.

Infact, normally a person walks at about 5 km/h in plain but the velocity decreases both ascending and descending on a steep path like the one in object.

It is usefull to extract the elevation profile of the track.

For this first we combine the distance from the start of the track with the current elevation

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 

let rec distanceElev (geom:OGR.Geometry) = 
    let mutable distance = 0.<m>
    let last = geom.GetPointCount() - 1
    [
        for i in 0..last ->
            let point = new OGR.Geometry(OGR.wkbGeometryType.wkbPoint)
            point.AddPoint(geom.GetX(i) |> float, geom.GetY(i) |> float, geom.GetZ(i) |> float)
            point.AssignSpatialReference(outSpatialRef)
            point
    ]
    |> List.pairwise
    |> List.map
        (
            fun (prev,curr) -> 
                distance <- distance + prev.Distance(curr) * 1.<m>
                distance,curr.GetZ(0) * 1.<m>
        )

and then we plot the tuples on a chart:

1: 
2: 

let xy = line |> distanceElev
Chart.Line([for (x,y) in xy -> (x, y)], "Elevation Profile")

So knowing the elevation of each point, how we can predict at which velocity a normal person will walk at each and the calculate the total time multiplying this velocity with the distance walked from the previous point?

Well an attempt to answer this question was given by Trobbler with its "hiking function":

1: 
2: 

let trobblersHikingFunction slope = 
    6. * Math.Exp(-3.5 * Math.Abs(slope + 0.05))

Trobbler's hiking function calculates an expected velocity based on the slope of the hiking and extimates a maximum velocity at 5% descendind slope which decreases for increasing slopes both descending or ascending.

We can plot the function to visualize its curve:

1: 

Chart.Line([for x in -70.0 .. 70.0 -> (x, (trobblersHikingFunction (x/100.)))])

I want to use this function and extract the following metrics for each point in the track: elevation, distance from previous point, total distance, slope, track time, duration from previous point, actual velocity, extimated velocity based on trobbler's hiking function.

The linestring is not really convenient because looses the information of the time associated to each track point and it does not give me fields to store every information.

So I define a more structured Data Type:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 

type Info = 
    {
        Geom : OGR.Geometry
        Distance : float<m>
        Slope : float
        TrackTime : System.DateTime
        ActualDuration : float<s>
        ActualVelocity : float<km/h>
        ExtimatedlVelocity : float<km/h>
        ExtimatedDuration : float<s>
    }

and populate a collection of elements of this type:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 

type Point = {Geom : Geometry; Time : DateTime}

let infos = 
    gpx.Trks.[0].Trksegs.[0].Trkpts
    |> List.ofArray
    |> List.map (fun trkpt -> 
            let point = new OGR.Geometry(OGR.wkbGeometryType.wkbPoint)
            point.AddPoint(trkpt.Lon |> float, trkpt.Lat |> float, trkpt.Ele |> float)
            point.AssignSpatialReference(inSpatialRef)
            let _ = point.TransformTo(outSpatialRef)
            {Geom = point; Time = trkpt.Time}
        )
    |> List.pairwise
    |> List.map
        (
            fun (prev,curr) -> 
                let dx = prev.Geom.Distance(curr.Geom) * 1.<m>
                let dh = (curr.Geom.GetZ(0) - prev.Geom.GetZ(0)) * 1.<m>
                let slope = dh/dx
                let duration = (curr.Time - prev.Time).TotalSeconds * 1.<s>
                let actualVelocity = dx / duration |> msToKmph
                let extimatedVel = 
                    let tobbler = trobblersHikingFunction slope
                    // floor the extimated velocity at no less then 1.0 km/h
                    let v = Math.Max(tobbler, 1.0)
                    v * 1.0<km/h>
                let extimatedDuration = dx / (extimatedVel |> kmphToMs)
                {
                    Geom                 = curr.Geom
                    Distance             = dx
                    Slope                = slope
                    TrackTime            = curr.Time
                    ActualDuration       = duration
                    ActualVelocity       = actualVelocity
                    ExtimatedlVelocity   = extimatedVel
                    ExtimatedDuration    = extimatedDuration
                }
        )

We can convert this in a frame to visualize the informations extracted:

1: 
2: 
3: 

let infosFrame = 
    infos
    |> Frame.ofRecords

Geom

Distance

Slope

...

ActualVelocity

ExtimatedlVelocity

ExtimatedDuration

0

OSGeo.OGR.Geometry

1,208

0,398

...

2,174

1,251

3,476

1

OSGeo.OGR.Geometry

3,743

0

...

4,492

5,037

2,676

2

OSGeo.OGR.Geometry

1,275

0,3769

...

0,9178

1,347

3,408

3

OSGeo.OGR.Geometry

5,622

0

...

5,059

5,037

4,018

4

OSGeo.OGR.Geometry

0,7925

-0,6062

...

0,4755

1

2,853

5

OSGeo.OGR.Geometry

1,541

0

...

5,548

5,037

1,101

6

OSGeo.OGR.Geometry

11,99

0,08016

...

5,396

3,805

11,35

7

OSGeo.OGR.Geometry

9,714

0

...

4,371

5,037

6,943

...

...

...

...

...

...

...

...

2769

OSGeo.OGR.Geometry

10,73

0,04481

...

4,828

4,306

8,97

2770

OSGeo.OGR.Geometry

7,7

0

...

4,62

5,037

5,503

2771

OSGeo.OGR.Geometry

8,556

0,1123

...

4,4

3,399

9,061

2772

OSGeo.OGR.Geometry

0,8972

1,071

...

0,8075

1

3,23

The Deedle frame provide us with functions, among the others, to aggregate the data and to see for example the total distance of the track:

1: 
2: 
3: 

let totalDistance = infosFrame?Distance.Sum()

printfn "TotalDistance = %f" totalDistance

TotalDistance = 11762.302687

The total length is still equivalent to that calculated for the linestring.

Let's plot the actual velocity for each point:

1: 

Chart.Point([for p in infos -> (p.Slope * 100., p.ActualVelocity)])

Slopes above 200% (descending or ascending) make the chart too confused so let's filter them out:

1: 

Chart.Point([for p in (infos |> List.where(fun x -> Math.Abs(x.Slope) < 2.)) -> (p.Slope * 100., p.ActualVelocity)])

It looks better and we can combine it with the plot of the trobbler's hiking function to see the correlation:

1: 
2: 
3: 
4: 
5: 

Chart.Combine
    [
        Chart.Point([for p in (infos |> List.where(fun x -> Math.Abs(x.Slope) < 2.)) -> (p.Slope * 100., p.ActualVelocity)])
        Chart.Line([ for x in -200.0 .. 200.0 -> (x, (trobblersHikingFunction (x/100.))) ])
    ]

Finally compare the actual duration with the extimated one and see that the extimation is really similar to the actual time of the track.

1: 
2: 
3: 
4: 

let actualDuration = infosFrame?ActualDuration.Sum() * 1.<s> * UM.secToHr
let extimatedDuration = infosFrame?ExtimatedDuration.Sum() * 1.<s> * UM.secToHr

printfn "Actual Duration = %f\nExtimated Duration = %f" actualDuration extimatedDuration

Actual Duration = 5.318333
Extimated Duration = 5.571914

To generlize the subject now I will calculate an extimated time for all the foot paths stored in a shape file.

The shapefile valgrandetrackscrosa_lenz.shp stores the paths to the valgrande peaks with the time extimated by the book "Valgrande National Park - Paths, history and nature" by Paolo Crosa Lenz. The time is probably calculated in an empirical way so will be a good term of comparison for our calculation.

To access the data I will use the OgrTypeProvider defined in FSharp.Gdal

1: 
2: 

let valgrandeTracks = new OgrTypeProvider<"G:/Data/valgrande_tracks_crosa_lenz.shp">()
let fmData = valgrandeTracks.Values |> Frame.ofValues

ID

CODE

SUBCODE

TITLE

TIME

Geometry

0

1

1

Cima Sasso

3,3

OSGeo.OGR.Geometry

1

4

4

Pizzo Proman

4,3

OSGeo.OGR.Geometry

2

2

2

b

Monte Faie

5

OSGeo.OGR.Geometry

3

3

3

Cima Corte Lorenzo

3

OSGeo.OGR.Geometry

4

5

5

Cima Saler

4,3

OSGeo.OGR.Geometry

5

6

6

Pizzo delle Pecore

4,3

OSGeo.OGR.Geometry

6

12

12

Cima Pedum

5,15

OSGeo.OGR.Geometry

7

7

7

Punta Pozzolo

5,3

OSGeo.OGR.Geometry

...

...

...

...

...

...

...

12

13

13

Cimone di Cortechiuso

4

OSGeo.OGR.Geometry

13

14

14

Monte Torrione

4,3

OSGeo.OGR.Geometry

14

15

15

La Piota

3,3

OSGeo.OGR.Geometry

15

16

16

b

Monte Zeda da Falmenta

4,3

OSGeo.OGR.Geometry

The geometries in this shape file don't store elevation so we'll get this information from a dem raster file:

1: 
2: 
3: 
4: 

let rDataset = Gdal.OpenShared(__SOURCE_DIRECTORY__ + @".\data\dem20_valg.tif", Access.GA_ReadOnly)

let mutable (geotransform:float[]) = [|0.;0.;0.;0.;0.;0.|]
rDataset.GetGeoTransform(geotransform)

The function extractMetrics below caluclates all the metrics we need in a way similar to that we used above to populate the infos collection from the gpx file but it also extracts from the dem file the elevation information with the FSharp.Gdal functions Raster.groundToImage and Raster.getImgValue. The return type of the function is a collection of PointMetrics (defined below) for each point in the linestrings of the paths:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52: 
53: 
54: 
55: 
56: 
57: 
58: 

type PointMetrics = 
    { 
        Point:Geometry; 
        Elev:float; 
        Distance:float; 
        Slope:float; 
        ExtimatedForwardVelocity:float<km/h>;
        ExtimatedForwardTime:float<s>;
        ExtimatedReverseVelocity:float<km/h>;
        ExtimatedReverseTime:float<s>; 
    }

let extractMetrics (geom:OGR.Geometry) = 
    geom
    |> Vector.points
    |> List.map 
        (
            fun (p) -> 
                let x,y = (p.GetX(0), p.GetY(0))
                let elev = 
                    (x,y)
                    |> Raster.groundToImage geotransform
                    |> Raster.getImgValue geotransform rDataset
                match elev with
                | Some(e) -> (p, e)
                | None -> (p, 0.)
        )
    |> List.pairwise
    |> List.map 
        (
            fun ((prevPoint,prevElev),(currPoint,currElev)) -> 
                let dx = currPoint.Distance(prevPoint)
                let dh = currElev - prevElev
                let slope = dh/dx
                // tobbler's hiking function
                let tobbler slope = (6. * Math.Exp(-3.5 * Math.Abs(slope + 0.05))) 
                let extimatedForwardVel = 
                    // floor the extimated velocity at 1.0 km/h as 
                    // I saw from the experiments with gpx that works
                    let v = Math.Max(tobbler slope, 1.0)  
                    v * 1.0<km/h>
                let extimatedReverseVel = 
                    // floor the extimated velocity at 1.0 km/h
                    let v = Math.Max(tobbler -slope, 1.0)  
                    v * 1.0<km/h>
                let extimatedForwardTime = (dx * 1.0<m>) / (extimatedForwardVel |> kmphToMs)
                let extimatedReversTime = (dx * 1.0<m>) / (extimatedReverseVel |> kmphToMs)
                { 
                    Point = currPoint; 
                    Elev = currElev; 
                    Distance = dx; 
                    Slope = slope; 
                    ExtimatedForwardVelocity = extimatedForwardVel;
                    ExtimatedForwardTime = extimatedForwardTime; 
                    ExtimatedReverseVelocity = extimatedReverseVel;
                    ExtimatedReverseTime = extimatedReversTime; 
                }
        )

sumTime aggregates the extimated elapsed forward time of each point to finally calculate the total extimated time given a collection of PointMetrics

1: 
2: 
3: 
4: 
5: 
6: 
7: 

let sumTime trackMetrics = 
    let value = 
        (
            trackMetrics
            |> List.fold (fun acc rc -> acc + rc.ExtimatedForwardTime) 0.<s>
        ) * secToHr / 1.<h>
    Math.Round(value, 2)

Given theese functions we can populate a new deedle frame with our extimated time:

1: 
2: 
3: 
4: 
5: 
6: 
7: 

let fmMyExtimatedTime = 
    valgrandeTracks.Features
    |> Seq.mapi (fun i feat -> 
        i, 
        "MYTIME", 
        (feat.Geometry |> extractMetrics |> sumTime))
    |> Frame.ofValues

MYTIME

0

2,78

1

4,27

2

5,35

3

2,49

4

2,11

5

3,58

6

3,94

7

3,77

...

...

12

3,76

13

3,46

14

2,43

15

3,49

and join the two frames to compare the values calculating a delta percentage:

1: 
2: 
3: 
4: 
5: 

let fmWithExtimatedTime = fmData.Join(fmMyExtimatedTime)

fmWithExtimatedTime?``Delta %`` <- 
    let delta = (fmWithExtimatedTime?MYTIME - fmWithExtimatedTime?TIME) / fmWithExtimatedTime?TIME * 100.
    delta |> Series.map(fun k v -> Math.Round(v))

ID

CODE

SUBCODE

...

Geometry

MYTIME

Delta %

0

1

1

...

OSGeo.OGR.Geometry

2,78

-16

1

4

4

...

OSGeo.OGR.Geometry

4,27

-1

2

2

2

b

...

OSGeo.OGR.Geometry

5,35

7

3

3

3

...

OSGeo.OGR.Geometry

2,49

-17

4

5

5

...

OSGeo.OGR.Geometry

2,11

-51

5

6

6

...

OSGeo.OGR.Geometry

3,58

-17

6

12

12

...

OSGeo.OGR.Geometry

3,94

-23

7

7

7

...

OSGeo.OGR.Geometry

3,77

-29

...

...

...

...

...

...

...

...

12

13

13

...

OSGeo.OGR.Geometry

3,76

-6

13

14

14

...

OSGeo.OGR.Geometry

3,46

-20

14

15

15

...

OSGeo.OGR.Geometry

2,43

-26

15

16

16

b

...

OSGeo.OGR.Geometry

3,49

-19

 
1: 

let avgDelta = fmWithExtimatedTime.Sum()?``Delta %`` / 16.

-19.8125

The worst result is on "Cima Saler" track: my extimation is half of that reported by the book and should be investigated. Anyway the other results seem good enough: my extimation is just about 20% more optimistic than the empirical one.

namespace System
namespace System.Collections
namespace System.Collections.Generic
namespace System.IO
namespace System.Xml
namespace System.Xml.Linq
namespace Deedle
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
Multiple items
namespace FSharp.Data

--------------------
namespace Microsoft.FSharp.Data
namespace FSharp.Charting
namespace OSGeo
namespace OSGeo.OGR
namespace OSGeo.GDAL
namespace OSGeo.OSR
namespace FSharp.Gdal
module UM

from FSharp.Gdal
type Gpx = XmlProvider<...>

Full name: Extimated-walk-time.Gpx
XmlProvider<"""<?xml version="1.0" encoding="utf-8"?><gpx xmlns:tc2="http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tp1="http://www.garmin.com/xmlschemas/TrackPointExtension/v1" xmlns="http://www.topografix.com/GPX/1/1" version="1.1" creator="TC2 to GPX11 XSLT stylesheet" xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd http://www.garmin.com/xmlschemas/TrackPointExtension/v1 http://www.garmin.com/xmlschemas/TrackPointExtensionv1.xsd"><trk><name>2016-04-10T06:24:49Z</name><trkseg><trkpt lat="46.0030837" lon="8.4914856"><ele>734.5847168</ele><time>2016-04-10T06:24:49Z</time></trkpt><trkpt lat="46.0030837" lon="8.4914856"><ele>734.5847168</ele><time>2016-04-10T06:24:49Z</time></trkpt></trkseg><trkseg><trkpt lat="46.0030837" lon="8.4914856"><ele>734.5847168</ele><time>2016-04-10T06:24:49Z</time></trkpt><trkpt lat="46.0030837" lon="8.4914856"><ele>734.5847168</ele><time>2016-04-10T06:24:49Z</time></trkpt></trkseg></trk><trk><name>2016-04-10T06:24:49Z</name><trkseg><trkpt lat="46.0030837" lon="8.4914856"><ele>734.5847168</ele><time>2016-04-10T06:24:49Z</time></trkpt><trkpt lat="46.0030837" lon="8.4914856"><ele>734.5847168</ele><time>2016-04-10T06:24:49Z</time></trkpt></trkseg><trkseg><trkpt lat="46.0030837" lon="8.4914856"><ele>734.5847168</ele><time>2016-04-10T06:24:49Z</time></trkpt><trkpt lat="46.0030837" lon="8.4914856"><ele>734.5847168</ele><time>2016-04-10T06:24:49Z</time></trkpt></trkseg></trk></gpx>""">
val content : string

Full name: Extimated-walk-time.content
val sr : StreamReader
Multiple items
type StreamReader =
  inherit TextReader
  new : stream:Stream -> StreamReader + 9 overloads
  member BaseStream : Stream
  member Close : unit -> unit
  member CurrentEncoding : Encoding
  member DiscardBufferedData : unit -> unit
  member EndOfStream : bool
  member Peek : unit -> int
  member Read : unit -> int + 1 overload
  member ReadLine : unit -> string
  member ReadToEnd : unit -> string
  ...

Full name: System.IO.StreamReader

--------------------
StreamReader(stream: Stream) : unit
StreamReader(path: string) : unit
StreamReader(stream: Stream, detectEncodingFromByteOrderMarks: bool) : unit
StreamReader(stream: Stream, encoding: Text.Encoding) : unit
StreamReader(path: string, detectEncodingFromByteOrderMarks: bool) : unit
StreamReader(path: string, encoding: Text.Encoding) : unit
StreamReader(stream: Stream, encoding: Text.Encoding, detectEncodingFromByteOrderMarks: bool) : unit
StreamReader(path: string, encoding: Text.Encoding, detectEncodingFromByteOrderMarks: bool) : unit
StreamReader(stream: Stream, encoding: Text.Encoding, detectEncodingFromByteOrderMarks: bool, bufferSize: int) : unit
StreamReader(path: string, encoding: Text.Encoding, detectEncodingFromByteOrderMarks: bool, bufferSize: int) : unit
StreamReader.ReadToEnd() : string
val gpx : XmlProvider<...>.Gpx

Full name: Extimated-walk-time.gpx
XmlProvider<...>.Parse(text: string) : XmlProvider<...>.Gpx


Parses the specified XML string
val trackCounts : int

Full name: Extimated-walk-time.trackCounts
property XmlProvider<...>.Gpx.Trks: XmlProvider<...>.Trk []
property Array.Length: int
val trackName : DateTime

Full name: Extimated-walk-time.trackName
val printfn : format:Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn
Multiple items
module Configuration

from FSharp.Gdal

--------------------
namespace System.Configuration
val Init : unit -> unit

Full name: FSharp.Gdal.Configuration.Init
val ignore : value:'T -> unit

Full name: Microsoft.FSharp.Core.Operators.ignore
val line : Geometry

Full name: Extimated-walk-time.line
Multiple items
type Geometry =
  new : type:wkbGeometryType -> Geometry + 2 overloads
  member AddGeometry : other:Geometry -> int
  member AddGeometryDirectly : other_disown:Geometry -> int
  member AddPoint : x:float * y:float * z:float -> unit
  member AddPoint_2D : x:float * y:float -> unit
  member Area : unit -> float
  member AssignSpatialReference : reference:SpatialReference -> unit
  member Boundary : unit -> Geometry
  member Buffer : distance:float * quadsecs:int -> Geometry
  member Centroid : unit -> Geometry
  ...

Full name: OSGeo.OGR.Geometry

--------------------
Geometry(type: wkbGeometryType) : unit
Geometry(cPtr: nativeint, cMemoryOwn: bool, parent: obj) : unit
Geometry(type: wkbGeometryType, wkt: string, wkb: int, wkb_buf: nativeint, gml: string) : unit
type wkbGeometryType =
  | wkbUnknown = 0
  | wkbPoint = 1
  | wkbLineString = 2
  | wkbPolygon = 3
  | wkbMultiPoint = 4
  | wkbMultiLineString = 5
  | wkbMultiPolygon = 6
  | wkbGeometryCollection = 7
  | wkbNone = 100
  | wkbLinearRing = 101
  ...

Full name: OSGeo.OGR.wkbGeometryType
field wkbGeometryType.wkbLineString = 2
val trkpt : XmlProvider<...>.Trkpt
Geometry.AddPoint(x: float, y: float, z: float) : unit
property XmlProvider<...>.Trkpt.Lon: decimal
Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------
type float = Double

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>
property XmlProvider<...>.Trkpt.Lat: decimal
property XmlProvider<...>.Trkpt.Ele: decimal
val inSpatialRef : SpatialReference

Full name: Extimated-walk-time.inSpatialRef
Multiple items
type SpatialReference =
  new : wkt:string -> SpatialReference + 1 overload
  member AutoIdentifyEPSG : unit -> int
  member Clone : unit -> SpatialReference
  member CloneGeogCS : unit -> SpatialReference
  member CopyGeogCSFrom : rhs:SpatialReference -> int
  member Dispose : unit -> unit
  member EPSGTreatsAsLatLong : unit -> int
  member EPSGTreatsAsNorthingEasting : unit -> int
  member ExportToMICoordSys : argout:string -> int
  member ExportToPCI : proj:string * units:string -> int
  ...

Full name: OSGeo.OSR.SpatialReference

--------------------
SpatialReference(wkt: string) : unit
SpatialReference(cPtr: nativeint, cMemoryOwn: bool, parent: obj) : unit
SpatialReference.ImportFromEPSG(arg: int) : int
val outSpatialRef : SpatialReference

Full name: Extimated-walk-time.outSpatialRef
Geometry.AssignSpatialReference(reference: SpatialReference) : unit
Geometry.TransformTo(reference: SpatialReference) : int
val length : float

Full name: Extimated-walk-time.length
Geometry.Length() : float
val plot : g:Geometry -> ChartTypes.GenericChart

Full name: Plot-geometries.plot


 Plots a geometry at a zoom of 80%
val distanceElev : geom:Geometry -> (float<m> * float<m>) list

Full name: Extimated-walk-time.distanceElev
val geom : Geometry
val mutable distance : float<m>
[<Measure>]
type m

Full name: FSharp.Gdal.UM.m
val last : int
Geometry.GetPointCount() : int
val i : int
val point : Geometry
field wkbGeometryType.wkbPoint = 1
Geometry.GetX(point: int) : float
Geometry.GetY(point: int) : float
Geometry.GetZ(point: int) : float
Multiple items
type List<'T> =
  new : unit -> List<'T> + 2 overloads
  member Add : item:'T -> unit
  member AddRange : collection:IEnumerable<'T> -> unit
  member AsReadOnly : unit -> ReadOnlyCollection<'T>
  member BinarySearch : item:'T -> int + 2 overloads
  member Capacity : int with get, set
  member Clear : unit -> unit
  member Contains : item:'T -> bool
  member ConvertAll<'TOutput> : converter:Converter<'T, 'TOutput> -> List<'TOutput>
  member CopyTo : array:'T[] -> unit + 2 overloads
  ...
  nested type Enumerator

Full name: System.Collections.Generic.List<_>

--------------------
List() : unit
List(capacity: int) : unit
List(collection: IEnumerable<'T>) : unit
val pairwise : list:'T list -> ('T * 'T) list

Full name: Microsoft.FSharp.Collections.List.pairwise
val map : mapping:('T -> 'U) -> list:'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.map
val prev : Geometry
val curr : Geometry
Geometry.Distance(other: Geometry) : float
val xy : (float<m> * float<m>) list

Full name: Extimated-walk-time.xy
type Chart =
  static member Area : data:seq<#value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> GenericChart
  static member Area : data:seq<#key * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> GenericChart
  static member Bar : data:seq<#value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> GenericChart
  static member Bar : data:seq<#key * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> GenericChart
  static member BoxPlotFromData : data:seq<#key * #seq<'a2>> * ?Name:string * ?Title:string * ?Color:Color * ?XTitle:string * ?YTitle:string * ?Percentile:int * ?ShowAverage:bool * ?ShowMedian:bool * ?ShowUnusualValues:bool * ?WhiskerPercentile:int -> GenericChart (requires 'a2 :> value)
  static member BoxPlotFromStatistics : data:seq<#key * #value * #value * #value * #value * #value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string * ?Percentile:int * ?ShowAverage:bool * ?ShowMedian:bool * ?ShowUnusualValues:bool * ?WhiskerPercentile:int -> GenericChart
  static member Bubble : data:seq<#value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string * ?BubbleMaxSize:int * ?BubbleMinSize:int * ?BubbleScaleMax:float * ?BubbleScaleMin:float * ?UseSizeForLabel:bool -> GenericChart
  static member Bubble : data:seq<#key * #value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string * ?BubbleMaxSize:int * ?BubbleMinSize:int * ?BubbleScaleMax:float * ?BubbleScaleMin:float * ?UseSizeForLabel:bool -> GenericChart
  static member Candlestick : data:seq<#value * #value * #value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> CandlestickChart
  static member Candlestick : data:seq<#key * #value * #value * #value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> CandlestickChart
  ...

Full name: FSharp.Charting.Chart
static member Chart.Line : data:Series<'K,#value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Drawing.Color * ?XTitle:string * ?YTitle:string -> ChartTypes.GenericChart (requires equality and 'K :> key)
static member Chart.Line : data:seq<#value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Drawing.Color * ?XTitle:string * ?YTitle:string -> ChartTypes.GenericChart
static member Chart.Line : data:seq<#key * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Drawing.Color * ?XTitle:string * ?YTitle:string -> ChartTypes.GenericChart
val x : float<m>
val y : float<m>
val trobblersHikingFunction : slope:float -> float

Full name: Extimated-walk-time.trobblersHikingFunction
val slope : float
type Math =
  static val PI : float
  static val E : float
  static member Abs : value:sbyte -> sbyte + 6 overloads
  static member Acos : d:float -> float
  static member Asin : d:float -> float
  static member Atan : d:float -> float
  static member Atan2 : y:float * x:float -> float
  static member BigMul : a:int * b:int -> int64
  static member Ceiling : d:decimal -> decimal + 1 overload
  static member Cos : d:float -> float
  ...

Full name: System.Math
Math.Exp(d: float) : float
Math.Abs(value: decimal) : decimal
Math.Abs(value: float) : float
Math.Abs(value: float32) : float32
Math.Abs(value: int64) : int64
Math.Abs(value: int) : int
Math.Abs(value: int16) : int16
Math.Abs(value: sbyte) : sbyte
val x : float
type Info =
  {Geom: Geometry;
   Distance: float<m>;
   Slope: float;
   TrackTime: DateTime;
   ActualDuration: float<s>;
   ActualVelocity: float<km/h>;
   ExtimatedlVelocity: float<km/h>;
   ExtimatedDuration: float<s>;}

Full name: Extimated-walk-time.Info
Info.Geom: Geometry
Info.Distance: float<m>
Info.Slope: float
Info.TrackTime: DateTime
Multiple items
type DateTime =
  struct
    new : ticks:int64 -> DateTime + 10 overloads
    member Add : value:TimeSpan -> DateTime
    member AddDays : value:float -> DateTime
    member AddHours : value:float -> DateTime
    member AddMilliseconds : value:float -> DateTime
    member AddMinutes : value:float -> DateTime
    member AddMonths : months:int -> DateTime
    member AddSeconds : value:float -> DateTime
    member AddTicks : value:int64 -> DateTime
    member AddYears : value:int -> DateTime
    ...
  end

Full name: System.DateTime

--------------------
DateTime()
   (+0 other overloads)
DateTime(ticks: int64) : unit
   (+0 other overloads)
DateTime(ticks: int64, kind: DateTimeKind) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, kind: DateTimeKind) : unit
   (+0 other overloads)
Info.ActualDuration: float<s>
[<Measure>]
type s

Full name: FSharp.Gdal.UM.s
Info.ActualVelocity: float<km/h>
[<Measure>]
type km

Full name: FSharp.Gdal.UM.km
[<Measure>]
type h

Full name: FSharp.Gdal.UM.h
Info.ExtimatedlVelocity: float<km/h>
Info.ExtimatedDuration: float<s>
type Point =
  {Geom: Geometry;
   Time: DateTime;}

Full name: Extimated-walk-time.Point
Point.Geom: Geometry
Point.Time: DateTime
val infos : Info list

Full name: Extimated-walk-time.infos
val ofArray : array:'T [] -> 'T list

Full name: Microsoft.FSharp.Collections.List.ofArray
property XmlProvider<...>.Trkpt.Time: DateTime
val prev : Point
val curr : Point
val dx : float<m>
val dh : float<m>
val duration : float<s>
val actualVelocity : float<km/h>
val msToKmph : speed:float<m/s> -> float<km/h>

Full name: FSharp.Gdal.UM.msToKmph
val extimatedVel : float<km/h>
val tobbler : float
val v : float
Math.Max(val1: decimal, val2: decimal) : decimal
   (+0 other overloads)
Math.Max(val1: float, val2: float) : float
   (+0 other overloads)
Math.Max(val1: float32, val2: float32) : float32
   (+0 other overloads)
Math.Max(val1: uint64, val2: uint64) : uint64
   (+0 other overloads)
Math.Max(val1: int64, val2: int64) : int64
   (+0 other overloads)
Math.Max(val1: uint32, val2: uint32) : uint32
   (+0 other overloads)
Math.Max(val1: int, val2: int) : int
   (+0 other overloads)
Math.Max(val1: uint16, val2: uint16) : uint16
   (+0 other overloads)
Math.Max(val1: int16, val2: int16) : int16
   (+0 other overloads)
Math.Max(val1: byte, val2: byte) : byte
   (+0 other overloads)
val extimatedDuration : float<s>
val kmphToMs : speed:float<km/h> -> float<m/s>

Full name: FSharp.Gdal.UM.kmphToMs
val infosFrame : Frame<int,string>

Full name: Extimated-walk-time.infosFrame
Multiple items
module Frame

from Deedle

--------------------
type Frame =
  static member ReadReader : reader:IDataReader -> Frame<int,string>
  static member CustomExpanders : Dictionary<Type,Func<obj,seq<string * Type * obj>>>
  static member NonExpandableInterfaces : List<Type>
  static member NonExpandableTypes : HashSet<Type>

Full name: Deedle.Frame

--------------------
type Frame<'TRowKey,'TColumnKey (requires equality and equality)> =
  interface IDynamicMetaObjectProvider
  interface INotifyCollectionChanged
  interface IFsiFormattable
  interface IFrame
  new : names:seq<'TColumnKey> * columns:seq<ISeries<'TRowKey>> -> Frame<'TRowKey,'TColumnKey>
  new : rowIndex:IIndex<'TRowKey> * columnIndex:IIndex<'TColumnKey> * data:IVector<IVector> * indexBuilder:IIndexBuilder * vectorBuilder:IVectorBuilder -> Frame<'TRowKey,'TColumnKey>
  member AddColumn : column:'TColumnKey * series:ISeries<'TRowKey> -> unit
  member AddColumn : column:'TColumnKey * series:seq<'V> -> unit
  member AddColumn : column:'TColumnKey * series:ISeries<'TRowKey> * lookup:Lookup -> unit
  member AddColumn : column:'TColumnKey * series:seq<'V> * lookup:Lookup -> unit
  ...

Full name: Deedle.Frame<_,_>

--------------------
new : names:seq<'TColumnKey> * columns:seq<ISeries<'TRowKey>> -> Frame<'TRowKey,'TColumnKey>
new : rowIndex:Indices.IIndex<'TRowKey> * columnIndex:Indices.IIndex<'TColumnKey> * data:IVector<IVector> * indexBuilder:Indices.IIndexBuilder * vectorBuilder:Vectors.IVectorBuilder -> Frame<'TRowKey,'TColumnKey>
static member Frame.ofRecords : series:Series<'K,'R> -> Frame<'K,string> (requires equality)
static member Frame.ofRecords : values:seq<'T> -> Frame<int,string>
static member Frame.ofRecords : values:IEnumerable * indexCol:string -> Frame<'R,string> (requires equality)
val totalDistance : float

Full name: Extimated-walk-time.totalDistance
static member Chart.Point : data:seq<#value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Drawing.Color * ?XTitle:string * ?YTitle:string * ?MarkerColor:Drawing.Color * ?MarkerSize:int -> ChartTypes.GenericChart
static member Chart.Point : data:seq<#key * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Drawing.Color * ?XTitle:string * ?YTitle:string * ?MarkerColor:Drawing.Color * ?MarkerSize:int -> ChartTypes.GenericChart
val p : Info
val where : predicate:('T -> bool) -> list:'T list -> 'T list

Full name: Microsoft.FSharp.Collections.List.where
val x : Info
static member Chart.Combine : charts:seq<ChartTypes.GenericChart> -> ChartTypes.GenericChart
val actualDuration : float<h>

Full name: Extimated-walk-time.actualDuration
val secToHr : float<h/s>

Full name: FSharp.Gdal.UM.secToHr
val extimatedDuration : float<h>

Full name: Extimated-walk-time.extimatedDuration
val valgrandeTracks : OgrTypeProvider<...>

Full name: Extimated-walk-time.valgrandeTracks
type OgrTypeProvider

Full name: FSharp.Gdal.OgrTypeProvider
val fmData : Frame<int,string>

Full name: Extimated-walk-time.fmData
property OgrTypeProvider<...>.Values: List<int * string * obj>
static member Frame.ofValues : values:seq<'R * 'C * 'V> -> Frame<'R,'C> (requires equality and equality)
val rDataset : Dataset

Full name: Extimated-walk-time.rDataset
Multiple items
type Gdal =
  new : unit -> Gdal
  static member AllRegister : unit -> unit
  static member ApplyGeoTransform : padfGeoTransform:float[] * dfPixel:float * dfLine:float * pdfGeoX:float * pdfGeoY:float -> unit
  static member AutoCreateWarpedVRT : src_ds:Dataset * src_wkt:string * dst_wkt:string * eResampleAlg:ResampleAlg * maxerror:float -> Dataset
  static member CPLBinaryToHex : nBytes:int * pabyData:nativeint -> string
  static member CPLHexToBinary : pszHex:string * pnBytes:int -> nativeint
  static member ComputeMedianCutPCT : red:Band * green:Band * blue:Band * num_colors:int * colors:ColorTable * callback:GDALProgressFuncDelegate * callback_data:string -> int
  static member ComputeProximity : srcBand:Band * proximityBand:Band * options:string[] * callback:GDALProgressFuncDelegate * callback_data:string -> int
  static member ContourGenerate : srcBand:Band * contourInterval:float * contourBase:float * fixedLevelCount:int * fixedLevels:float[] * useNoData:int * noDataValue:float * dstLayer:Layer * idField:int * elevField:int * callback:GDALProgressFuncDelegate * callback_data:string -> int
  static member DataTypeIsComplex : eDataType:DataType -> int
  ...
  nested type GDALErrorHandlerDelegate
  nested type GDALProgressFuncDelegate

Full name: OSGeo.GDAL.Gdal

--------------------
Gdal() : unit
Gdal.OpenShared(utf8_path: string, eAccess: Access) : Dataset
type Access =
  | GA_ReadOnly = 0
  | GA_Update = 1

Full name: OSGeo.GDAL.Access
field Access.GA_ReadOnly = 0
val mutable geotransform : float []

Full name: Extimated-walk-time.geotransform
Dataset.GetGeoTransform(argout: float []) : unit
type PointMetrics =
  {Point: Geometry;
   Elev: float;
   Distance: float;
   Slope: float;
   ExtimatedForwardVelocity: float<km/h>;
   ExtimatedForwardTime: float<s>;
   ExtimatedReverseVelocity: float<km/h>;
   ExtimatedReverseTime: float<s>;}

Full name: Extimated-walk-time.PointMetrics
Multiple items
PointMetrics.Point: Geometry

--------------------
type Point =
  {Geom: Geometry;
   Time: DateTime;}

Full name: Extimated-walk-time.Point
PointMetrics.Elev: float
PointMetrics.Distance: float
PointMetrics.Slope: float
PointMetrics.ExtimatedForwardVelocity: float<km/h>
PointMetrics.ExtimatedForwardTime: float<s>
PointMetrics.ExtimatedReverseVelocity: float<km/h>
PointMetrics.ExtimatedReverseTime: float<s>
val extractMetrics : geom:Geometry -> PointMetrics list

Full name: Extimated-walk-time.extractMetrics
Multiple items
module Vector

from FSharp.Gdal

--------------------
type Vector =
  static member ofOptionalValues : data:seq<OptionalValue<'T>> -> IVector<'T>
  static member ofOptionalValues : data:seq<'T option> -> IVector<'T>
  static member ofValues : data:seq<'T> -> IVector<'T>
  static member ofValues : data:'T [] -> IVector<'T>

Full name: Deedle.F# Vector extensions.Vector
val points : geom:Geometry -> Geometry list

Full name: FSharp.Gdal.Vector.points
val p : Geometry
val y : float
val elev : float option
module Raster

from FSharp.Gdal
val groundToImage : geotransform:float [] -> x:float * y:float -> int * int

Full name: FSharp.Gdal.Raster.groundToImage
val getImgValue : geotransform:float [] -> dataset:Dataset -> xPixel:int * yLine:int -> float option

Full name: FSharp.Gdal.Raster.getImgValue
union case Option.Some: Value: 'T -> Option<'T>
val e : float
union case Option.None: Option<'T>
val prevPoint : Geometry
val prevElev : float
val currPoint : Geometry
val currElev : float
val dx : float
val dh : float
val tobbler : (float -> float)
val extimatedForwardVel : float<km/h>
val extimatedReverseVel : float<km/h>
val extimatedForwardTime : float<s>
val extimatedReversTime : float<s>
val sumTime : trackMetrics:PointMetrics list -> float

Full name: Extimated-walk-time.sumTime
val trackMetrics : PointMetrics list
Multiple items
val value : float

--------------------
type value = IConvertible

Full name: FSharp.Charting.value
val fold : folder:('State -> 'T -> 'State) -> state:'State -> list:'T list -> 'State

Full name: Microsoft.FSharp.Collections.List.fold
val acc : float<s>
val rc : PointMetrics
Math.Round(d: decimal) : decimal
Math.Round(a: float) : float
Math.Round(d: decimal, mode: MidpointRounding) : decimal
Math.Round(d: decimal, decimals: int) : decimal
Math.Round(value: float, mode: MidpointRounding) : float
Math.Round(value: float, digits: int) : float
Math.Round(d: decimal, decimals: int, mode: MidpointRounding) : decimal
Math.Round(value: float, digits: int, mode: MidpointRounding) : float
val fmMyExtimatedTime : Frame<int,string>

Full name: Extimated-walk-time.fmMyExtimatedTime
property OgrTypeProvider<...>.Features: IEnumerable<OgrTypeProvider<...>.Feature>
module Seq

from Microsoft.FSharp.Collections
val mapi : mapping:(int -> 'T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.mapi
val feat : OgrTypeProvider<...>.Feature
property OgrTypeProvider<...>.Feature.Geometry: Geometry
val fmWithExtimatedTime : Frame<int,string>

Full name: Extimated-walk-time.fmWithExtimatedTime
member Frame.Join : otherFrame:Frame<'TRowKey,'TColumnKey> -> Frame<'TRowKey,'TColumnKey>
member Frame.Join : colKey:'TColumnKey * series:Series<'TRowKey,'V> -> Frame<'TRowKey,'TColumnKey>
member Frame.Join : otherFrame:Frame<'TRowKey,'TColumnKey> * kind:JoinKind -> Frame<'TRowKey,'TColumnKey>
member Frame.Join : colKey:'TColumnKey * series:Series<'TRowKey,'V> * kind:JoinKind -> Frame<'TRowKey,'TColumnKey>
member Frame.Join : otherFrame:Frame<'TRowKey,'TColumnKey> * kind:JoinKind * lookup:Lookup -> Frame<'TRowKey,'TColumnKey>
member Frame.Join : colKey:'TColumnKey * series:Series<'TRowKey,'V> * kind:JoinKind * lookup:Lookup -> Frame<'TRowKey,'TColumnKey>
val delta : Series<int,float>
Multiple items
module Series

from Deedle

--------------------
type Series =
  static member ofNullables : values:seq<Nullable<'a0>> -> Series<int,'a0> (requires default constructor and value type and 'a0 :> ValueType)
  static member ofObservations : observations:seq<'a0 * 'a1> -> Series<'a0,'a1> (requires equality)
  static member ofOptionalObservations : observations:seq<'K * 'a1 option> -> Series<'K,'a1> (requires equality)
  static member ofValues : values:seq<'b> -> Series<int,'b>

Full name: Deedle.F# Series extensions.Series

--------------------
type Series<'K,'V (requires equality)> =
  interface IFsiFormattable
  interface ISeries<'K>
  new : pairs:seq<KeyValuePair<'K,'V>> -> Series<'K,'V>
  new : keys:'K [] * values:'V [] -> Series<'K,'V>
  new : keys:seq<'K> * values:seq<'V> -> Series<'K,'V>
  new : index:IIndex<'K> * vector:IVector<'V> * vectorBuilder:IVectorBuilder * indexBuilder:IIndexBuilder -> Series<'K,'V>
  member After : lowerExclusive:'K -> Series<'K,'V>
  member Aggregate : aggregation:Aggregation<'K> * observationSelector:Func<DataSegment<Series<'K,'V>>,KeyValuePair<'TNewKey,OptionalValue<'R>>> -> Series<'TNewKey,'R> (requires equality)
  member Aggregate : aggregation:Aggregation<'K> * keySelector:Func<DataSegment<Series<'K,'V>>,'TNewKey> * valueSelector:Func<DataSegment<Series<'K,'V>>,OptionalValue<'R>> -> Series<'TNewKey,'R> (requires equality)
  member AsyncMaterialize : unit -> Async<Series<'K,'V>>
  ...

Full name: Deedle.Series<_,_>

--------------------
new : pairs:seq<KeyValuePair<'K,'V>> -> Series<'K,'V>
new : keys:seq<'K> * values:seq<'V> -> Series<'K,'V>
new : keys:'K [] * values:'V [] -> Series<'K,'V>
new : index:Indices.IIndex<'K> * vector:IVector<'V> * vectorBuilder:Vectors.IVectorBuilder * indexBuilder:Indices.IIndexBuilder -> Series<'K,'V>
val map : f:('K -> 'T -> 'R) -> series:Series<'K,'T> -> Series<'K,'R> (requires equality)

Full name: Deedle.Series.map
val k : int
val avgDelta : float

Full name: Extimated-walk-time.avgDelta
static member FrameExtensions.Sum : frame:Frame<'R,'C> -> Series<'C,float> (requires equality and equality)
namespace Fsharp.Gdal
F# Project
Fork me on GitHub