Documentation

atParam yields a parameterized view of an object as a continuous function. It is designed to be used infix, like path ``atParam`` 0.5.

domainLower defaults to being constantly 0 (for vector spaces with numeric scalars).

domainUpper defaults to being constantly 1 (for vector spaces with numeric scalars).

atStart is the value at the start of the domain. That is,

atStart x = x `atParam` domainLower x

This is the default implementation, but some representations will have a more efficient and/or precise implementation.

atEnd is the value at the end of the domain. That is,

atEnd x = x `atParam` domainUpper x

This is the default implementation, but some representations will have a more efficient and/or precise implementation.

splitAtParam splits an object p into two new objects (l,r) at the parameter t, where l corresponds to the portion of p for parameter values from 0 to t and r for to that from t to 1. The following property should hold:

prop_splitAtParam f t u =
  | u < t     = atParam f u == atParam l (u / t)
  | otherwise = atParam f u == atParam f t ??? atParam l ((u - t) / (domainUpper f - t))
  where (l,r) = splitAtParam f t

where (???) = (^+^) if the codomain is a vector type, or const flip if the codomain is a point type. Stated more intuitively, all this is to say that the parameterization scales linearly with splitting.

splitAtParam can also be used with parameters outside the range of the domain. For example, using the parameter 2 with a path (where the domain is the default [0,1]) gives two result paths where the first is the original path extended to the parameter 2, and the second result path travels backwards from the end of the first to the end of the original path.

Extract a particular section of the domain, linearly reparameterized to the same domain as the original. Should satisfy the property:

prop_section x l u t =
  let s = section x l u
  in     domainBounds x == domainBounds x
      && (x `atParam` lerp l u t) == (s `atParam` t)

That is, the section should have the same domain as the original, and the reparameterization should be linear.

Flip the parameterization on the domain.

arcLengthBounded eps x approximates the arc length of x. The true arc length is guaranteed to lie within the interval returned, which will have a size of at most eps.

arcLength eps s approximates the arc length of x up to the accuracy eps (plus or minus).

Approximate the arc length up to a standard accuracy of stdTolerance (1e-6).

arcLengthToParam eps s l converts the absolute arc length l, measured from the start of the domain, to a parameter on the object s. The true arc length at the parameter returned is guaranteed to be within eps of the requested arc length.

This should work for any arc length, and may return any parameter value (not just parameters in the domain).

A simple interface to convert arc length to a parameter, guaranteed to be accurate within stdTolerance, or 1e-6.