The hardware and bandwidth for this mirror is donated by dogado GmbH, the Webhosting and Full Service-Cloud Provider. Check out our Wordpress Tutorial.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]dogado.de.
cost_variance_frontier() and everything built on it
(routed_unit_cost(), routed_cost_curve(),
two_stage_design(), dual_frame_design()) route
the simulated samples without the optimality certificate of single
tours, which only adds proof time: about 14 times faster on single-tour
problems.
The local-mean variance estimator (design_variance()
for "lpm", "cube" and single-replicate
systematic samples) averages over each sampled unit and its
neighbours = 3 nearest sampled units, as
BalancedSampling::vsb() (engine fieldopt-core
0.10.0). The previous neighbourhood grew until the inclusion
probabilities summed to one and overestimated the variance by 60 to 160
percent for spatially smooth variables (experiment E3).
design_variance() also reports df, the degrees
of freedom of the variance (r - 1 with r
replicates): use the t quantile for intervals.
routed_cost_curve() measures the routed cost
G(n) = c0 + a n + b sqrt(n) of a design: Hansen, Hurwitz
and Madow’s travel constant estimated by routing the frame;
predict() gives the total, average and marginal
cost.
two_stage_design() and
dual_frame_design() fit the routed cost curve
G(n) = c0 + a n + b sqrt(n) from samples routed at a few
sizes and allocate with the marginal cost G'(n), which is
what Cochran’s and Hartley’s rules need when the cost is not linear;
under a budget the sample sizes come from the fitted curve, so the
design spends the budget at its real routed cost. The previous loop used
the average cost and took 3 to 12 percent too few primary units. Results
gain c1_average (or cost_a_average),
cost_curve and cost_coef.
schedule_fieldwork() solves the assignment of units
to bases and the routes jointly, as one multi-depot problem with a route
limit per base and the per_route cost in the objective
(engine fieldopt-core 0.8.1);
route_fieldwork() charges per_route in its
objective too. On the 23 Cordeau multi-depot instances the solver
reaches or beats the best known solution on 11 and stays within 1.6% on
the rest, in 1 to 26 seconds.
Pipe-friendly inputs: travel_matrix() takes a sample
(its sampled units only) with bases and a
speed that turns distances into minutes;
route_fieldwork() and schedule_fieldwork()
take the sample as units; sampled() returns
the selected rows, so a plan reads
frame |> select_units(n) |> travel_matrix(bases = towns, speed = 60) |> schedule_fieldwork(units = s, ...).
Connectors: as_svydesign() hands a sample to the
survey package (a replicate-weight design for replicated
systematic samples, Brewer’s or the simple-random-sampling approximation
otherwise) for calibration, domains and nonresponse adjustment;
frame_overlap() matches the establishments of a list frame
to the cells of the area frame (coordinates, polygons or a table of
linked pairs) and marks the overlap domain;
read_areaframe() reads the cells exported by the area-frame
service (Parquet with WKB geometries) or any spatial file.
select_units(method = "lpm") and
spatial_balance() use a grid spatial index (engine
fieldopt-core 0.9.1): a frame of a million cells is sampled
in under a second instead of hours.
schedule_fieldwork(region = ) solves one region at a time
and combines the calendars, the way a national survey is scheduled state
by state.
schedule_calendar() redistributes the routes of a
schedule over teams and days as an integer programme solved with the
highs package (in Suggests): team availability by day,
routes fixed to a team or a day, precedences, and a daily limit that
lets short routes share a team-day; it minimises the last working
day.
route_fieldwork(certify = ) runs a branch-and-bound
on Held-Karp 1-trees that proves single tours optimal (engine
fieldopt-core 0.9.0): most tours of up to a hundred units
are certified within a few seconds, and optimal is no
longer limited to instances of 13 units.
The routing solver was rebuilt (engine fieldopt-core
0.5.0): instances of up to 13 units are solved exactly; larger ones by a
hybrid genetic search with the optimal split of giant tours and a
granular local search with inter-route moves (relocate, swap,
2-opt); the Held-Karp bound replaces the two-edge bound for single
tours and optimal reports proven optimality;
route_fieldwork() gains demand,
capacity, time_limit and
engine = "vrpr" (the PyVRP solver through the
vrpr package, also in schedule_fieldwork(),
where it optimises the assignment to bases jointly with the routes). The
built-in solver has feasible and infeasible subpopulations with adaptive
penalties, SWAP and intra-route swaps, moves priced from route
totals in constant time, population restarts and a time limit (engine
0.7.0): on TSPLIB it is optimal and on Augerat set A it reaches 24 of 27
optima (mean gap 0.01%, largest 0.15%) in about two seconds.
New tools (engine fieldopt-core 0.4.0):
route_fieldwork() takes a service_time per
unit that counts towards max_length and reports route
durations; field_cost_model() gains
per_route (the cost of a team-day);
schedule_fieldwork() assigns units to bases, routes each
base and builds the calendar of teams and days;
dual_frame_estimator() combines the area and list samples
(Hartley with fixed, screening or estimated theta;
Fuller-Burmeister) with design-based variances;
select_units(method = "cube", balance = ) draws balanced
samples by the cube method and spatial_balance() is the
Voronoi measure of Stevens and Olsen; ratio_estimator()
uses a known auxiliary total; multivariate_allocation() is
the Bethel allocation for several study variables;
as_frame() and as_sf() move between
sf layers and frames.
Review round (engine fieldopt-core 0.3.0): the
routing local search prices every move in the direction travelled, so
asymmetric road matrices (one-way streets, durations by direction) no
longer loop, and the lower bound is valid for asymmetric matrices and
for several routes; two_stage_allocation() tries every
whole m, accepts a fractional m_secondary and
meets its target in small populations;
dual_frame_allocation() reads sd as the
standard deviation with divisor N - 1 and refuses
theta outside [0, 1] and budgets below two
units per frame; select_units() refuses size
with "srs" (the probabilities were mislabelled), duplicate
unit names, n below the number of strata, strata with too
few positive sizes and invalid seeds, and leaves the user’s
random-number generator untouched; point_estimator()
refuses missing y; two_stage_design() and
dual_frame_design() report converged = FALSE
when the rounds run out; cost_variance_frontier() takes the
coordinate columns from a supplied matrix;
core_version() reports the engine crate. New:
autoplot() for samples, print() for points,
tidy()/glance() for routes,
glance() for frontiers.
The R wrappers are shipped in R/extendr-wrappers.R
and no longer regenerated at install time
(cargo run --bin document), which failed on the CRAN
Windows toolchain.
Area-frame and dual-frame design: select_units()
gains strata, a spatially ordered systematic method with
interpenetrating replicates and simple random sampling;
select_points(), expected_hits() and
point_estimator() implement point sampling inside segments
with the multiplicity estimator; segment_estimator() gives
the closed, open and weighted segment estimators;
dual_frame_allocation() is Hartley’s allocation with an
optimised or fixed mixing weight (screening design);
two_stage_allocation() is Cochran’s two-stage allocation
with the cost function c1 n + c2 n m.
design_variance() chooses the variance estimator that
matches the design (local-mean, replicates or SRS). Engine:
fieldopt-core 0.2.3.
cost_variance_frontier() accepts
strata, selection and replicates,
a list of per-stratum allocations in n_grid, and reports
cost_per_unit.
travel_matrix() gains a detour factor
for straight-line distances and method = "osrm", road
durations or distances from an OSRM server through the osrm
package, requested in blocks; the frontier and the routed designs accept
the same method.
routed_unit_cost(), two_stage_design()
and dual_frame_design() iterate the allocation with the
cost per area unit measured by routing;
point_design_effect() simulates the area design and returns
the bias, variance and design effect of point sampling;
select_points() gains a systematic layout;
tidy() and glance() for the three
allocations.
Variances are computed within strata and summed
("stratified srs", "stratified local-mean");
route plots of geographic matrices put longitude on the x axis.
First version: travel matrices from coordinates or a road network
(travel_matrix()), a field cost model
(field_cost_model()), GRASP routing of the field work for
one or several teams (route_fieldwork()), spatially
balanced selection of units with the local pivotal method
(select_units()), Horvitz-Thompson estimation with the
local-mean variance estimator (design_variance()),
cost-aware allocation across strata or frames
(frame_allocation()) and the cost-variance frontier of a
design by simulation (cost_variance_frontier()). The engine
is the Rust crate fieldopt-core.
These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.
Health stats visible at Monitor.