Docstring and style updates

Author: mikeingold

src/integral.jl

@@ -3,30 +3,33 @@
 ################################################################################
 
 """
-    integral(f, geometry[, rule]; diff_method=_default_diff_method(geometry, FP), FP=Float64)
+    integral(f, geometry[, rule]; kwargs...)
 
 Numerically integrate a given function `f(::Point)` over the domain defined by
 a `geometry` using a particular numerical integration `rule` with floating point
 precision of type `FP`.
 
 # Arguments
 - `f`: an integrand function, i.e. any callable with a method `f(::Meshes.Point)`
-- `geometry`: some `Meshes.Geometry` that defines the integration domain
+- `geometry`: a Meshes `Geometry` or `Domain` that defines the integration domain
 - `rule`: optionally, the `IntegrationRule` used for integration (by default
 `GaussKronrod()` in 1D and `HAdaptiveCubature()` else)
 
 # Keyword Arguments
-- `diff_method::DifferentiationMethod = _default_diff_method(geometry, FP)`: the method to
-use for calculating Jacobians that are used to calculate differential elements
-- `FP = Float64`: the floating point precision desired.
+- `diff_method::DifferentiationMethod`: manually specifies the differentiation method use to
+calculate Jacobians within the integration domain.
+- `FP = Float64`: manually specifies the desired output floating point precision
 """
 function integral end
 
+# Default integration rule to use if unspecified
+_defrule(geometry) = (Meshes.paramdim(geometry) == 1) ? GaussKronrod() : HAdaptiveCubature()
+
 # If only f and geometry are specified, select default rule
 function integral(
         f,
         geometry::Geometry,
-        rule::I = Meshes.paramdim(geometry) == 1 ? GaussKronrod() : HAdaptiveCubature();
+        rule::I = _defrule(geometry);
         kwargs...
 ) where {I <: IntegrationRule}
     _integral(f, geometry, rule; kwargs...)
@@ -35,12 +38,12 @@ end
 function integral(
         f,
         domain::Meshes.Domain,
-        rule::I = Meshes.paramdim(domain) == 1 ? GaussKronrod() : HAdaptiveCubature();
+        rule::I = _defrule(domain);
         kwargs...
 ) where {I <: IntegrationRule}
     # Discretize the Domain into primitive geometries, sum the integrals over those
     subintegral(geometry) = integral(f, geometry, rule; kwargs...)
-    subgeometries = Meshes.elements(Meshes.discretize(domain)) |> collect
+    subgeometries = collect(Meshes.elements(Meshes.discretize(domain)))
     return sum(subintegral, subgeometries)
 end
 

src/specializations/PolyArea.jl

@@ -9,22 +9,11 @@
 ################################################################################
 
 """
-    integral(f, area::PolyArea, rule = HAdaptiveCubature();
-             diff_method=FiniteDifference(), FP=Float64)
+    integral(f, area::PolyArea, rule = HAdaptiveCubature(); kwargs...)
 
 Like [`integral`](@ref) but integrates over the surface domain defined by a `PolyArea`.
 The surface is first discretized into facets that are integrated independently using
 the specified integration `rule`.
-
-# Arguments
-- `f`: an integrand function, i.e. any callable with a method `f(::Meshes.Point)`
-- `area`: a `PolyArea` that defines the integration domain
-- `rule = HAdaptiveCubature()`: optionally, the `IntegrationRule` used for integration
-
-# Keyword Arguments
-- `diff_method::DifferentiationMethod`: the method to use for
-calculating Jacobians that are used to calculate differential elements
-- `FP = Float64`: the floating point precision desired
 """
 function integral(
         f,