Cookbook

This page contains five self-contained recipes that cover the most common SPC analysis scenarios. Each recipe describes its input data shape, provides working code samples in C#, Visual Basic, and F#, explains what the results mean, and highlights the single most common mistake practitioners make in that scenario.

These recipes assume the reader has already read Getting Started with Numerics.NET SPC. For guidance on selecting the right chart type, see Choosing the Right Analysis.

Scenario. A chemical batch process produces one measurement per batch: the yield (%) of a distillation step. Batches arrive in time order and cannot be grouped into rational subgroups. The goal is to determine whether the yield process is in statistical control and, if so, to estimate process capability against a specification of 90 %–105 %.

Input shape. A single IReadOnlyList<double> of n observations in time order. Missing values should be omitted before passing to the API; the library treats NaN as a contract violation in individuals data.

// Recipe: Individuals process analysis (I-MR)
double[] measurements = {
    23.1, 24.0, 22.8, 24.5, 23.3, 24.8, 22.5, 24.2,
    23.7, 24.1, 23.4, 24.3, 23.6, 24.0, 23.2
};
Vector<double> obs = Vector.Create(measurements);

// 1. Construct and analyze the chart
IndividualsMovingRangeChartSet chart =
    new IndividualsMovingRangeChartSet(obs);
chart.Analyze();

FixedLimitSeries iSeries = chart.IndividualsSeries;
Console.WriteLine(
    $"I chart: CL={iSeries.CenterLine:F2} " +
    $"UCL={iSeries.UpperControlLimit:F2} " +
    $"LCL={iSeries.LowerControlLimit:F2}");

// 2. Evaluate rules
RuleSetEvaluation rules =
    chart.IndividualsSeries.EvaluateRules(ControlRuleSets.Nelson);
bool isStable = !rules.HasViolations;
Console.WriteLine($"Stable: {isStable}");

// 3. Capability analysis (independent step)
if (isStable)
{
    var specs = new SpecificationLimits(Lower: 21.0, Upper: 27.0);
    CapabilityAnalysisResult cap = Capability.Analyze(obs, specs);
    Console.WriteLine($"Cpk = {cap.Cpk:F3}");
}

Dim measurements As Double() = {
    23.1, 24.0, 22.8, 24.5, 23.3, 24.8, 22.5, 24.2,
    23.7, 24.1, 23.4, 24.3, 23.6, 24.0, 23.2
}
Dim obs As Vector(Of Double) = Vector.Create(measurements)

Dim chart As New IndividualsMovingRangeChartSet(obs)
chart.Analyze()

Dim iSeries As FixedLimitSeries = chart.IndividualsSeries
Console.WriteLine(
    $"I chart: CL={iSeries.CenterLine:F2} " &
    $"UCL={iSeries.UpperControlLimit:F2} LCL={iSeries.LowerControlLimit:F2}")

Dim rules As RuleSetEvaluation =
    chart.IndividualsSeries.EvaluateRules(ControlRuleSets.Nelson)
Dim isStable As Boolean = Not rules.HasViolations
Console.WriteLine($"Stable: {isStable}")

If isStable Then
    Dim specs = New SpecificationLimits(Lower:=21.0, Upper:=27.0)
    Dim cap As CapabilityAnalysisResult = Capability.Analyze(obs, specs)
    Console.WriteLine($"Cpk = {cap.Cpk:F3}")
End If

No code example is currently available or this language may not be supported.

let measurements = [|
    23.1; 24.0; 22.8; 24.5; 23.3; 24.8; 22.5; 24.2
    23.7; 24.1; 23.4; 24.3; 23.6; 24.0; 23.2
|]
let obs = Vector.Create(measurements)

let chart = new IndividualsMovingRangeChartSet(obs)
chart.Analyze()

let iSeries = chart.IndividualsSeries
printfn "I chart: CL=%.2f UCL=%.2f LCL=%.2f"
    iSeries.CenterLine iSeries.UpperControlLimit iSeries.LowerControlLimit

let rules = chart.IndividualsSeries.EvaluateRules(ControlRuleSets.Nelson)
let isStable = not rules.HasViolations
printfn "Stable: %b" isStable

if isStable then
    let specs = SpecificationLimits(Lower = Nullable(21.0), Upper = Nullable(27.0))
    let cap = Capability.Analyze(obs, specs)
    printfn "Cpk = %.3f" (cap.Cpk.GetValueOrDefault())

Reading the result. After calling Analyze(), the IndividualsMovingRangeChartSet exposes each observation with its plotted value, control limits, and rule violations through its IndividualsSeries series. The capability section exposes $C_p$, $C_{pk}$ (using MovingRange by default) and the corresponding performance indices $P_p$, $P_{pk}$. A process in control with a $C_{pk}$ above 1.33 meets the conventional automotive/manufacturing benchmark.

Scenario. A machining centre produces shafts in a continuous run. Every hour an operator measures five consecutive shafts (a rational subgroup) and records the diameters in millimetres. Twenty-five subgroups have been collected. The engineering tolerance is 50.00 mm ± 0.05 mm.

Input shape. A jagged or rectangular 2-D collection where each inner sequence is one subgroup of equal or near-equal size. XBar‑R is reliable for subgroup sizes 2–10; for larger subgroups use XBar‑S instead. See Variables Charts for the supported size range.

// Recipe: Subgrouped manufacturing analysis (XBar-R, n=4)
double[,] rawData = {
    { 23.1, 24.0, 22.8, 24.5 },
    { 23.3, 24.8, 22.5, 24.2 },
    { 23.7, 24.1, 23.4, 24.3 },
    { 23.6, 24.0, 23.2, 24.4 },
    { 23.0, 24.6, 22.9, 24.1 }
};
Matrix<double> subgroups = Matrix.CopyFrom(rawData);

// 1. Construct and analyze
XBarRChartSet chart = new XBarRChartSet(subgroups);
chart.Analyze();

Console.WriteLine(
    $"XBar UCL={chart.MeansSeries.UpperControlLimit:F3}");

// 2. Rules on XBar component
RuleSetEvaluation rules =
    chart.MeansSeries.EvaluateRules(ControlRuleSets.Nelson);
Console.WriteLine($"XBar rule violations: {rules.Violations.Count}");

// 3. Capability (independent step)
var specs = new SpecificationLimits(Lower: 21.0, Upper: 27.0);
CapabilityAnalysisResult cap = Capability.Analyze(subgroups, specs);
Console.WriteLine($"Cpk = {cap.Cpk:F3}");

Dim rawData As Double(,) = {
    {23.1, 24.0, 22.8, 24.5},
    {23.3, 24.8, 22.5, 24.2},
    {23.7, 24.1, 23.4, 24.3},
    {23.6, 24.0, 23.2, 24.4},
    {23.0, 24.6, 22.9, 24.1}
}
Dim subgroups As Matrix(Of Double) = Matrix.CopyFrom(rawData)

Dim chart As New XBarRChartSet(subgroups)
chart.Analyze()
Console.WriteLine($"XBar UCL={chart.MeansSeries.UpperControlLimit:F3}")

Dim rules As RuleSetEvaluation =
    chart.MeansSeries.EvaluateRules(ControlRuleSets.Nelson)
Console.WriteLine($"XBar rule violations: {rules.Violations.Count}")

Dim specs = New SpecificationLimits(Lower:=21.0, Upper:=27.0)
Dim cap As CapabilityAnalysisResult = Capability.Analyze(subgroups, specs)
Console.WriteLine($"Cpk = {cap.Cpk:F3}")

No code example is currently available or this language may not be supported.

let rawData = array2D [|
    [| 23.1; 24.0; 22.8; 24.5 |]
    [| 23.3; 24.8; 22.5; 24.2 |]
    [| 23.7; 24.1; 23.4; 24.3 |]
    [| 23.6; 24.0; 23.2; 24.4 |]
    [| 23.0; 24.6; 22.9; 24.1 |]
|]
let subgroups = Matrix.CopyFrom(rawData)

let chart = new XBarRChartSet(subgroups)
chart.Analyze()
printfn "XBar UCL=%.3f" chart.MeansSeries.UpperControlLimit

let rules = chart.MeansSeries.EvaluateRules(ControlRuleSets.Nelson)
printfn "XBar rule violations: %d" rules.Violations.Count

let specs = SpecificationLimits(Lower = Nullable(21.0), Upper = Nullable(27.0))
let cap = Capability.Analyze(subgroups, specs)
printfn "Cpk = %.3f" (cap.Cpk.GetValueOrDefault())

Reading the result. The fitted XBarRChartSet exposes separate series for the XBar chart (monitoring the subgroup mean) and the R chart (monitoring the subgroup range). Stability must be evaluated on both charts. An R chart out of control indicates that within-subgroup variation itself is unstable, which invalidates the XBar control limits. If both charts show control, the capability section will report $C_p$ and $C_{pk}$ using the pooled within-subgroup range estimator.

Scenario. A circuit-board assembly line inspects every board in each production lot, but lot sizes vary from 50 to 300 boards. The quality metric is the proportion defective per lot. Because the denominator changes from lot to lot, the control limits must be recalculated individually for each point.

Input shape. Two parallel sequences of equal length: a sequence of defective counts (integers or doubles) and a sequence of sample sizes (integers). The sample sizes may all differ. Do not pre-compute proportions and pass them as the first sequence; the API requires raw counts so it can compute Poisson or binomial limits correctly.

// Recipe: Variable sample-size P chart
Vector<double> defects = Vector.Create(
    new double[] { 3, 5, 2, 7, 4, 6, 3, 8, 2, 5 });
Vector<double> sizes = Vector.Create(
    new double[] { 50, 60, 45, 70, 55, 65, 50, 80, 45, 60 });

PChart chart = new PChart(defects, sizes);
chart.Analyze();

Console.WriteLine($"P bar = {chart.Series.CenterLine:F4}");

// Render with pointwise limits
Vector<double> pts  = chart.Series.Values;
Vector<double> ucls = chart.Series.UpperControlLimits;
for (int i = 0; i < pts.Count; i++)
    Console.WriteLine(
        $"  [{i}] p={pts[i]:F4} " +
        $"UCL={ucls[i]:F4}");

Dim defects As Vector(Of Double) = Vector.Create(
    New Double() {3, 5, 2, 7, 4, 6, 3, 8, 2, 5})
Dim sizes As Vector(Of Double) = Vector.Create(
    New Double() {50, 60, 45, 70, 55, 65, 50, 80, 45, 60})

Dim chart As New PChart(defects, sizes)
chart.Analyze()

Console.WriteLine($"P bar = {chart.Series.CenterLine:F4}")
Dim pts As Vector(Of Double) = chart.Series.Values
Dim ucls As Vector(Of Double) = chart.Series.UpperControlLimits
For i As Integer = 0 To pts.Count - 1
    Console.WriteLine($"  [{i}] p={pts(i):F4} UCL={ucls(i):F4}")
Next

No code example is currently available or this language may not be supported.

let defects = Vector.Create([| 3.0; 5.0; 2.0; 7.0; 4.0; 6.0; 3.0; 8.0; 2.0; 5.0 |])
let sizes = Vector.Create([| 50.0; 60.0; 45.0; 70.0; 55.0; 65.0; 50.0; 80.0; 45.0; 60.0 |])

let chart = new PChart(defects, sizes)
chart.Analyze()

printfn "P bar = %g" chart.Series.CenterLine
let pts  = chart.Series.Values
let ucls = chart.Series.UpperControlLimits
for i in 0 .. pts.Count - 1 do
    printfn "  [%d] p=%g UCL=%g" i pts.[i] ucls.[i]

Reading the result. Because sample sizes differ, each plotted point has its own pair of upper and lower control limits. The result model exposes per-point limit vectors; do not read a single scalar limit from the result and apply it to all points. Points where the computed lower control limit would be negative are floored at zero. See Result Model and Rendering Semantics for details on accessing per-point vectors.

Scenario. After confirming an XBar‑R process is in control (Recipe 2), the team needs to produce a formal capability report that includes a normality test so the customer can evaluate whether the standard $C_p$/$C_{pk}$ indices are valid for this process.

Input shape. The same subgrouped data as Recipe 2, plus a SpecificationLimits class with at minimum one non-null limit, and the flag assumptionDiagnostics: true passed to the analysis call.

// Recipe: Capability analysis with assumption diagnostics
double[] data = {
    23.1, 24.0, 22.8, 24.5, 23.3, 24.8, 22.5, 24.2,
    23.7, 24.1, 23.4, 24.3, 23.6, 24.0, 23.2, 24.4,
    23.0, 24.6, 22.9, 24.1
};
Vector<double> obs = Vector.Create(data);
var specs = new SpecificationLimits(Lower: 21.0, Upper: 27.0);

// 1. Chart analysis
IndividualsMovingRangeChartSet chart =
    new IndividualsMovingRangeChartSet(obs);
chart.Analyze();
bool stable =
    !chart.IndividualsSeries.EvaluateRules(ControlRuleSets.Nelson).HasViolations;
Console.WriteLine($"Stable: {stable}");

// 2. Capability (request normality testing)
CapabilityAnalysisResult cap = Capability.Analyze(
    obs, specs,
    normalityTest: TestOfNormality.ShapiroWilk);
Console.WriteLine($"Cp={cap.Cp:F3} Cpk={cap.Cpk:F3}");
Console.WriteLine($"Pp={cap.Pp:F3} Ppk={cap.Ppk:F3}");

// 3. Assumption diagnostics from the capability result
AssumptionDiagnostics? diag = cap.Diagnostics;
if (diag?.NormalityTest != null)
    Console.WriteLine(
        $"Normality p = {diag.NormalityTest.PValue:F4}");

Dim data As Double() = {
    23.1, 24.0, 22.8, 24.5, 23.3, 24.8, 22.5, 24.2,
    23.7, 24.1, 23.4, 24.3, 23.6, 24.0, 23.2, 24.4,
    23.0, 24.6, 22.9, 24.1
}
Dim obs As Vector(Of Double) = Vector.Create(data)
Dim specs = New SpecificationLimits(Lower:=21.0, Upper:=27.0)

Dim chart As New IndividualsMovingRangeChartSet(obs)
chart.Analyze()
Dim stable As Boolean = Not chart.IndividualsSeries.EvaluateRules(ControlRuleSets.Nelson).HasViolations
Console.WriteLine($"Stable: {stable}")

Dim cap As CapabilityAnalysisResult = Capability.Analyze(
    obs, specs,
    normalityTest:=TestOfNormality.ShapiroWilk)
Console.WriteLine($"Cp={cap.Cp:F3} Cpk={cap.Cpk:F3}")
Console.WriteLine($"Pp={cap.Pp:F3} Ppk={cap.Ppk:F3}")

Dim diag As AssumptionDiagnostics = cap.Diagnostics
If diag IsNot Nothing AndAlso diag.NormalityTest IsNot Nothing Then
    Console.WriteLine($"Normality p = {diag.NormalityTest.PValue:F4}")
End If

No code example is currently available or this language may not be supported.

let data = [|
    23.1; 24.0; 22.8; 24.5; 23.3; 24.8; 22.5; 24.2
    23.7; 24.1; 23.4; 24.3; 23.6; 24.0; 23.2; 24.4
    23.0; 24.6; 22.9; 24.1
|]
let obs = Vector.Create(data)
let specs = SpecificationLimits(Lower = Nullable(21.0), Upper = Nullable(27.0))

let chart = new IndividualsMovingRangeChartSet(obs)
chart.Analyze()
let stable = not (chart.IndividualsSeries.EvaluateRules(ControlRuleSets.Nelson).HasViolations)
printfn "Stable: %b" stable

let cap = Capability.Analyze(
    obs, specs,
    normalityTest = TestOfNormality.ShapiroWilk)
printfn "Cp=%.3f Cpk=%.3f" (cap.Cp.GetValueOrDefault()) (cap.Cpk.GetValueOrDefault())
printfn "Pp=%.3f Ppk=%.3f" (cap.Pp.GetValueOrDefault()) (cap.Ppk.GetValueOrDefault())

let diag = cap.Diagnostics
if diag <> null && diag.NormalityTest <> null then
    printfn "Normality p = %.4f" diag.NormalityTest.PValue

Reading the result. The AssumptionDiagnostics object is returned alongside the CapabilityAnalysisResult. Check the PValue from the normality test (accessible via NormalityTest). A p-value above 0.05 does not contradict normality; a value below 0.05 warrants investigation before submitting the $C_{pk}$ figure. The capability indices themselves are always computed regardless of the test outcome. For a full discussion, see Capability, Performance, and Assumption Diagnostics.

Scenario. A web service computes SPC results on a background worker and needs to cache or transmit the result to a front-end that renders the chart. The front-end should not re-run the analysis; it should deserialize the result and read the per-point vectors directly for rendering without any further computation.

Input shape. A previously computed fitted chart. After calling Analyze(), the chart object is self-contained and can be serialized via its ToJson() method. All plotted values, control limits, and rule violation flags are stored as immutable vectors and survive a round-trip. See Integration and Persistence for serializer configuration details.

// Recipe: Serialize and restore a deployed chart
double[] data = {
    23.1, 24.0, 22.8, 24.5, 23.3, 24.8, 22.5, 24.2, 23.7, 24.1
};

// 1. Fit the chart
IndividualsMovingRangeChartSet original =
    new IndividualsMovingRangeChartSet(Vector.Create(data));
original.Analyze();

// 2. Deploy (freeze parameters) and serialize
IndividualsMovingRangeChartSet deployed = original.Deploy();
string json = deployed.ToJson();

// 3. Restore from JSON (e.g., from database or API response)
IndividualsMovingRangeChartSet restored =
    IndividualsMovingRangeChartSet.FromJson(json);

Console.WriteLine(
    $"Original CL = {original.IndividualsSeries.CenterLine:F4}");
Console.WriteLine(
    $"Restored CL = {restored.IndividualsSeries.CenterLine:F4}");

Dim data As Double() = {
    23.1, 24.0, 22.8, 24.5, 23.3, 24.8, 22.5, 24.2, 23.7, 24.1
}

Dim original As New IndividualsMovingRangeChartSet(Vector.Create(data))
original.Analyze()

Dim deployed As IndividualsMovingRangeChartSet = original.Deploy()
Dim json As String = deployed.ToJson()

Dim restored As IndividualsMovingRangeChartSet =
    IndividualsMovingRangeChartSet.FromJson(json)

Console.WriteLine($"Original CL = {original.IndividualsSeries.CenterLine:F4}")
Console.WriteLine($"Restored CL = {restored.IndividualsSeries.CenterLine:F4}")

No code example is currently available or this language may not be supported.

let data = [| 23.1; 24.0; 22.8; 24.5; 23.3; 24.8; 22.5; 24.2; 23.7; 24.1 |]

let original = new IndividualsMovingRangeChartSet(Vector.Create(data))
original.Analyze()

let deployed = original.Deploy()
let json = deployed.ToJson()

let restored = IndividualsMovingRangeChartSet.FromJson(json)

printfn "Original CL = %g" original.IndividualsSeries.CenterLine
printfn "Restored CL = %g" restored.IndividualsSeries.CenterLine

Reading the result. After deserialization the restored object is functionally identical to the original: all indexed vectors are present at the same positions, control limits match, and rule violation flags are preserved. The receiver does not need access to the original raw data at all. This pattern is the recommended approach for any architecture that separates the computation tier from the presentation tier.

Scenario. A manufacturing line has completed Phase I baseline estimation. New batches arrive daily and must be plotted against the frozen control limits. The baseline chart is persisted to JSON and restored on each monitoring run.

Workflow.

1. Fit the chart with Analyze() during Phase I.

2. Call Deploy() to create a deployed chart that holds frozen control limits and discards the original observations.

3. Serialize the deployed chart with ToJson() and store it.

4. When new data arrives, restore the deployed chart with FromJson() and call Apply(Vector<Double>) to produce a new fitted chart evaluated against the frozen baseline.

This pattern supports charts-only monitoring without rules or capability analysis—simply inspect the plotted values and control limits after Apply(Vector<Double>).

Other Resources