Result Model

After calling Analyze() on a chart object, the chart exposes its analysis results through typed series properties. This page describes the shared properties available on all ControlSeries subtypes, explains the difference between scalar and pointwise control limits, documents the RuleViolation window model, and gives guidance on translating the result object into a visual chart.

All concrete chart-data types inherit from ControlSeries, which exposes Values and Index. Control-limit properties are defined on FixedLimitSeries (for charts with constant limits) and on PointwiseLimitSeries (for P, U, and EWMA charts with per-point limits).

The length of the <codeEntityReference>P:Numerics.NET.Statistics.ProcessControl.ControlSeries.Values</codeEntityReference> vector depends on the chart family:

• Individuals charts: one point per observation, so Values.Length equals the number of values passed in.

• XBar, XBar‑R, XBar‑S, P, NP, C, U charts : one point per subgroup. For a matrix input with k rows, Values.Length == k.

• EWMA and CUSUM charts: one point per observation, mirroring the individuals layout.

When displaying a control chart alongside a time axis or subgroup-number axis, map index i in Values to the (i+1)-th tick on the axis.

For chart families where every point shares the same control limit (equal subgroup sizes), the scalar UpperControlLimit and LowerControlLimit properties are sufficient for rendering.

For P and U charts with variable subgroup sizes, the 3-sigma limits vary from point to point because they depend on n_i. In this case:

• PChart and UChart expose UpperControlLimits and LowerControlLimits vectors (plural) alongside the scalar summary properties.

• When rendering, prefer the vectors over the scalars. Draw each limit as a step function or connected line through the per-point values.

• P and U charts do not expose scalar UpperControlLimit / LowerControlLimit properties. Always use the UpperControlLimits and LowerControlLimits vectors for both rendering and violation detection.

Vector<double> defects =
    Vector.Create(new double[] { 3, 5, 2, 7, 4, 6 });
Vector<double> sampleSizes =
    Vector.Create(new double[] { 50, 60, 45, 70, 55, 65 });

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

// CORRECT: use pointwise vectors for variable-sample P/U charts
Vector<double> upperLimits = chart.Series.UpperControlLimits;
Vector<double> lowerLimits = chart.Series.LowerControlLimits;
Vector<double> points = chart.Series.Values;

for (int i = 0; i < points.Count; i++)
{
    Console.WriteLine(
        $"Point {i}: p={points[i]:F4} " +
        $"LCL={lowerLimits[i]:F4} UCL={upperLimits[i]:F4}");
}
// NOTE: in Deployed state per-point limits are not available;
// use chart.Apply(newCounts, newSizes) to obtain fresh pointwise limits.

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

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

Dim upperLimits As Vector(Of Double) = chart.Series.UpperControlLimits
Dim lowerLimits As Vector(Of Double) = chart.Series.LowerControlLimits
Dim points As Vector(Of Double) = chart.Series.Values
For i As Integer = 0 To points.Count - 1
    Console.WriteLine(
        $"Point {i}: p={points(i):F4} " &
        $"LCL={lowerLimits(i):F4} UCL={upperLimits(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 |])
let sampleSizes = Vector.Create([| 50.0; 60.0; 45.0; 70.0; 55.0; 65.0 |])

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

let upperLimits = chart.Series.UpperControlLimits
let lowerLimits = chart.Series.LowerControlLimits
let points = chart.Series.Values
for i in 0 .. points.Count - 1 do
    printfn "Point %d: p=%g LCL=%g UCL=%g"
        i points.[i] lowerLimits.[i] upperLimits.[i]

The table below summarizes the point unit and limit layout for each chart family.

When a run rule fires, the library records a RuleViolation object with the following properties:

The typical pattern for highlighting a violation window is:

1. Iterate the Violations collection on RuleSetEvaluation.

2. For each violation, shade the horizontal region from x = WindowStart - 0.5 to x = WindowStart + WindowLength - 0.5 with a warning color.

3. Render the trigger point at TriggerIndex with a distinct marker (e.g., filled circle vs. open circle) so that the exact trigger is identifiable at a glance.

double[] data = {
    10.5, 11.2, 10.8, 11.5, 10.3, 11.8, 10.1, 11.4,
    10.9, 11.1, 10.6, 11.3, 10.7, 11.0, 10.4
};
IndividualsMovingRangeChartSet chart =
    new IndividualsMovingRangeChartSet(Vector.Create(data));
chart.Analyze();

RuleSetEvaluation ruleResult =
    chart.IndividualsSeries.EvaluateRules(ControlRuleSets.Nelson);

foreach (RuleViolation v in ruleResult.Violations)
{
    int windowEnd = v.WindowStart + v.WindowLength - 1;
    // Shade the violation window in your charting layer:
    // chart.AddHighlight(v.WindowStart, windowEnd, color: Red);
    Console.WriteLine(
        $"[{v.RuleId}] Highlight points {v.WindowStart}..{windowEnd}");
}

Dim data As Double() = {
    10.5, 11.2, 10.8, 11.5, 10.3, 11.8, 10.1, 11.4,
    10.9, 11.1, 10.6, 11.3, 10.7, 11.0, 10.4
}
Dim chart As New IndividualsMovingRangeChartSet(Vector.Create(data))
chart.Analyze()

Dim ruleResult As RuleSetEvaluation = chart.IndividualsSeries.EvaluateRules(ControlRuleSets.Nelson)
For Each v As RuleViolation In ruleResult.Violations
    Dim windowEnd As Integer = v.WindowStart + v.WindowLength - 1
    Console.WriteLine($"[{v.RuleId}] Highlight points {v.WindowStart}..{windowEnd}")
Next

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

let data = [|
    10.5; 11.2; 10.8; 11.5; 10.3; 11.8; 10.1; 11.4
    10.9; 11.1; 10.6; 11.3; 10.7; 11.0; 10.4
|]
let chart = new IndividualsMovingRangeChartSet(Vector.Create(data))
chart.Analyze()

let ruleResult = chart.IndividualsSeries.EvaluateRules(ControlRuleSets.Nelson)
for v in ruleResult.Violations do
    let windowEnd = v.WindowStart + v.WindowLength - 1
    printfn "[%s] Highlight points %d..%d" v.RuleId v.WindowStart windowEnd

The minimal steps to render any control chart are the same regardless of charting library:

1. Plot Values as the primary data series (line + markers).

2. Draw CenterLine as a solid horizontal reference line.

3. Draw UpperControlLimit and LowerControlLimit as dashed horizontal lines (or per-point series for variable-limit charts).

4. Overlay violation highlights using the window model described above.

double[] data = {
    10.5, 11.2, 10.8, 11.5, 10.3, 11.8, 10.1, 11.4, 10.9, 11.1
};
IndividualsMovingRangeChartSet chart =
    new IndividualsMovingRangeChartSet(Vector.Create(data));
chart.Analyze();

FixedLimitSeries iSeries = chart.IndividualsSeries;

// Map to a hypothetical plotting API:
// chartSeries.Add("I", iSeries.Values);
// chartSeries.AddHorizontalLine("CL", iSeries.CenterLine);
// chartSeries.AddHorizontalLine("UCL", iSeries.UpperControlLimit);
// chartSeries.AddHorizontalLine("LCL", iSeries.LowerControlLimit);
Console.WriteLine($"Points: {iSeries.Values.Count}");
Console.WriteLine(
    $"CL={iSeries.CenterLine:F4} UCL={iSeries.UpperControlLimit:F4}");

Dim data As Double() = {
    10.5, 11.2, 10.8, 11.5, 10.3, 11.8, 10.1, 11.4, 10.9, 11.1
}
Dim chart As New IndividualsMovingRangeChartSet(Vector.Create(data))
chart.Analyze()

Dim iSeries As FixedLimitSeries = chart.IndividualsSeries
Console.WriteLine($"Points: {iSeries.Values.Count}")
Console.WriteLine($"CL={iSeries.CenterLine:F4} UCL={iSeries.UpperControlLimit:F4}")

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

let data = [| 10.5; 11.2; 10.8; 11.5; 10.3; 11.8; 10.1; 11.4; 10.9; 11.1 |]
let chart = new IndividualsMovingRangeChartSet(Vector.Create(data))
chart.Analyze()

let iSeries = chart.IndividualsSeries
printfn "Points: %d" iSeries.Values.Count
printfn "CL=%g UCL=%g" iSeries.CenterLine iSeries.UpperControlLimit

Other Resources