climb_factor_gem 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3de080785de7f1f7833f2d69a8323197e026bb3e621dfd395539f152ce9966ca
+  data.tar.gz: 4b697e0f6cea23b5c2fbdb5b650ac90e7912b5367b87d0d96a3cce7efda9e1c7
+SHA512:
+  metadata.gz: 7f3b2ff8ce4b33182e3407b7f214b711404f888ee8d6dae3d06f5d07c543c2d86afe38015f1315a9480f32ad9d7217079b8043bed3e2e3de14974f30933ad47c
+  data.tar.gz: 3fac167ac1c40cc6d30f2ae4639cd5eb40f1adefdaf00eb3fba6723abca53539679778af68d0963931b230966484a7b59b72c9723f9f27ba296ded124933a388

data/LICENSE

@@ -0,0 +1,2 @@
+copyright (c) 2017 Benjamin Crowell
+GPL v2

data/README.md

@@ -0,0 +1,83 @@
+Climb Factor
+=====
+This is a Ruby gem adaptation of the software authored by Ben Crowell, the original source for which you can find [here](https://bitbucket.org/ben-crowell/kcals).
+
+## Description
+
+This software estimates your energy expenditure from running or walking,
+based on a GPS track or a track generated by an application such as
+google maps or [onthegomap](https://onthegomap.com).
+
+The model used to calculate the results is described in this paper:
+
+B. Crowell, "From treadmill to trails: predicting performance of runners,"
+https://www.biorxiv.org/content/10.1101/2021.04.03.438339v2 , doi: 10.1101/2021.04.03.438339
+
+The output from this software is most useful if you want to compare
+one run to another, e.g., if I want to know how a mountain run with lots of elevation gain
+compares with a flat run at a longer distance, or if I want to project whether doing a certain
+trail as a run is feasible for me.
+
+## Use through the web interface
+
+The web interface is available [here](https://www.lightandmatter.com/cf)
+
+## Use
+Add this to your Gemfile
+```
+gem 'climb_factor_gem'
+```
+To invoke it, you must provide an array of horizontal/vertical pairs (in meters!):
+```
+hv = [[0, 1], [1.1, 4], [3.4, 6], ...]
+ClimbFactor.estimate(hv)
+```
+
+See `climb_factor.rb` for more details and additional options.
+
+## Filtering
+
+The parameters filtering and xy_filtering both represent horizontal distances
+in units of meters. Their defaults values are 200 and 30, respectively. These are meant to get rid of bogus
+oscillations in the data. Any elevation (z) changes that occur over horizontal distances less
+than the value of "filtering" will tend to get filtered out, and likewise any horizontal motion that occurs
+over horizontal distances less than the value of "xy_filtering."
+To turn off filtering, set the relevant parameter to 0.
+
+The choice of the vertical filtering parameter
+can have a huge effect on the total elevation gain, but the
+effect on the calorie expenditure is usually fairly small.
+There are several reasons why it may be a good idea to set a fairly large value of the vertical
+("filtering") parameter:
+
+ 1. If the resolution of the horizontal track is poor, then it may appear to go up and down steep hillsides,
+          when in fact the real road or trail contours around them.
+
+ 2. If elevations from GPS are being used (which is a bad idea), then random fluctuations in the GPS
+          elevations can cause large errors.
+
+ 3. If the elevations are being taken from a digital elevation model (DEM), which is generally a good
+         idea, then there may still be certain types of errors.
+         Trails and roads are intentionally constructed so as not to go up and down steep hills, but
+         the DEM may not accurately reflect this. The most common situation seems to be one in which
+         a trail or road takes a detour into a narrow gully in order to maintain a steady grade.
+         The DEM currently used by this software has a horizontal resolution of 30 meters.
+         If the gully is narrower than this, then the DEM doesn't know about the the gully, and
+         the detour appears to be a steep excursion up and then back down the prevailing slope.
+         I have found empirically that setting filtering=60 m is roughly the minimum that is required
+         in order to eliminate this type of artifact, which makes sense because a detour into a 30 meter
+         gully probably does involve about 60 meters of horizontal travel.
+
+My rules of thumb for setting the filtering are as follows:
+
+ * For most runs with relatively short and not insanely steep hills, the default vertical filtering
+     parameter of 60 m works well. Using a higher filtering value leads to wrong results, because
+     the hills get smoothed out entirely.
+
+ * For very steep runs with a lot of elevation gain, in rugged terrain, it's necessary to use a
+     larger filtering value of about 200 m. Otherwise the energy estimates are much too high.
+     This is the software's default.
+
+The mileage derived from a GPS track can vary quite a bit depending on the resolution of the GPS data.
+Higher resolution increases the mileage, because small wiggles get counted in. This has a big effect on
+the energy calculation, because the energy is mostly sensitive to mileage, not gain.

data/lib/climb_factor/filtering.rb

@@ -0,0 +1,124 @@
+require_relative 'low_level_math'
+
+module ClimbFactor
+  module Filtering
+    def self.resample_and_filter_hv(hv,filtering,target_resampling_resolution:30.0)
+      # The default for target_resampling_resolution is chosen because typically public DEM data isn't any better than this horizontal resolution anyway.
+      if filtering>target_resampling_resolution then filtering=target_resampling_resolution end
+      k = (filtering/target_resampling_resolution).floor # Set resampling resolution so that it divides filtering.
+      while target_resampling_resolution*k<filtering do k+=1 end
+      if k%2==1 then k+=1 end # make it even
+      resampling_resolution = filtering/k
+      resampled_v = resample_hv(hv,resampling_resolution)
+      result = []
+      0.upto(resampled_v.length-1) { |i|
+        result.push([resampling_resolution*i,resampled_v[i]])
+      }
+      return result
+    end
+
+    def self.resample_hv(hv,desired_h_resolution)
+      # Inputs a list of [h,v] points, returns a list of v values interpolated to achieve the given constant horizontal resolution (or slightly more).
+      # This is similar to add_resolution_and_check_size_limit(), but that routine kludgingly does multiple things.
+      tot_h = hv.last[0]-hv[0][0]
+      n = (tot_h/desired_h_resolution).ceil+1
+      dh = tot_h/(n-1) # actual resolution, which will be a tiny bit better
+      result = []
+      m = 0 # index into hv
+      0.upto(n-1) { |i| # i is an index into resampled output
+        h = hv[0][0]+dh*i
+        while m<hv.length-1 && hv[m+1][0]<h do m += 1 end
+        s = (h-hv[m][0])/(hv[m+1][0]-hv[m][0]) # interpolation fraction ranging from 0 to 1
+        result.push(CfMath.linear_interp(hv[m][1],hv[m+1][1],s))
+      }
+      return result
+    end
+
+    def self.do(v0,w)
+      # inputs:
+      #   v0 is a list of floating-point numbers, representing the value of a function at equally spaced points on the x axis
+      #   w = width of rectangular window to convolve with; will be made even if it isn't
+      # output:
+      #   a fresh array in the same format as v0, doesn't modify v0
+      # v0's length should be a power of 2 and >=2
+
+      if w<=1 then return v0 end
+
+      if w%2==1 then w=w+1 end
+
+      # remove DC and detrend, so that start and end are both at 0
+      #        -- https://www.dsprelated.com/showthread/comp.dsp/175408-1.php
+      # After filtering, we put these back in.
+      # v0 = original, which we don't touch
+      # v = detrended
+      # v1 = filtered
+      # For the current method, it's only necessary that n is even, not a power of 2, and detrending
+      # isn't actually needed.
+      v = v0.dup
+      n = v.length
+      slope = (v.last-v[0])/(n.to_f-1.0)
+      c = -v[0]
+      0.upto(n-1) { |i|
+        v[i] = v[i] - (c + slope*i)
+      }
+
+      # Copy the unfiltered data over as a default. On the initial and final portions, where part of the
+      # rectangular kernel hangs over the end, we don't attempt to do any filtering. Using the filter
+      # on those portions, even with appropriate normalization, would bias the (x,y) points, effectively
+      # moving the start and finish line inward.
+      v1 = v.dup
+
+      # convolve with a rectangle of width w:
+      sum = 0
+      count = 0
+      # Sum the initial portion for use in the average for the first filtered data point:
+      sum_left = 0.0
+      0.upto(w-1) { |i|
+        break if i>n/2-1 # this happens in the unusual case where w isn't less than n; we're guaranteed that n is even
+        sum_left = sum_left+v[i]
+      }
+      # the filter is applied to the middle portion, from w to n-w:
+      if w<n then
+        sum = sum_left
+        w.upto(n) { |i|
+          if i>=v.length then break end # wasn't part of original algorithm, but needed for some data sets...?
+          if v[i].nil?
+            raise("coordinate #{i} of #{w}..#{n} is nil, length of vector is #{v.length}, for v0=#{v0.length}, w=#{w}")
+          end
+          sum = sum + v[i]-v[i-w]
+          j = i-w/2
+          break if j>n-w
+          if j>=w && j<=n-w then
+            v1[j] = sum/w
+          end
+        }
+      end
+
+      # To avoid a huge discontinuity in the elevation when the filter turns on, turn it on gradually
+      # in the initial and final segments of length w:
+      # FIXME: leaves a small discontinuity
+      sum_left = 0.0
+      sum_right = 0.0
+      nn = 0
+      0.upto(2*w+1) { |i|
+        break if i>n/2-1 # unusual case, see above
+        j = n-i-1
+        sum_left = sum_left+v[i]
+        sum_right = sum_right+v[j]
+        nn = nn+1
+        if i%2==0 then
+          ii = i/2
+          jj = n-i/2-1
+          v1[ii] = sum_left/nn
+          v1[jj] = sum_right/nn
+        end
+      }
+
+      # put DC and trend back in:
+      0.upto(n-1) { |i|
+        v1[i] = v1[i] + (c + slope*i)
+      }
+      return v1
+    end
+  end
+end

data/lib/climb_factor/geometry.rb

@@ -0,0 +1,84 @@
+require_relative 'low_level_math'
+
+module ClimbFactor
+  module Geom
+    def self.earth_radius(lat)
+      # https://en.wikipedia.org/wiki/Earth_radius#Geocentric_radius
+      a = 6378137.0 # earth's equatorial radius, in meters
+      b = 6356752.3 # polar radius
+      slat = Math::sin(CfMath.deg_to_rad(lat))
+      clat = Math::cos(CfMath.deg_to_rad(lat))
+      return Math::sqrt( ((a*a*clat)**2+(b*b*slat)**2) / ((a*clat)**2+(b*slat)**2)) # radius in meters
+    end
+
+    def self.cartesian_to_spherical(x,yy,z,lat0,lon0)
+      # returns [lat,lon,altitude], in units of degrees, degrees, and meters
+      # see Geom.spherical_to_cartesian() for description of coordinate systems used and the transformations.
+      # Calculate a first-order approximation to the inverse of the polyconic projection:
+      r0 = earth_radius(lat0)
+      zz = z+r0
+      slat0 = Math::sin(CfMath.deg_to_rad(lat0))
+      clat0 = Math::cos(CfMath.deg_to_rad(lat0))
+      r = Math::sqrt(x*x+yy*yy+zz*zz)
+      y =  clat0*yy+slat0*zz
+      zzz = -slat0*yy+clat0*zz
+      lat = CfMath.rad_to_deg(Math::asin(y/r))
+      lon = CfMath.rad_to_deg(Math::atan2(x,zzz))+lon0
+      1.upto(10) { |i| # more iterations to improve the result
+        x2,y2,z2 = spherical_to_cartesian(lat,lon,z,lat0,lon0)
+        dx = x-x2
+        dy = yy-y2
+        break if dx.abs<1.0e-8 and dy.abs<1.0e-8
+        lat = lat + CfMath.rad_to_deg(dy/r0)
+        lon = lon + CfMath.rad_to_deg(dx/(r0*clat0)) if clat0!=0.0
+      }
+      return [lat,lon,z]
+    end
+
+    def self.spherical_to_cartesian(lat,lon,alt,lat0,lon0)
+      # Inputs are in degrees, except for alt, which is in meters.
+      # Returns [x,y,z] in meters.
+      # The "cartesian" coordinates are not actually cartesian. They're coordinates in which
+      # (x,y) are from a polyconic projection https://en.wikipedia.org/wiki/Polyconic_projection
+      # centered on (lat0,lon0), and z is altitude.
+      # (In older versions of the software, z was distance from center of earth.)
+      # Outputs are in meters. The metric for the projection is not exactly euclidean, so later
+      # calculations that treat these as cartesian coordinates are making an approximation. The error
+      # should be tiny on the scales we normally deal with. The important thing for our purposes is
+      # that the gradient of z is vertical.
+      lam = CfMath.deg_to_rad(lon)
+      lam0 = CfMath.deg_to_rad(lon0)
+      phi = CfMath.deg_to_rad(lat)
+      phi0 = CfMath.deg_to_rad(lat0)
+      cotphi = 1/Math::tan(phi)
+      u = (lam-lam0)*Math::sin(phi) # is typically on the order of 10^-3 (half the width of a USGS topo)
+      if u.abs<0.01
+        # use taylor series to avoid excessive rounding in calculation of 1-cos(u)
+        u2 = u*u
+        u4 = u2*u2
+        one_minus_cosu = 0.5*u2-(0.0416666666666667)*u4+(1.38888888888889e-3)*u2*u4-(2.48015873015873e-5)*u4*u4
+          # max error is about 10^-27, which is a relative error of about 10^-23
+      else
+        one_minus_cosu = 1-Math::cos(u)
+      end
+      r0 = earth_radius(lat0)
+            # Use initial latitude and keep r0 constant. If we let r0 vary, then we also need to figure
+            # out the direction of the g vector in this model.
+      x = r0*cotphi*Math::sin(u)
+      y = r0*((phi-phi0)+cotphi*one_minus_cosu)
+      z = alt
+      return [x,y,z]
+    end
+
+    def self.interpolate_raster(z,x,y)
+      # z = array[iy][ix]
+      # x,y = floating point, in array-index units
+      ix = x.to_i
+      iy = y.to_i
+      fx = x-ix # fractional part
+      fy = y-iy
+      z = CfMath.interpolate_square(fx,fy,z[iy][ix],z[iy][ix+1],z[iy+1][ix],z[iy+1][ix+1])
+      return z
+    end
+  end
+end

data/lib/climb_factor/low_level_math.rb

@@ -0,0 +1,59 @@
+module ClimbFactor
+  module CfMath
+    def self.deg_to_rad(x)
+      return 0.0174532925199433*x
+    end
+
+    def self.rad_to_deg(x)
+      return x/0.0174532925199433
+    end
+
+    def self.pythag(x,y)
+      return Math::sqrt(x*x+y*y)
+    end
+
+    def self.interpolate_square(x,y,z00,z10,z01,z11)
+      # https://en.wikipedia.org/wiki/BiClimbFactorMath.linear_interpolation#Unit_Square
+      # The crucial thing is that this give results that are continuous across boundaries of squares.
+      w00 = (1.0-x)*(1.0-y)
+      w10 = x*(1.0-y)
+      w01 = (1.0-x)*y
+      w11 = x*y
+      norm = w00+w10+w01+w11
+      z = (z00*w00+z10*w10+z01*w01+z11*w11)/norm
+      return z
+    end
+
+    def self.linear_interp(x1,x2,s)
+      return x1+s*(x2-x1)
+    end
+
+    def self.add2d(p,q)
+      return [p[0]+q[0],p[1]+q[1]]
+    end
+
+    def self.sub2d(p,q)
+      return [p[0]-q[0],p[1]-q[1]]
+    end
+
+    def self.dot2d(p,q)
+      return p[0]*q[0]+p[1]*q[1]
+    end
+
+    def self.scalar_mul2d(p,s)
+      return [s*p[0],s*p[1]]
+    end
+
+    def self.normalize2d(p)
+      return scalar_mul2d(p,1.0/mag2d(p))
+    end
+
+    def self.dist2d(p,q)
+      return mag2d(sub2d(p,q))
+    end
+
+    def self.mag2d(p)
+      return Math::sqrt(dot2d(p,p))
+    end
+  end
+end

data/lib/climb_factor/physiology.rb

@@ -0,0 +1,104 @@
+#=========================================================================
+# @@ physiological model
+#=========================================================================
+
+# For the cr and cw functions, see Minetti, http://jap.physiology.org/content/93/3/1039.full
+
+module ClimbFactor
+  module Phys
+    def self.minetti(i)
+      # cost of running or walking, in J/kg.m
+      if $running then
+        a,b,c,d,p = [26.073730183424228, 0.031038121935618928, 1.3809948743424785, -0.06547207947176657, 2.181405714691871]
+      else
+        a,b,c,d,p = [22.911633035337864, 0.02621471025436344, 1.3154310892336223, -0.08317260964525384, 2.208584834633906]
+      end
+      cost = (a*((i**p+b)**(1/p)+i/c+d)).abs
+      if true then
+        # "recreational" version
+        cutoff_i = -0.03
+        if i<cutoff_i then cost=[cost,minetti(cutoff_i)].max end
+      end
+      return cost
+    end
+    # Five-parameter fit to the following data:
+    #   c is minimized at imin, and has the correct value cmin there (see comments in ClimbFactorPhys.i_to_iota())
+    #   slopes at +-infty are ClimbFactorPhys.minetti's values: sp=9.8/0.218; sm=9.8/-1.062 for running,
+    #                                           sp=9.8/0.243; sm=9.8/-1.215 for walking
+    #   match ClimbFactorPhys.minetti's value at i=0.0
+    # original analytic work, with p=2 and slightly different values of sp and sm:
+    #    calc -e "x0=-0.181355; y0=1.781269; sp=9.8/.23; sm=9.8/-1.2; a=(sp-sm)/2; c=a/[(sp+sm)/2]; b=x0^2(c^2-1); d=(1/a)*{y0-a*[sqrt(x0^2+b)+x0/c]}; a(1-1/c)"
+    #    a = 25.3876811594203
+    #    c = 1.47422680412371
+    #    b = 0.0385908791280687
+    #    d = -0.0741786448190981
+    # I then optimized the parameters further, including p, numerically, to fit the above criteria.
+    # Also checked that it agrees well with the polynomial for a reasonable range of i values.
+
+    def self.minetti_original(i) # their 5th-order polynomial fits; these won't work well at extremes of i
+      if $running then return minetti_cr(i) else return minetti_cw(i) end
+    end
+
+    def self.i_to_iota(i)
+      # convert i to a linearized scale iota, where iota^2=[C(i)-C(imin)]/c2 and sign(iota)=sign(i-imin)
+      # The following are the minima of the Minetti functions.
+      if $running then
+        imin = -0.181355
+        cmin = 1.781269
+        c2=66.0 # see comments at ClimbFactorPhys.minetti_quadratic_coeffs()
+      else
+        imin = -0.152526
+        cmin= 0.935493
+        c2=94.0 # see comments at ClimbFactorPhys.minetti_quadratic_coeffs()
+      end
+      if i.class != Float then i=to_f(i) end
+      if i.infinite? then return i end
+      c=minetti(i)
+      if c<cmin then
+        # happens sometimes due to rounding
+        c=cmin
+      end
+      result = Math::sqrt((c-cmin)/c2)
+      if i<imin then result= -result end
+      return result
+    end
+
+    def self.minetti_quadratic_coeffs()
+      # my rough approximation to Minetti, optimized to fit the range that's most common
+      if $running then
+        i0=-0.15
+        c0=1.84
+        c2=66.0
+      else
+        i0=-0.1
+        c0=1.13
+        c2=94.0
+      end
+      b0=c0+c2*i0*i0
+      b1=-2*c2*i0
+      b2=c2
+      return [i0,c0,c2,b0,b1,b2]
+    end
+
+    def self.minetti_cr(i) # no longer used
+      # i = gradient
+      # cr = cost of running, in J/kg.m
+      if i>0.5 || i<-0.5 then return minetti_steep(i) end
+      return 155.4*i**5-30.4*i**4-43.3*i**3+46.3*i**2+19.5*i+3.6
+      # note that the 3.6 is different from their best value of 3.4 on the flats, i.e., the polynomial isn't a perfect fit
+    end
+
+    def self.minetti_cw(i) # no longer used
+      # i = gradient
+      # cr = cost of walking, in J/kg.m
+      if i>0.5 || i<-0.5 then return minetti_steep(i) end
+      return 280.5*i**5-58.7*i**4-76.8*i**3+51.9*i**2+19.6*i+2.5
+    end
+
+    def self.minetti_steep(i) # no longer used
+      g=9.8 # m/s2=J/kg.m
+      if i>0 then eff=0.23 else eff=-1.2 end
+      return g*i/eff
+    end
+  end
+end

data/lib/climb_factor.rb

@@ -0,0 +1,86 @@
+require_relative "climb_factor/filtering"
+require_relative "climb_factor/physiology"
+require_relative "climb_factor/low_level_math"
+
+module ClimbFactor
+  def self.estimate(hv,nominal_distance:nil,filtering:200.0)
+    # inputs:
+    #   All inputs are in units of meters.
+    #   hv = list of [horizontal,vertical] coordinate pairs
+    #   nominal_distance = if supplied, scale horizontal length of course to equal this value
+    #   filtering = get rid of bogus fluctuations in vertical data that occur on horizontal scales less than this
+    # output:
+    #   cf = a floating-point number representing a climb factor, expressed as a percentage
+    hv = Filtering.resample_and_filter_hv(hv,filtering)
+    rescale = 1.0
+    if !nominal_distance.nil? then
+      rescale = nominal_distance/(hv.last[0]-hv[0][0])
+    end
+    stats,hv = integrate_gain_and_energy(hv,rescale)
+    c,h = stats['c'],stats['h'] # energy cost in joules and (possibly rescaled) horiz distance in meters
+    cf = 100.0*(c-h*Phys.minetti(0.0))/c
+    return cf
+  end
+
+  def self.integrate_gain_and_energy(hv,rescale,body_mass:1.0)
+    # integrate to find total gain, slope distance, and energy burned
+    # returns [stats,hv], where:
+    #   stats = {'c'=>c,'d'=>d,'gain'=>gain,'i_rms'=>i_rms,...}
+    #   hv = modified copy of input hv, with predicted times added, if we have the necessary data
+    v = 0 # total vertical distance (=0 at end of a loop)
+    d = 0 # total distance along the slope
+    gain = 0 # total gain
+    c = 0 # cost in joules
+    first = true
+    old_h = 0
+    old_v = 0
+    i_sum = 0.0
+    i_sum_sq = 0.0
+    iota_sum = 0.0
+    iota_sum_sq = 0.0
+    baumel_si = 0.0 # compute this directly as a check
+    t = 0.0 # integrated time, in seconds
+    h_reintegrated = 0.0 # if rescale!=1, this should be the same as nominal_h
+    k = 0
+    hv.each { |a|
+      h,v = a
+      if !first then
+        dh = (h-old_h)*rescale
+        dv = v-old_v
+        dd = Math::sqrt(dh*dh+dv*dv)
+        h_reintegrated = h_reintegrated+dh
+        d = d+dd
+        if dv>0 then gain=gain+dv end
+        i=0
+        if dh>0 then i=dv/dh end
+        if dh>0 then baumel_si=baumel_si+dv**2/dh end
+        # In the following, weight by dh, although normally this doesn't matter because we make the
+        # h intervals constant before this point.
+        i_sum = i_sum + i*dh
+        i_sum_sq = i_sum_sq + i*i*dh
+        dc = dd*body_mass*Phys.minetti(i)
+            # in theory it matters whether we use dd or dh here; I think from Minetti's math it's dd
+        c = c+dc
+        #if not ($split_energy_at.nil?) and d-dd<$split_energy_at_m and d>$split_energy_at_m then
+        #   $stderr.print "at d=#{$split_energy_at}, energy=#{(c*0.0002388459).round} kcals\n"
+        #   # fixme -- implement this in a better way
+        #end
+        k=k+1
+      end
+      old_h = h
+      old_v = v
+      first = false
+    }
+    n = hv.length-1.0
+    h = h_reintegrated # should equal $nominal_h; may differ from hv.last[0]-hv[0][0] if rescale!=1
+    i_rms = Math::sqrt(i_sum_sq/h - (i_sum/h)**2)
+    i_mean = (hv.last[1]-hv[0][1])/h
+    i0,c0,c2,b0,b1,b2 = Phys.minetti_quadratic_coeffs()
+    e_q = h*body_mass*(b0+b1*i_mean+b2*i_rms)
+    cf = (c-h*body_mass*Phys.minetti(0.0))/c
+    stats = {'c'=>c,'h'=>h,'d'=>d,'gain'=>gain,'i_rms'=>i_rms,'i_mean'=>i_mean,'e_q'=>e_q,
+            'cf'=>cf,'baumel_si'=>baumel_si,
+            't'=>t}
+    return [stats,hv]
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: climb_factor_gem
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Benjamin Crowell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-08-14 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/climb_factor.rb
+- lib/climb_factor/filtering.rb
+- lib/climb_factor/geometry.rb
+- lib/climb_factor/low_level_math.rb
+- lib/climb_factor/physiology.rb
+homepage: https://bitbucket.org/hello-drifter/climb-factor-gem
+licenses:
+- GPL-2.0-or-later
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: A library that uses a scientifically validated model to determine the energetic
+  cost of running up and down hills.
+test_files: []