Data Contracts

This page describes the data contracts the SPC library expects from callers: which .NET types are accepted, how observations must be ordered, how subgroups are represented, and what the library does when input data is missing, invalid, or too small to support a statistically meaningful result.

Understanding these contracts before calling any chart or capability API prevents the most common runtime exceptions and ensures that the resulting charts reflect the true process.

All SPC entry points accept numeric data through one of three .NET types. Choose the type that matches how your application already holds its data to avoid unnecessary copying.

The library always treats data as if it were collected in time order. The first element of a Vector<T> (index 0) represents the earliest observation, and the last element represents the most recent.

If your data store returns rows in reverse-chronological order (newest first), reverse the collection before constructing the input vector.

The SPC library supports two subgroup layouts: equal-sized subgroups supplied as a matrix, and variable-sized subgroups supplied as a flat vector paired with a subgroup-ID vector.

Equal-Sized Subgroups

Pass a Matrix<T> where each row is one subgroup and every row has the same number of columns. The library derives n from the column count at construction time.

// Subgroups as a Matrix: rows = subgroups, columns = measurements
double[,] data = {
    {  9.8, 10.2, 10.0, 10.1 },
    { 10.3,  9.9, 10.1, 10.2 },
    {  9.7, 10.4,  9.8, 10.0 },
    { 10.1, 10.0,  9.9, 10.3 },
    { 10.2,  9.8, 10.2, 10.1 }
};
Matrix<double> subgroups = Matrix.CopyFrom(data);

XBarRChartSet chart = new XBarRChartSet(subgroups);
chart.Analyze();
Console.WriteLine($"XBar CL  = {chart.MeansSeries.CenterLine:F4}");
Console.WriteLine($"XBar UCL = {chart.MeansSeries.UpperControlLimit:F4}");

Dim data As Double(,) = {
    {9.8, 10.2, 10.0, 10.1},
    {10.3, 9.9, 10.1, 10.2},
    {9.7, 10.4, 9.8, 10.0},
    {10.1, 10.0, 9.9, 10.3},
    {10.2, 9.8, 10.2, 10.1}
}
Dim subgroups As Matrix(Of Double) = Matrix.CopyFrom(data)

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

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

let data = array2D [|
    [|  9.8; 10.2; 10.0; 10.1 |]
    [| 10.3;  9.9; 10.1; 10.2 |]
    [|  9.7; 10.4;  9.8; 10.0 |]
    [| 10.1; 10.0;  9.9; 10.3 |]
    [| 10.2;  9.8; 10.2; 10.1 |]
|]
let subgroups = Matrix.CopyFrom(data)

let chart = new XBarRChartSet(subgroups)
chart.Analyze()
printfn "XBar CL  = %g" chart.MeansSeries.CenterLine
printfn "XBar UCL = %g" chart.MeansSeries.UpperControlLimit

This layout feeds XBarRChartSet and XBarSChartSet directly.

Variable-Sized Subgroups

When subgroups differ in size, pass the measurements as a flat Vector<T> together with an integer vector of subgroup IDs or a vector of subgroup sizes. The library uses the ID vector to partition the flat data into subgroups at analysis time.

// Variable-size subgroups: provide defect counts + sample sizes per subgroup
Vector<double> defects =
    Vector.Create(new double[] { 3, 5, 2, 7, 4 });
Vector<double> sampleSizes =
    Vector.Create(new double[] { 50, 60, 45, 70, 55 });

PChart chart = new PChart(defects, sampleSizes);
chart.Analyze();
// P chart produces pointwise limits that vary with sample size
Vector<double> upperLimits = chart.Series.UpperControlLimits;
Vector<double> lowerLimits = chart.Series.LowerControlLimits;
Console.WriteLine(
    $"UCL[0] = {upperLimits[0]:F4}  UCL[4] = {upperLimits[4]:F4}");

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

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
Console.WriteLine($"UCL[0] = {upperLimits(0):F4}  UCL[4] = {upperLimits(4):F4}")

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 |])
let sampleSizes = Vector.Create([| 50.0; 60.0; 45.0; 70.0; 55.0 |])

let chart = new PChart(defects, sampleSizes)
chart.Analyze()
let upperLimits = chart.Series.UpperControlLimits
printfn "UCL[0] = %g  UCL[4] = %g" upperLimits.[0] upperLimits.[4]

Individuals charts expect a single Vector<T> of measurements. The moving-range chart is computed internally from successive differences; callers do not supply the moving-range values directly.

// Provide observations as a Vector<double>
double[] data = { 9.8, 10.2, 10.0, 9.9, 10.1, 10.3, 9.7, 10.4 };
Vector<double> observations = Vector.Create(data);

IndividualsMovingRangeChartSet chart =
    new IndividualsMovingRangeChartSet(observations);
chart.Analyze();
Console.WriteLine(
    $"Individuals CL = {chart.IndividualsSeries.CenterLine:F4}");

Dim data As Double() = {9.8, 10.2, 10.0, 9.9, 10.1, 10.3, 9.7, 10.4}
Dim observations As Vector(Of Double) = Vector.Create(data)

Dim chart As New IndividualsMovingRangeChartSet(observations)
chart.Analyze()
Console.WriteLine($"Individuals CL = {chart.IndividualsSeries.CenterLine:F4}")

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

let data = [| 9.8; 10.2; 10.0; 9.9; 10.1; 10.3; 9.7; 10.4 |]
let observations = Vector.Create(data)

let chart = new IndividualsMovingRangeChartSet(observations)
chart.Analyze()
printfn "Individuals CL = %g" chart.IndividualsSeries.CenterLine

The IndividualsMovingRangeChartSet type holds both the individuals chart data and the moving-range chart data after the analysis completes.

The library enforces strict numeric validity. Any observation that is double.NaN, double.PositiveInfinity, or double.NegativeInfinity causes the analysis method to throw an ArgumentException identifying the offending index.

See Diagnostics, Exceptions, and Failure Modes for the full list of exceptions thrown on invalid input and for patterns to validate data before the call.

Control-limit computation requires enough data points to produce a stable within-process sigma estimate. The table below lists the hard minimums enforced by the library; passing fewer observations than the minimum throws an ArgumentException.

Attribute charts impose additional domain constraints on top of the general numeric-validity rules:

Other Resources