Package 'measure'

Description

Perturbs initialized parameters to create diverse starting points for multi-start optimization strategies.

Usage

add_param_jitter(params_list, scale = 0.1, method = c("gaussian", "uniform"))

Arguments

Value

List of jittered parameter lists.

See Also

Other peak-deconvolution: assess_deconv_quality(), check_quality_gates(), initialize_peak_params(), optimize_deconvolution()

Description

Add or update a validation section

Usage

add_validation_section(report, section, data)

Arguments

Value

Updated measure_validation_report object.

Examples

report <- measure_validation_report(title = "Test Report")
# Add custom section
report <- add_validation_section(
  report,
  "custom_study",
  list(results = data.frame(x = 1:3, y = 4:6))
)

Description

align_max_shift() controls the maximum shift allowed in alignment. align_segment_length() controls segment size for COW alignment.

Usage

align_max_shift(range = c(1L, 50L), trans = NULL)

align_segment_length(range = c(10L, 100L), trans = NULL)

Arguments

Value

A function with classes "quant_param" and "param".

Examples

align_max_shift()
align_segment_length()

Description

A convenience function to check if all criteria in an assessment passed.

Usage

all_pass(assessment, na_pass = FALSE)

Arguments

Value

Logical: TRUE if all criteria passed, FALSE otherwise.

Examples

crit <- measure_criteria(cv = 15, rsd = 20)
results <- list(cv = 10, rsd = 15)
assessment <- measure_assess(results, crit)
all_pass(assessment)

Description

Calculates comprehensive quality metrics for a peak deconvolution fit, including goodness-of-fit statistics, information criteria, per-peak quality, and residual diagnostics.

Usage

assess_deconv_quality(x, y, result, models)

Arguments

Value

A list of class deconv_quality containing:

• goodness_of_fit: R-squared, RMSE, MAE, chi-squared

• information_criteria: AIC, BIC, AICc

• peak_quality: Per-peak purity, overlap, area

• residual_analysis: Autocorrelation, heteroscedasticity, normality tests

• overall_grade: Letter grade (A/B/C/D/F)

• convergence_info: Optimization convergence details

See Also

Other peak-deconvolution: add_param_jitter(), check_quality_gates(), initialize_peak_params(), optimize_deconvolution()

Examples

# Create synthetic data and fit
x <- seq(0, 20, by = 0.1)
true_y <- 1.5 * exp(-0.5 * ((x - 8) / 1)^2) +
  0.8 * exp(-0.5 * ((x - 12) / 1.5)^2)
y <- true_y + rnorm(length(x), sd = 0.05)

models <- list(gaussian_peak_model(), gaussian_peak_model())
init_params <- list(
  list(height = 1.2, center = 7.5, width = 1.2),
  list(height = 0.6, center = 12.5, width = 1.8)
)

result <- optimize_deconvolution(x, y, models, init_params)
quality <- assess_deconv_quality(x, y, result, models)
print(quality)

Description

Add fitted values and residuals to calibration data.

Usage

## S3 method for class 'measure_calibration'
augment(x, ...)

Arguments

Value

A tibble with the original calibration data plus:

• .fitted: Fitted values

• .resid: Residuals

• .std_resid: Standardized residuals

• .hat: Leverage values

• .cooksd: Cook's distance

Description

Create ggplot2 visualizations of spectral/chromatographic data stored in measure objects.

Usage

## S3 method for class 'measure_tbl'
autoplot(object, ...)

## S3 method for class 'measure_list'
autoplot(object, summary = FALSE, max_spectra = 50, alpha = 0.3, ...)

## S3 method for class 'recipe'
autoplot(object, n_samples = 10, which = c("before_after", "summary"), ...)

Arguments

Details

For measure_tbl (single spectrum):

• Plots location vs value as a line

For measure_list (multiple spectra):

• Plots all spectra with optional summary ribbon

• Use summary = TRUE for mean +/- SD ribbon

• Use max_spectra to limit number of individual lines

For recipe:

• Shows before/after comparison of preprocessing

• Requires a prepped recipe

• Use n_samples to control number of samples shown

Value

A ggplot2 object.

Examples

## Not run: 
library(ggplot2)

# Single spectrum
spec <- new_measure_tbl(location = 1:100, value = sin(1:100 / 10) + rnorm(100, sd = 0.1))
autoplot(spec)

# Multiple spectra with summary
rec <- recipe(water ~ ., data = meats_long) |>
  step_measure_input_long(transmittance, location = vars(channel)) |>
  prep()
baked <- bake(rec, new_data = NULL)
autoplot(baked$.measures, summary = TRUE)

# Recipe before/after comparison
rec <- recipe(water ~ ., data = meats_long) |>
  update_role(id, new_role = "id") |>
  step_measure_input_long(transmittance, location = vars(channel)) |>
  step_measure_snv() |>
  prep()
autoplot(rec, n_samples = 10)

## End(Not run)

Description

Creates a Bland-Altman plot showing differences vs means with limits of agreement.

Usage

## S3 method for class 'measure_bland_altman'
autoplot(object, show_loa = TRUE, show_ci = FALSE, ...)

Arguments

Value

A ggplot object.

Description

Creates diagnostic plots for a calibration curve using ggplot2.

Usage

## S3 method for class 'measure_calibration'
autoplot(object, type = c("curve", "residuals", "qq", "all"), ...)

Arguments

Value

A ggplot object.

Examples

library(ggplot2)
data <- data.frame(
  nominal_conc = c(0, 10, 25, 50, 100),
  response = c(0.5, 15.2, 35.8, 72.1, 148.3)
)
cal <- measure_calibration_fit(data, response ~ nominal_conc)
autoplot(cal)
autoplot(cal, type = "residuals")

Description

Creates a control chart visualization showing data points, control limits, and any rule violations.

Usage

## S3 method for class 'measure_control_chart'
autoplot(object, ...)

Arguments

Value

A ggplot object showing the control chart.

Description

Creates a scatter plot with regression line for method comparison.

Usage

## S3 method for class 'measure_deming_regression'
autoplot(object, show_identity = TRUE, ...)

## S3 method for class 'measure_passing_bablok'
autoplot(object, show_identity = TRUE, ...)

Arguments

Value

A ggplot object.

Description

Creates diagnostic plots for linearity assessment.

Usage

## S3 method for class 'measure_linearity'
autoplot(object, type = c("fit", "residuals"), ...)

Arguments

Value

A ggplot object.

Description

Creates a visualization of matrix effects showing suppression/enhancement.

Usage

## S3 method for class 'measure_matrix_effect'
autoplot(object, type = c("bar", "point", "forest"), show_limits = TRUE, ...)

Arguments

Value

A ggplot object.

Description

Creates a bar chart or dot plot of proficiency scores with threshold lines.

Usage

## S3 method for class 'measure_proficiency_score'
autoplot(object, type = c("bar", "point"), ...)

Arguments

Value

A ggplot object.

Description

Creates a Pareto chart showing the relative contribution of each uncertainty component to the combined uncertainty.

Usage

## S3 method for class 'measure_uncertainty_budget'
autoplot(object, ...)

Arguments

Value

A ggplot object showing the Pareto chart.

Examples

library(ggplot2)
u1 <- uncertainty_component("Repeatability", 0.05, type = "A", df = 9)
u2 <- uncertainty_component("Calibrator", 0.02, type = "B")
u3 <- uncertainty_component("Temperature", 0.03, type = "B")
budget <- measure_uncertainty_budget(u1, u2, u3)

autoplot(budget)

Description

baseline_lambda() controls the smoothness penalty in ALS baseline correction. baseline_asymmetry() controls the asymmetry parameter in ALS. baseline_degree() controls the polynomial degree for baseline fitting.

Usage

baseline_lambda(range = c(2, 9), trans = scales::transform_log10())

baseline_asymmetry(range = c(0.001, 0.1), trans = NULL)

baseline_degree(range = c(1L, 6L), trans = NULL)

baseline_half_window(range = c(5L, 100L), trans = NULL)

baseline_span(range = c(0.1, 0.9), trans = NULL)

baseline_alpha(range = c(0, 1), trans = NULL)

baseline_window(range = c(10L, 200L), trans = NULL)

Arguments

Value

A function with classes "quant_param" and "param".

Examples

baseline_lambda()
baseline_asymmetry()
baseline_degree()
baseline_span()

Description

Creates a Bi-Gaussian peak model with four parameters: height, center, width_left, and width_right.

Usage

bigaussian_peak_model()

Details

The Bi-Gaussian function uses different widths on the left and right sides of the peak, providing flexible asymmetry.

Value

A bigaussian_peak_model object.

See Also

Other peak-models: emg_peak_model(), gaussian_peak_model(), lorentzian_peak_model()

Examples

model <- bigaussian_peak_model()
x <- seq(0, 10, by = 0.1)
params <- list(height = 1, center = 5, width_left = 0.8, width_right = 1.2)
y <- peak_model_value(model, x, params)
plot(x, y, type = "l")

Description

bin_width() controls the width of bins in spectral binning. emsc_degree() controls the polynomial degree for EMSC correction. osc_n_components() controls the number of orthogonal components in OSC.

Usage

bin_width(range = c(1, 20), trans = NULL)

emsc_degree(range = c(0L, 4L), trans = NULL)

osc_n_components(range = c(1L, 10L), trans = NULL)

Arguments

Value

A function with classes "quant_param" and "param".

Examples

bin_width()
emsc_degree()
osc_n_components()

Description

Validates that all samples in a measure_list have consistent axes (same locations). This is important for matrix operations that assume aligned data.

Usage

check_axis_consistency(
  x,
  tolerance = 1e-10,
  action = c("error", "warn", "message")
)

Arguments

Value

Invisibly returns a list with:

• consistent: Logical indicating if axes are consistent

• reference_locations: The reference locations (from first sample)

• inconsistent_samples: Indices of samples with different axes

• max_deviation: Maximum deviation from reference locations

Examples

# Consistent axes
specs <- new_measure_list(list(
  new_measure_tbl(location = 1:10, value = rnorm(10)),
  new_measure_tbl(location = 1:10, value = rnorm(10))
))
check_axis_consistency(specs)

# Inconsistent axes
specs_bad <- new_measure_list(list(
  new_measure_tbl(location = 1:10, value = rnorm(10)),
  new_measure_tbl(location = 1:11, value = rnorm(11))
))
try(check_axis_consistency(specs_bad))

Description

Validates that a recipe is properly structured for measure operations. Checks for common issues like missing input steps, incompatible column types, and role conflicts.

Usage

check_measure_recipe(recipe, strict = TRUE)

Arguments

Details

The following checks are performed:

Errors (will cause failures):

• No input step (⁠step_measure_input_*⁠)

• Output step before input step

• Multiple input steps

Warnings (may cause issues):

• No output step (data stays in internal format)

• Processing steps after output step

• No predictor columns identified

Info (suggestions):

• Large number of measurement columns (consider dimension reduction)

• No ID column identified

Value

If strict = TRUE, returns a tibble with columns:

level

Severity: "error", "warning", or "info"

check

Name of the check that triggered the message

message

Description of the issue

If strict = FALSE, returns the recipe invisibly after printing warnings.

Examples

## Not run: 
library(recipes)

# Check a properly structured recipe
rec <- recipe(outcome ~ ., data = meats_long) |>
  update_role(id, new_role = "id") |>
  step_measure_input_long(transmittance, location = vars(channel)) |>
  step_measure_snv() |>
  step_measure_output_wide()

check_measure_recipe(rec)

# Check a recipe with issues
bad_rec <- recipe(outcome ~ ., data = my_data) |>
  step_measure_snv()  # Missing input step!

check_measure_recipe(bad_rec)

## End(Not run)

Description

Evaluates a deconvolution quality assessment against configurable thresholds to determine if the fit is acceptable.

Usage

check_quality_gates(quality, reject_threshold = 0.85, warn_threshold = 0.95)

Arguments

Value

A list with:

• status: "pass", "warn", or "reject"

• pass, warn, reject: Logical flags

• messages: Character vector of issues found

• grade: Overall quality grade

See Also

Other peak-deconvolution: add_param_jitter(), assess_deconv_quality(), initialize_peak_params(), optimize_deconvolution()

Description

Creates a peak model object from a registered model name.

Usage

create_peak_model(name)

Arguments

Value

A peak_model object.

See Also

peak_models(), register_peak_model()

Examples

model <- create_peak_model("gaussian")
print(model)

Description

Factory functions that return commonly-used criteria sets for analytical validation workflows.

Usage

criteria_bioanalytical(
  cv_qc = 15,
  cv_calibration = 20,
  r_squared = 0.99,
  recovery_range = c(80, 120),
  accuracy_bias = 15
)

criteria_ich_q2(
  cv_repeatability = 2,
  cv_intermediate = 5,
  recovery_range = c(98, 102),
  r_squared = 0.999
)

criteria_bland_altman(
  loa_width = NULL,
  bias_max = NULL,
  proportional_bias_p = 0.05
)

criteria_method_comparison(
  slope_range = c(0.9, 1.1),
  intercept_range = NULL,
  r_squared = 0.95
)

criteria_proficiency_testing(max_z_score = 2, pct_satisfactory = 100)

criteria_matrix_effects(me_range = c(80, 120), me_cv = 15)

criteria_surrogate_recovery(surrogate_recovery = c(70, 130))

Arguments

Value

A measure_criteria object.

Examples

# Default bioanalytical criteria
criteria_bioanalytical()

# Custom thresholds
criteria_bioanalytical(cv_qc = 20, r_squared = 0.98)

Description

Defines a single acceptance criterion for analytical validation. Criteria are used with measure_assess() to produce pass/fail decisions.

Usage

criterion(
  name,
  operator = c("<", "<=", ">", ">=", "==", "!=", "between", "outside"),
  threshold,
  description = NULL,
  priority = c("major", "critical", "minor")
)

Arguments

Value

A measure_criterion object.

See Also

measure_criteria() for combining multiple criteria, measure_assess() for evaluating criteria.

Examples

# QC coefficient of variation must be < 15%
criterion("cv_qc", "<", 15, description = "QC CV < 15%")

# R-squared must be >= 0.99
criterion("r_squared", ">=", 0.99)

# Recovery must be between 80% and 120%
criterion("recovery", "between", c(80, 120), priority = "critical")

Description

derivative_order() controls the order of differentiation in step_measure_derivative() (1 = first derivative, 2 = second derivative). derivative_gap() and derivative_segment() control the gap derivative (Norris-Williams) parameters in step_measure_derivative_gap().

Usage

derivative_order(range = c(1L, 2L), trans = NULL)

derivative_gap(range = c(1L, 10L), trans = NULL)

derivative_segment(range = c(1L, 5L), trans = NULL)

Arguments

Value

A function with classes "quant_param" and "param".

Examples

derivative_order()
derivative_gap()
derivative_segment()

Description

Creates an Exponentially Modified Gaussian peak model with four parameters: height, center, width (sigma), and tau (exponential decay constant).

Usage

emg_peak_model()

Details

The EMG function models asymmetric peaks with tailing, common in chromatography. It is the convolution of a Gaussian with an exponential decay function.

Value

An emg_peak_model object.

See Also

Other peak-models: bigaussian_peak_model(), gaussian_peak_model(), lorentzian_peak_model()

Examples

model <- emg_peak_model()
x <- seq(0, 15, by = 0.1)
params <- list(height = 1, center = 5, width = 0.5, tau = 0.3)
y <- peak_model_value(model, x, params)
plot(x, y, type = "l")

Description

Finds all columns in a data frame that contain measurement data (i.e., are of class measure_list).

Usage

find_measure_cols(data)

Arguments

Value

Character vector of column names containing measure data. Returns empty character vector if no measure columns found.

Examples

library(recipes)

rec <- recipe(water + fat + protein ~ ., data = meats_long) |>
  update_role(id, new_role = "id") |>
  step_measure_input_long(transmittance, location = vars(channel)) |>
  prep()

result <- bake(rec, new_data = NULL)
find_measure_cols(result)  # ".measures"

Description

Returns the names of columns that contain measure_nd_list objects.

Usage

find_measure_nd_cols(data)

Arguments

Value

Character vector of column names.

Examples

# After using step_measure_input_long with multiple location columns
# find_measure_nd_cols(result)

Description

Find peaks columns in a data frame

Usage

find_peaks_cols(data)

Arguments

Value

Character vector of column names.

Description

These methods convert measure objects to data frames suitable for use with ggplot2.

Usage

## S3 method for class 'measure_tbl'
fortify(model, data = NULL, ...)

## S3 method for class 'measure_list'
fortify(model, data = NULL, ...)

Arguments

Value

A tibble with columns location and value (for measure_tbl) or location, value, and sample (for measure_list).

Examples

## Not run: 
library(ggplot2)

# Single spectrum
spec <- new_measure_tbl(location = 1:100, value = rnorm(100))
ggplot(fortify(spec), aes(location, value)) + geom_line()

# Multiple spectra (from recipe output)
rec <- recipe(water ~ ., data = meats_long) |>
  step_measure_input_long(transmittance, location = vars(channel)) |>
  prep()
baked <- bake(rec, new_data = NULL)
ggplot(fortify(baked$.measures), aes(location, value, group = sample)) +
  geom_line(alpha = 0.5)

## End(Not run)

Description

S3 method to extract the underlying data from a calibration object in a format suitable for ggplot2.

Usage

## S3 method for class 'measure_calibration'
fortify(model, data = NULL, ...)

Arguments

Value

A data frame with the calibration data and fitted values/residuals.

Description

Creates a symmetric Gaussian peak model with three parameters: height, center, and width (sigma).

Usage

gaussian_peak_model()

Details

The Gaussian function is:

$f(x) = h \cdot \exp\left(-\frac{(x - c)^2}{2\sigma^2}\right)$

where h is height, c is center, and sigma is width.

Value

A gaussian_peak_model object.

See Also

Other peak-models: bigaussian_peak_model(), emg_peak_model(), lorentzian_peak_model()

Examples

model <- gaussian_peak_model()
x <- seq(0, 10, by = 0.1)
params <- list(height = 1, center = 5, width = 1)
y <- peak_model_value(model, x, params)
plot(x, y, type = "l")

Description

Returns only the criteria that failed assessment.

Usage

get_failures(assessment)

Arguments

Value

A filtered measure_assessment tibble containing only failures.

Examples

crit <- measure_criteria(cv = 15, rsd = 20)
results <- list(cv = 18, rsd = 25)  # Both fail
assessment <- measure_assess(results, crit)
get_failures(assessment)

Description

Returns the number of dimensions (1 for measure_list, 2+ for measure_nd_list) of a measure column in a data frame.

Usage

get_measure_col_ndim(data, col)

Arguments

Value

Integer indicating the number of dimensions.

Examples

library(recipes)

rec <- recipe(water + fat + protein ~ ., data = meats_long) |>
  update_role(id, new_role = "id") |>
  step_measure_input_long(transmittance, location = vars(channel)) |>
  prep()

result <- bake(rec, new_data = NULL)
get_measure_col_ndim(result, ".measures")  # 1

Description

Retrieves a registered peak detection algorithm by name.

Usage

get_peak_algorithm(name)

Arguments

Value

A list with components:

• name: Algorithm name

• algorithm_fn: The algorithm function

• pack_name: Source package name

• description: Brief description

• default_params: List of default parameter values

• param_info: List of parameter descriptions

• technique: Technique name (or NULL)

Returns NULL if algorithm not found.

See Also

peak_algorithms(), register_peak_algorithm()

Examples

algo <- get_peak_algorithm("prominence")
if (!is.null(algo)) {
  print(algo$description)
}

Description

Get validation section data

Usage

get_validation_section(report, section)

Arguments

Value

The section data, or NULL if not found.

Examples

report <- measure_validation_report(title = "Test Report")
get_validation_section(report, "calibration")  # NULL

Description

Extract one-row summary statistics from a calibration curve.

Usage

## S3 method for class 'measure_calibration'
glance(x, ...)

Arguments

Value

A tibble with columns:

• r_squared: Coefficient of determination

• adj_r_squared: Adjusted R-squared

• sigma: Residual standard error

• df: Degrees of freedom

• model_type: Model type (linear/quadratic)

• weights_type: Weighting scheme

• n_points: Number of calibration points

• n_outliers: Number of flagged outliers

Examples

data <- data.frame(
  nominal_conc = c(0, 10, 25, 50, 100),
  response = c(0.5, 15.2, 35.8, 72.1, 148.3)
)
cal <- measure_calibration_fit(data, response ~ nominal_conc)
glance(cal)

Description

Kuhn and Johnson (2013) used these two data sets to model the glucose yeild in large- and small-scale bioreactors:

Details

• Fifteen small-scale (5 liters) bioreactors were seeded with cells and were monitored daily for 14 days.

• Three large-scale bioreactors were also seeded with cells from the same batch and monitored daily for 14 days.

Samples were collected each day from all bioreactors and glucose was measured. The goal would be to create models on the data from the more numerous small-scale bioreactors and then evaluate if these results can accurately predict what is happening in the large-scale bioreactors.

Value

Two tibbles. For each, there are 2,651 columns whose names are numbers and these are the measured assay values (and the names are the wave numbers). The numeric column glucose has the outcome data, day is the number of days in the bioreactor, the batch_id is the reactor identifier (with "L" for large and "S" for small), and batch_sample that is the ID and the day.

Source

Kuhn and Johnson (2020), Feature Engineering and Selection, Chapman and Hall/CRC . https://bookdown.org/max/FES/ and https://github.com/topepo/FES

Examples

data(glucose_bioreactors)
dim(bioreactors_small)

Description

Checks whether a data frame contains at least one measure column. This is the recommended way to validate data in step functions.

Usage

has_measure_col(data)

Arguments

Value

Invisibly returns the names of measure columns found. Throws an error if no measure columns are found.

Examples

library(recipes)

rec <- recipe(water + fat + protein ~ ., data = meats_long) |>
  update_role(id, new_role = "id") |>
  step_measure_input_long(transmittance, location = vars(channel)) |>
  prep()

result <- bake(rec, new_data = NULL)
has_measure_col(result)  # TRUE (returns invisibly)

Description

Checks whether a peak detection algorithm is registered.

Usage

has_peak_algorithm(name)

Arguments

Value

Logical TRUE if algorithm exists, FALSE otherwise.

See Also

peak_algorithms()

Examples

has_peak_algorithm("prominence")  # TRUE
has_peak_algorithm("nonexistent") # FALSE

Description

Check if a Peak Model Exists

Usage

has_peak_model(name)

Arguments

Value

Logical TRUE if model exists.

Description

Check if validation report has a section

Usage

has_validation_section(report, section)

Arguments

Value

Logical indicating if section exists and has data.

Examples

report <- measure_validation_report(title = "Test Report")
has_validation_section(report, "calibration")  # FALSE

Description

Simulated HPLC-UV chromatogram data for demonstration of chromatographic preprocessing and peak analysis. The dataset represents a separation of five phenolic compounds (caffeine, theobromine, catechin, epicatechin, and quercetin) with 20 samples of varying concentrations.

Format

A tibble with 30,020 observations and 8 variables:

sample_id

Integer sample identifier (1-20)

time_min

Retention time in minutes (0-15, 0.01 min resolution)

absorbance_mAU

UV absorbance signal in milli-absorbance units

caffeine_conc

True caffeine concentration (mg/L) for calibration

theobromine_conc

True theobromine concentration (mg/L)

catechin_conc

True catechin concentration (mg/L)

epicatechin_conc

True epicatechin concentration (mg/L)

quercetin_conc

True quercetin concentration (mg/L)

Details

The chromatograms include realistic features such as:

• Gaussian peak shapes with compound-specific widths

• Baseline drift

• Instrumental noise

• Small retention time variations between runs

• Concentration-dependent peak heights

This dataset is useful for demonstrating:

• Baseline correction methods

• Peak detection and integration

• Calibration curve construction

• Retention time alignment

The peaks appear at approximately these retention times:

• Caffeine: ~2.5 min

• Theobromine: ~4.2 min

• Catechin: ~6.8 min

• Epicatechin: ~9.1 min

• Quercetin: ~12.3 min

Source

Simulated data generated for the measure package. See data-raw/generate_datasets.R for the generation script.

See Also

sec_chromatograms for SEC/GPC chromatography data

Examples

data(hplc_chromatograms)

# View structure
str(hplc_chromatograms)

# Get a single chromatogram
library(dplyr)
chrom_1 <- hplc_chromatograms |> filter(sample_id == 1)

# Plot (if ggplot2 available)
if (requireNamespace("ggplot2", quietly = TRUE)) {
  library(ggplot2)
  ggplot(chrom_1, aes(x = time_min, y = absorbance_mAU)) +
    geom_line() +
    labs(x = "Retention Time (min)", y = "Absorbance (mAU)",
         title = "HPLC Chromatogram")
}

Description

Attempts to infer the type of measurement axis based on the range and characteristics of location values. This is a heuristic that helps guide appropriate preprocessing choices.

Usage

infer_axis_type(location)

Arguments

Value

Character string indicating inferred axis type:

• "wavelength_nm": Visible/NIR wavelengths (typically 300-2500 nm)

• "wavenumber": Mid-IR wavenumbers (typically 400-4000 cm^-1)

• "retention_time": Chromatography retention time (typically 0-60 min)

• "mass_charge": Mass spectrometry m/z (typically 50-2000+)

• "ppm": NMR chemical shift (typically -2 to 14 ppm)

• "two_theta": XRD diffraction angle (typically 5-90 degrees)

• "temperature": Thermal analysis (typically 20-1000 C)

• "unknown": Could not determine axis type

Examples

# NIR wavelengths
infer_axis_type(seq(1000, 2500, by = 2))

# Mid-IR wavenumbers
infer_axis_type(seq(4000, 400, by = -4))

# Retention time (minutes)
infer_axis_type(seq(0, 30, by = 0.01))

# NMR chemical shift
infer_axis_type(seq(0, 12, by = 0.001))

Description

Initializes peak model parameters using actual peak properties from the data rather than naive guesses, improving optimization convergence.

Usage

initialize_peak_params(
  x,
  y,
  n_peaks,
  models,
  peak_indices = NULL,
  smooth = TRUE,
  smooth_span = 0.05
)

Arguments

Value

List of initialized parameter lists (one per peak).

See Also

Other peak-deconvolution: add_param_jitter(), assess_deconv_quality(), check_quality_gates(), optimize_deconvolution()

Examples

# Create synthetic data with two peaks
x <- seq(0, 20, by = 0.1)
y <- 1.5 * exp(-0.5 * ((x - 8) / 1)^2) +
  0.8 * exp(-0.5 * ((x - 12) / 1.5)^2)

models <- list(gaussian_peak_model(), gaussian_peak_model())
init_params <- initialize_peak_params(x, y, n_peaks = 2, models = models)

Description

Test if Object is a Calibration Curve

Usage

is_measure_calibration(x)

Arguments

Value

Logical: TRUE if x is a measure_calibration object.

Examples

# After fitting a calibration curve
data <- data.frame(
  nominal_conc = c(0, 10, 25, 50, 100),
  response = c(0.5, 15.2, 35.8, 72.1, 148.3)
)
cal <- measure_calibration_fit(data, response ~ nominal_conc)
is_measure_calibration(cal)

Description

Test if object is a measure list

Usage

is_measure_list(x)

Arguments

Value

Logical indicating if x inherits from measure_list.

Examples

# After using step_measure_input_*, the .measures column is a measure_list
library(recipes)

rec <- recipe(water + fat + protein ~ ., data = meats_long) |>
  update_role(id, new_role = "id") |>
  step_measure_input_long(transmittance, location = vars(channel)) |>
  prep()

result <- bake(rec, new_data = NULL)
is_measure_list(result$.measures)

Description

Test if object is an n-dimensional measure list

Usage

is_measure_nd_list(x)

Arguments

Value

Logical indicating if x inherits from measure_nd_list.

Examples

# Create and test a measure_nd_list
meas1 <- new_measure_nd_tbl(
  location_1 = 1:5,
  location_2 = rep(1, 5),
  value = rnorm(5)
)
ml <- new_measure_nd_list(list(meas1))
is_measure_nd_list(ml)  # TRUE

Description

Test if object is an n-dimensional measure tibble

Usage

is_measure_nd_tbl(x)

Arguments

Value

Logical indicating if x inherits from measure_nd_tbl.

Examples

# Create a 2D measure tibble
mt <- new_measure_nd_tbl(
  location_1 = 1:10,
  location_2 = rep(1:2, each = 5),
  value = rnorm(10)
)
is_measure_nd_tbl(mt)  # TRUE

# Regular tibbles are not measure_nd_tbl
is_measure_nd_tbl(tibble::tibble(x = 1:5))  # FALSE

Description

Test if object is a measure tibble

Usage

is_measure_tbl(x)

Arguments

Value

Logical indicating if x inherits from measure_tbl.

Examples

# Create a measure tibble
mt <- measure:::new_measure_tbl(location = 1:5, value = rnorm(5))
is_measure_tbl(mt)

# Regular tibbles are not measure tibbles
is_measure_tbl(tibble::tibble(location = 1:5, value = rnorm(5)))

Description

Test if Object is a Peak Model

Usage

is_peak_model(x)

Arguments

Value

Logical indicating if x is a peak_model.

Description

Test if object is a peaks list

Usage

is_peaks_list(x)

Arguments

Value

Logical.

Description

Creates a Lorentzian (Cauchy) peak model with three parameters: height, center, and gamma (half-width at half-maximum).

Usage

lorentzian_peak_model()

Details

The Lorentzian function has heavier tails than Gaussian and is commonly used in spectroscopy.

Value

A lorentzian_peak_model object.

See Also

Other peak-models: bigaussian_peak_model(), emg_peak_model(), gaussian_peak_model()

Examples

model <- lorentzian_peak_model()
x <- seq(0, 10, by = 0.1)
params <- list(height = 1, center = 5, gamma = 0.5)
y <- peak_model_value(model, x, params)
plot(x, y, type = "l")

Description

Simulated MALDI-TOF (Matrix-Assisted Laser Desorption/Ionization Time-of-Flight) mass spectrometry data for demonstration of mass spectral preprocessing. The dataset represents protein/peptide analysis from four experimental groups with four replicates each.

Format

A tibble with 304,016 observations and 5 variables:

sample_id

Sample identifier combining group and replicate

group

Experimental group ("Control", "Treatment_A", "Treatment_B", "Treatment_C")

replicate

Replicate number (1-4)

mz

Mass-to-charge ratio (m/z) in Daltons (1000-20000 Da)

intensity

Signal intensity (arbitrary units)

Details

MALDI-TOF is a soft ionization technique commonly used for analyzing biomolecules such as proteins, peptides, and polymers. The technique provides mass-to-charge (m/z) ratios that can be used for identification and quantification.

The spectra include realistic features such as:

• Multiple peptide/protein peaks at different m/z values

• Baseline variation

• Chemical noise

• Peak width proportional to m/z (resolution effects)

• Replicate variation

This dataset is useful for demonstrating:

• Baseline correction methods

• Peak detection for mass spectra

• Normalization between samples

• Differential analysis between groups

Each group has a characteristic peak pattern:

• Control: Peptides at m/z ~1200, 1450, 1800, 2200, 3500, 5800, 8400, 12000

• Treatment_A: Peptides at m/z ~1100, 1650, 2100, 2800, 4200, 6500, 9200, 14000

• Treatment_B: Proteins at m/z ~2500, 4000, 5500, 8000, 11000, 15000, 18000

• Treatment_C: Peptides at m/z ~1050, 1280, 1520, 1890, 2340, 2980, 3650, 4500

The m/z resolution is approximately 500 ppm (parts per million), typical for linear MALDI-TOF instruments. Note that simulated spectra include baseline noise and minor peaks in addition to the characteristic peaks listed above.

Source

Simulated data generated for the measure package. See data-raw/generate_datasets.R for the generation script.

See Also

hplc_chromatograms for HPLC chromatography data meats_long for NIR spectroscopy data

Examples

data(maldi_spectra)

# View structure
str(maldi_spectra)

# Get unique samples
unique(maldi_spectra$sample_id)

# Get one spectrum
library(dplyr)
spec_1 <- maldi_spectra |> filter(sample_id == "Control_1")

# Plot (if ggplot2 available)
if (requireNamespace("ggplot2", quietly = TRUE)) {
  library(ggplot2)
  ggplot(spec_1, aes(x = mz, y = intensity)) +
    geom_line() +
    labs(x = "m/z (Da)", y = "Intensity",
         title = "MALDI-TOF Mass Spectrum")
}

# Compare groups
if (requireNamespace("ggplot2", quietly = TRUE)) {
  # Get one replicate per group
  comparison <- maldi_spectra |>
    filter(replicate == 1)

  ggplot(comparison, aes(x = mz, y = intensity, color = group)) +
    geom_line(alpha = 0.7) +
    facet_wrap(~group, ncol = 1) +
    labs(x = "m/z (Da)", y = "Intensity",
         title = "MALDI-TOF Spectra by Group")
}

Description

Calculates accuracy metrics including bias, recovery, and confidence intervals for method validation.

Usage

measure_accuracy(
  data,
  measured_col,
  reference_col,
  group_col = NULL,
  conf_level = 0.95
)

Arguments

Details

Accuracy expresses the closeness of agreement between a measured value and a reference value. It is typically assessed using:

• Bias: Systematic difference from the reference value

• Recovery: Percentage of the reference value that is measured

ICH Q2 Requirements

Accuracy should be assessed at a minimum of 3 concentration levels covering the specified range (typically 80-120% of the target).

Value

A measure_accuracy object containing:

• n: Number of observations

• mean_measured: Mean of measured values

• mean_reference: Mean of reference values

• bias: Absolute bias (measured - reference)

• bias_pct: Relative bias as percentage

• recovery: Recovery percentage (measured/reference * 100)

• recovery_ci_lower, recovery_ci_upper: Confidence interval for recovery

See Also

measure_linearity(), measure_carryover()

Other accuracy: measure_carryover(), measure_linearity()

Examples

# Accuracy at multiple levels
set.seed(123)
data <- data.frame(
  level = rep(c("low", "mid", "high"), each = 5),
  nominal = rep(c(10, 50, 100), each = 5),
  measured = c(
    rnorm(5, 10.2, 0.3),
    rnorm(5, 49.5, 1.5),
    rnorm(5, 101, 3)
  )
)

result <- measure_accuracy(data, "measured", "nominal", group_col = "level")
print(result)

Description

Central dispatcher that enables 1D preprocessing operations to work on n-dimensional measurement data. For 1D data, it applies the function directly. For nD data, it slices along the specified dimensions, applies the function to each 1D slice, and rebuilds the nD structure.

Usage

measure_apply(x, fn, along = 1L, ...)

Arguments

Details

The measure_apply() function is the workhorse for making 1D preprocessing steps work on nD data. It handles:

• 1D data: Direct function application

• nD data: Slice-apply-rebuild pattern

For nD data, the function extracts 1D slices along the specified dimension(s), applies the transformation function to each slice, and reassembles the result into the original nD structure.

Value

An object of the same class as the input, with the function applied to each 1D slice.

Examples

# Create a simple 2D measurement
m2d <- new_measure_nd_tbl(
  location_1 = rep(1:10, each = 3),
  location_2 = rep(1:3, times = 10),
  value = rnorm(30)
)

# Define a simple smoothing function for 1D data
smooth_1d <- function(x) {
  x$value <- stats::filter(x$value, rep(1/3, 3), sides = 2)
  x[!is.na(x$value), ]
}

# Apply smoothing along dimension 1
result <- measure_apply(m2d, smooth_1d, along = 1)

Description

Evaluates a set of values against acceptance criteria and returns a detailed assessment table with pass/fail status.

Usage

measure_assess(data, criteria, action = c("return", "warn", "error"))

Arguments

Value

A tibble with class measure_assessment containing:

• criterion: Name of the criterion

• value: The observed value

• threshold: The threshold value(s)

• operator: The comparison operator

• pass: Logical indicating pass/fail

• priority: Priority level of the criterion

• description: Human-readable description

See Also

measure_criteria() for creating criteria, criterion() for individual criteria.

Examples

# Define criteria
crit <- measure_criteria(
  cv_qc = list("<", 15),
  r_squared = list(">=", 0.99),
  recovery = list("between", c(80, 120))
)

# Assess results
results <- list(cv_qc = 12.5, r_squared = 0.995, recovery = 98.2)
measure_assess(results, crit)

# Assess with some failures
results_bad <- list(cv_qc = 18.3, r_squared = 0.985, recovery = 75)
measure_assess(results_bad, crit)

Description

Extracts metadata about the axis (location dimension) of measure data, including range, spacing, direction, and inferred axis type.

Usage

measure_axis_info(x, sample = 1L)

Arguments

Value

A list with:

• min, max: Range of location values

• n_points: Number of data points

• spacing: Median absolute spacing between points

• direction: "increasing", "decreasing", or "mixed"

• regular: Logical indicating if spacing is regular (within tolerance)

• axis_type: Inferred axis type (see infer_axis_type())

Examples

# NIR spectrum
spec <- new_measure_tbl(
  location = seq(1000, 2500, by = 2),
  value = rnorm(751)
)
measure_axis_info(spec)

# Chromatogram
chrom <- new_measure_tbl(
  location = seq(0, 30, by = 0.01),
  value = rnorm(3001)
)
measure_axis_info(chrom)

Description

Performs Bland-Altman analysis to compare two measurement methods. This calculates the mean bias, limits of agreement, and optionally tests for proportional bias.

Usage

measure_bland_altman(
  data,
  method1_col,
  method2_col,
  id_col = NULL,
  conf_level = 0.95,
  regression = c("none", "linear", "quadratic")
)

Arguments

Details

Interpretation

The Bland-Altman plot shows the difference between methods against their mean. Key features:

• Mean bias: Average difference (systematic error)

• Limits of agreement (LOA): Range containing 95% of differences

• Proportional bias: Trend in differences with concentration

Acceptance Criteria

Methods are typically considered interchangeable if:

• Mean bias is clinically/analytically insignificant

• LOA width is acceptable for the intended use

• No significant proportional bias

Value

A measure_bland_altman object containing:

• data: Tibble with mean, difference, and LOA for each observation

• statistics: List of summary statistics (bias, SD, LOA, CIs)

• regression: Regression results if requested (model, p-value)

See Also

measure_deming_regression(), measure_passing_bablok()

Other method-comparison: measure_deming_regression(), measure_passing_bablok(), measure_proficiency_score()

Examples

# Compare two blood glucose meters
set.seed(123)
data <- data.frame(
  patient_id = 1:30,
  meter_A = rnorm(30, mean = 100, sd = 15),
  meter_B = rnorm(30, mean = 102, sd = 16)
)

ba <- measure_bland_altman(
  data,
  method1_col = "meter_A",
  method2_col = "meter_B",
  regression = "linear"
)

print(ba)
tidy(ba)

# Visualize
ggplot2::autoplot(ba)

Description

A calibration curve object stores the fitted model, diagnostics, and metadata for quantitation workflows. Created by measure_calibration_fit().

Structure

A measure_calibration object is a list containing:

model

The underlying fitted model (lm object)

model_type

Character: "linear" or "quadratic"

weights_type

Character: weighting scheme used

formula

The model formula

data

The calibration data used for fitting

diagnostics

List of diagnostic statistics

outliers

Data frame of flagged outliers (if any)

call

The original function call

See Also

measure_calibration_fit() for creating calibration objects, measure_calibration_predict() for prediction, tidy.measure_calibration() for extracting coefficients, autoplot.measure_calibration() for diagnostic plots.

Description

Fits a weighted or unweighted calibration curve for quantitation. Supports linear and quadratic models with various weighting schemes.

Usage

measure_calibration_fit(
  data,
  formula,
  model = c("linear", "quadratic"),
  weights = c("none", "1/x", "1/x2", "1/y", "1/y2"),
  origin = FALSE,
  outlier_method = c("none", "studentized", "cook"),
  outlier_threshold = NULL,
  outlier_action = c("flag", "remove"),
  sample_type_col = NULL
)

Arguments

Details

Weighting

Weighting is essential when response variance changes with concentration (heteroscedasticity). Common patterns:

• Constant CV: Use "1/x2" or "1/y2"

• Constant absolute error: Use "none"

• Proportional error: Use "1/x" or "1/y"

Outlier Handling

By default, outliers are flagged but NOT removed. This follows the principle of "flag, don't drop" for analytical data. If removal is enabled, the removed points are stored in the result for audit purposes.

Value

A measure_calibration object containing the fitted model, diagnostics, and metadata.

See Also

measure_calibration_predict() for prediction, autoplot.measure_calibration() for diagnostic plots, tidy.measure_calibration() for extracting coefficients.

Examples

# Simple linear calibration
data <- data.frame(
  nominal_conc = c(0, 10, 25, 50, 100, 200),
  response = c(0.5, 15.2, 35.8, 72.1, 148.3, 295.7)
)
cal <- measure_calibration_fit(data, response ~ nominal_conc)
print(cal)

# Weighted calibration (1/x^2)
cal_weighted <- measure_calibration_fit(
  data,
  response ~ nominal_conc,
  weights = "1/x2"
)

# Quadratic model
cal_quad <- measure_calibration_fit(
  data,
  response ~ nominal_conc,
  model = "quadratic"
)

Description

Uses a fitted calibration curve to predict concentrations from responses.

Usage

measure_calibration_predict(
  object,
  newdata,
  interval = c("none", "confidence", "prediction"),
  level = 0.95,
  ...
)

Arguments

Details

For inverse prediction (response -> concentration), the function uses root-finding when the model is quadratic. For linear models, direct algebraic inversion is used.

Interval Calculation

Intervals are calculated using the delta method for the inverse prediction. For quadratic models, intervals are approximate.

Value

A tibble with columns:

• .pred_conc: Predicted concentration

• .pred_lower: Lower bound (if intervals requested)

• .pred_upper: Upper bound (if intervals requested)

See Also

measure_calibration_fit() for fitting calibration curves.

Examples

# Fit calibration curve
cal_data <- data.frame(
  nominal_conc = c(0, 10, 25, 50, 100),
  response = c(0.5, 15.2, 35.8, 72.1, 148.3)
)
cal <- measure_calibration_fit(cal_data, response ~ nominal_conc)

# Predict concentrations from new responses
unknowns <- data.frame(response = c(45, 85, 120))
measure_calibration_predict(cal, unknowns)

# With prediction intervals
measure_calibration_predict(cal, unknowns, interval = "prediction")

Description

Evaluates the performance of a calibration curve using verification samples (continuing calibration verification - CCV, or independent QC samples). This function assesses whether the calibration remains valid during or between analytical runs.

Usage

measure_calibration_verify(
  calibration,
  verification_data,
  nominal_col = "nominal_conc",
  acceptance_pct = 15,
  acceptance_pct_lloq = 20,
  lloq = NULL,
  sample_type_col = NULL,
  criteria = NULL
)

Arguments

Details

Verification Workflow

Calibration verification is typically performed:

1. At the beginning and end of analytical batches

2. After every N unknown samples (e.g., every 10)

3. When instrument performance is in question

Acceptance Criteria

Default criteria are based on bioanalytical guidelines:

• Standard samples: ±15% of nominal

• LLOQ samples: ±20% of nominal

For more stringent applications (e.g., clinical chemistry), consider using ±10% or providing custom criteria.

Value

A measure_calibration_verify object (a tibble) containing:

• Predicted concentrations

• Accuracy (%nominal)

• Deviation from nominal (%)

• Pass/fail status for each sample

• Overall verification status

See Also

measure_calibration_fit() for fitting calibration curves, measure_calibration_predict() for prediction, measure_criteria() for custom acceptance criteria.

Examples

# Fit calibration
cal_data <- data.frame(
  nominal_conc = c(1, 5, 10, 50, 100, 500),
  response = c(1.2, 5.8, 11.3, 52.1, 105.2, 498.7)
)
cal <- measure_calibration_fit(cal_data, response ~ nominal_conc)

# Verify with QC samples
qc_data <- data.frame(
  sample_id = c("QC_Low", "QC_Mid", "QC_High"),
  nominal_conc = c(3, 75, 400),
  response = c(3.3, 77.2, 385.1)
)

verify_result <- measure_calibration_verify(cal, qc_data)
print(verify_result)

Description

Evaluates carryover by analyzing blank samples run after high-concentration samples.

Usage

measure_carryover(
  data,
  response_col,
  sample_type_col,
  run_order_col,
  blank_type = "blank",
  high_type = "high",
  threshold = 20,
  lloq = NULL
)

Arguments

Details

Carryover is the appearance of analyte in a blank sample due to contamination from a previous high-concentration sample. It is typically assessed by analyzing blank samples immediately after the highest calibration standard or QC sample.

Acceptance Criteria (ICH M10)

Carryover in the blank sample following the high concentration should not exceed:

• 20% of the LLOQ (for the analyte)

• 5% of the internal standard response

Value

A measure_carryover object containing:

• blank_responses: Response values in blanks after high samples

• mean_blank: Mean blank response

• max_blank: Maximum blank response

• high_responses: High sample responses

• carryover_pct: Carryover as percentage of high or LLOQ

• pass: Whether carryover is within acceptable limits

See Also

measure_accuracy(), measure_system_suitability()

Other accuracy: measure_accuracy(), measure_linearity()

Examples

# Carryover assessment
data <- data.frame(
  run_order = 1:10,
  sample_type = c("std", "std", "std", "high", "blank",
                  "qc", "qc", "high", "blank", "std"),
  response = c(100, 500, 1000, 5000, 5, 500, 510, 4900, 8, 100)
)

result <- measure_carryover(
  data,
  response_col = "response",
  sample_type_col = "sample_type",
  run_order_col = "run_order",
  lloq = 50
)
print(result)

Description

Named list of regex patterns for detecting measurement column types. Used by measure_identify_columns() for auto-detection. Users can extend or modify these patterns and pass them to detection functions.

Usage

measure_column_patterns

Format

Named list with regex patterns:

wavenumber

wn_ prefix for IR wavenumber (cm^-1)

wavelength

nm_ prefix for wavelength (nm)

retention_time

rt_ prefix for chromatography retention time

mz

mz_ prefix for mass-to-charge ratio (MS)

ppm

ppm_ prefix for NMR chemical shift

channel

ch_ prefix for numbered channels

generic

x_ prefix for generic/unknown axis

Examples

# View default patterns
measure_column_patterns

# Create custom patterns
my_patterns <- c(measure_column_patterns, list(custom = "^my_prefix_"))

Description

Summarizes columns by their detected type, useful for understanding the structure of analytical datasets.

Usage

measure_column_summary(data, patterns = measure_column_patterns)

Arguments

Value

A tibble summarizing each detected type:

type

Column type

n_columns

Number of columns of this type

example_cols

First 3 column names of this type

Examples

df <- data.frame(
  id = 1:5,
  wn_1000 = rnorm(5), wn_1001 = rnorm(5), wn_1002 = rnorm(5),
  concentration = rnorm(5)
)
measure_column_summary(df)

Description

Creates a control chart with optional multi-rule (Westgard) violation detection.

Usage

measure_control_chart(
  data,
  response_col,
  order_col,
  limits = NULL,
  rules = c("1_3s", "2_2s", "R_4s", "4_1s", "10x"),
  group_col = NULL
)

Arguments

Details

Westgard Rules

The function supports common Westgard multi-rules:

• 1:3s: One point beyond 3 sigma (action required)

• 2:2s: Two consecutive points beyond 2 sigma (warning)

• R:4s: Range of two consecutive points > 4 sigma

• 4:1s: Four consecutive points beyond 1 sigma (same side)

• 10x: Ten consecutive points on same side of mean

Interpretation

• Violations are flagged with the specific rule that was triggered

• Multiple rules can be triggered by the same point

• A run is considered "in control" if no violations are detected

Value

A measure_control_chart object containing:

• data: The input data with added violation flags

• limits: The control limits used

• violations: Summary of rule violations

• rules_applied: Which rules were checked

See Also

measure_control_limits(), autoplot.measure_control_chart()

Other control-charts: measure_control_limits(), measure_system_suitability()

Examples

# Generate control chart with Westgard rules
set.seed(123)
qc_data <- data.frame(
  run_order = 1:50,
  qc_value = c(rnorm(45, 100, 2), rnorm(5, 106, 2))  # Last 5 shifted
)
chart <- measure_control_chart(qc_data, "qc_value", "run_order")
print(chart)

Description

Calculates control limits for quality control monitoring using Shewhart rules and optionally EWMA or CUSUM statistics.

Usage

measure_control_limits(
  data,
  response_col,
  group_col = NULL,
  type = c("shewhart", "ewma", "cusum"),
  n_sigma = 3,
  target = NULL,
  lambda = 0.2,
  k = 0.5,
  h = 5
)

Arguments

Details

Shewhart Charts

Classic control charts with limits at mean +/- n*sigma:

• UCL/LCL: Action limits (typically 3 sigma)

• UWL/LWL: Warning limits (typically 2 sigma)

EWMA Charts

Exponentially weighted moving average, more sensitive to small shifts:

• Control limits narrow as more data is collected

• Lambda parameter controls weight of recent observations

CUSUM Charts

Cumulative sum chart for detecting persistent shifts:

• Upper and lower CUSUM statistics track cumulative deviations

• Decision interval h determines sensitivity

Value

A measure_control_limits object containing:

• center: Center line (target or mean)

• lcl: Lower control limit

• ucl: Upper control limit

• lwl: Lower warning limit (2 sigma)

• uwl: Upper warning limit (2 sigma)

• sigma: Estimated standard deviation

• Additional statistics depending on chart type

See Also

measure_control_chart(), measure_system_suitability()

Other control-charts: measure_control_chart(), measure_system_suitability()

Examples

# Calculate Shewhart control limits
set.seed(123)
qc_data <- data.frame(
  run_order = 1:30,
  qc_value = rnorm(30, mean = 100, sd = 2)
)
limits <- measure_control_limits(qc_data, "qc_value")
print(limits)

# EWMA control limits
limits_ewma <- measure_control_limits(qc_data, "qc_value", type = "ewma")

Description

Combines multiple criterion() objects into a criteria set for use with measure_assess().

Usage

measure_criteria(..., .list = NULL)

Arguments

Value

A measure_criteria object (list of measure_criterion objects).

See Also

criterion() for creating individual criteria, measure_assess() for evaluating criteria.

Examples

# Using criterion() objects
measure_criteria(
  criterion("cv_qc", "<", 15),
  criterion("r_squared", ">=", 0.99),
  criterion("recovery", "between", c(80, 120))
)

# Using shorthand notation
measure_criteria(
  cv_qc = list("<", 15),
  r_squared = list(">=", 0.99),
  bias = list("between", c(-10, 10))
)

# Simple threshold (assumes "<=")
measure_criteria(
  cv = 15,       # cv <= 15
  rsd = 20       # rsd <= 20
)

Description

Performs Deming regression to compare two measurement methods when both have measurement error. This is preferred over ordinary least squares when both methods have non-negligible error.

Usage

measure_deming_regression(
  data,
  method1_col,
  method2_col,
  error_ratio = NULL,
  method1_sd = NULL,
  method2_sd = NULL,
  bootstrap = FALSE,
  bootstrap_n = 1000,
  conf_level = 0.95
)

Arguments

Details

Error Ratio

The error ratio (lambda) represents the ratio of error variances: lambda = var(method2) / var(method1)

Common approaches:

• lambda = 1: Assume equal error variances

• Estimate from replicates: Use SDs from replicate measurements

• Estimate from calibration: Use known method precision data

Interpretation

For equivalent methods:

• Slope should be close to 1 (proportional agreement)

• Intercept should be close to 0 (no constant bias)

If 95% CI for slope includes 1 and CI for intercept includes 0, methods are considered equivalent.

Implementation

If the mcr package is available, it is used for fitting. Otherwise, a manual implementation is used with optional bootstrap CIs.

Value

A measure_deming_regression object containing:

• coefficients: Tibble with intercept and slope estimates and CIs

• statistics: List of diagnostic statistics (RMSE, R-squared)

• data_summary: Summary of input data

• bootstrap: Bootstrap results if requested

See Also

measure_bland_altman(), measure_passing_bablok()

Other method-comparison: measure_bland_altman(), measure_passing_bablok(), measure_proficiency_score()

Examples

# Method comparison data
data <- data.frame(
  reference = c(5.2, 10.5, 15.8, 25.3, 50.1, 75.4, 100.2),
  new_method = c(5.1, 10.8, 16.2, 25.9, 49.8, 76.1, 101.3)
)

# Deming regression with bootstrap CIs
result <- measure_deming_regression(
  data,
  method1_col = "reference",
  method2_col = "new_method",
  bootstrap = TRUE,
  bootstrap_n = 500
)

print(result)
tidy(result)

Description

Detects significant drift in feature responses across run order using trend tests and/or slope analysis.

Usage

measure_detect_drift(
  data,
  features,
  run_order_col = "run_order",
  sample_type_col = "sample_type",
  qc_type = NULL,
  method = c("slope", "mann_kendall", "both")
)

Arguments

Value

A tibble with drift statistics for each feature:

• feature: Feature name

• slope: Regression slope (change per run)

• slope_pvalue: P-value for slope != 0

• percent_change: Total percent change over run

• significant: Logical, TRUE if drift is statistically significant

Examples

# Create data with drift
data <- data.frame(
  sample_type = rep("qc", 20),
  run_order = 1:20,
  feature1 = 100 + (1:20) * 0.5 + rnorm(20, sd = 2),
  feature2 = 50 + rnorm(20, sd = 1)  # No drift
)

measure_detect_drift(data, c("feature1", "feature2"))

Description

Returns the semantic names for each dimension (e.g., "wavelength", "retention_time").

Usage

measure_dim_names(x)

Arguments

Value

Character vector of dimension names, or NULL if not set.

Examples

m2d <- new_measure_nd_tbl(
  location_1 = 1:10,
  location_2 = rep(1:2, each = 5),
  value = rnorm(10),
  dim_names = c("retention_time", "wavelength")
)
measure_dim_names(m2d)

Description

Returns the units for each dimension (e.g., "nm", "min").

Usage

measure_dim_units(x)

Arguments

Value

Character vector of dimension units, or NULL if not set.

Examples

m2d <- new_measure_nd_tbl(
  location_1 = 1:10,
  location_2 = rep(1:2, each = 5),
  value = rnorm(10),
  dim_units = c("min", "nm")
)
measure_dim_units(m2d)

Description

Reconstructs an n-dimensional measurement from a 1D vector that was created by measure_unfold(). Requires the fold metadata attribute.

Usage

measure_fold(x)

Arguments

Value

A measure_nd_tbl or measure_nd_list with the original dimensional structure restored.

See Also

measure_unfold() to create foldable 1D data

Examples

# Create, unfold, then fold back
m2d <- new_measure_nd_tbl(
  location_1 = rep(1:3, each = 4),
  location_2 = rep(1:4, times = 3),
  value = 1:12
)

m1d <- measure_unfold(m2d)
m2d_restored <- measure_fold(m1d)

# Values are preserved
all.equal(m2d$value, m2d_restored$value)

Description

Performs a Gage Repeatability and Reproducibility study to assess measurement system variation.

Usage

measure_gage_rr(
  data,
  response_col,
  part_col,
  operator_col,
  tolerance = NULL,
  conf_level = 0.95,
  k = 5.15
)

Arguments

Details

Gage R&R decomposes total measurement variation into:

• Repeatability (EV): Equipment variation - variability from repeated measurements by the same operator on the same part

• Reproducibility (AV): Appraiser variation - variability between operators measuring the same parts

• Part-to-Part (PV): True variation between parts

Acceptance Criteria (typical guidelines)

• %R&R < 10%: Measurement system acceptable

• %R&R 10-30%: Measurement system may be acceptable depending on application

• %R&R > 30%: Measurement system needs improvement

The number of distinct categories (ndc) should be >= 5 for a capable measurement system.

Value

A measure_gage_rr object containing:

• Variance components (Repeatability, Reproducibility, Part-to-Part)

• %Contribution of each component

• %Study Variation (using k * sigma)

• %Tolerance (if tolerance provided)

• Number of distinct categories (ndc)

See Also

measure_repeatability(), measure_intermediate_precision()

Other precision: measure_intermediate_precision(), measure_repeatability(), measure_reproducibility()

Examples

# Gage R&R study with 10 parts, 3 operators, 2 replicates each
set.seed(123)
data <- expand.grid(
  part = 1:10,
  operator = c("A", "B", "C"),
  replicate = 1:2
)
data$measurement <- 50 +
  (data$part - 5) * 2 +  # Part-to-part variation
  ifelse(data$operator == "A", 0.5,
         ifelse(data$operator == "B", -0.3, 0)) +  # Operator effect
  rnorm(nrow(data), 0, 0.5)  # Repeatability

result <- measure_gage_rr(
  data,
  response_col = "measurement",
  part_col = "part",
  operator_col = "operator",
  tolerance = 20
)
print(result)

Description

Returns detailed information about the coordinate grid, including unique values per dimension, grid shape, and regularity status.

Usage

measure_grid_info(x)

Arguments

Value

A list with components:

• ndim: Number of dimensions

• dim_names: Semantic dimension names (if set)

• dim_units: Dimension units (if set)

• unique_values: List of unique coordinate values per dimension

• shape: Integer vector of unique value counts per dimension

• n_points: Total number of data points

• is_regular: Whether the grid is regular

• has_na: Whether any values are NA

Examples

m2d <- new_measure_nd_tbl(
  location_1 = rep(seq(0, 10, by = 2), each = 4),
  location_2 = rep(c(254, 280, 320, 350), times = 6),
  value = rnorm(24),
  dim_names = c("time", "wavelength"),
  dim_units = c("min", "nm")
)
measure_grid_info(m2d)

Description

Automatically detects column types in a data frame based on naming conventions common in analytical chemistry. This helps set up recipes with appropriate roles for different column types.

Usage

measure_identify_columns(data, patterns = measure_column_patterns)

Arguments

Details

Column type detection uses the following naming conventions:

Columns not matching any pattern are classified as "other" and suggested as either "outcome" (if numeric), "id" (if character/factor with unique values), or "predictor".

Value

A tibble with columns:

column

Column name

type

Detected type (from pattern names, or "other" if no match)

suggested_role

Suggested recipe role based on type

n_values

Number of non-NA values

class

R class of the column

Examples

# Wide format spectral data
df <- data.frame(
  sample_id = 1:5,
  outcome = rnorm(5),
  wn_1000 = rnorm(5),
  wn_1001 = rnorm(5),
  wn_1002 = rnorm(5)
)
measure_identify_columns(df)

# Chromatography data
df2 <- data.frame(
  id = letters[1:3],
  concentration = c(1.2, 2.3, 3.4),
  rt_0.5 = rnorm(3),
  rt_1.0 = rnorm(3),
  rt_1.5 = rnorm(3)
)
measure_identify_columns(df2)

Description

Calculates intermediate precision statistics for measurements performed under varying conditions (different days, analysts, or instruments).

Usage

measure_intermediate_precision(
  data,
  response_col,
  factors,
  group_col = NULL,
  conf_level = 0.95
)

Arguments

Details

Intermediate precision quantifies the variability due to different conditions within the same laboratory. This typically includes:

• Different days

• Different analysts

• Different equipment (of the same type)

The function uses a one-way or nested ANOVA approach to estimate variance components. For more complex designs, consider using mixed effects models with the lme4 package.

Value

A measure_precision object containing variance components and precision estimates:

• component: Name of the variance component

• variance: Estimated variance

• percent_variance: Percentage of total variance

• sd: Standard deviation (square root of variance)

• cv: Coefficient of variation (%) for that component