@things-factory/spc 7.0.0-alpha.6

package/helps/spc/spc-chart-concept.md

@@ -0,0 +1,59 @@
+## 품질 통계 제어 차트 (SPC) - 기본 이해
+
+### 개요
+
+품질 통계 제어 차트(SPC)는 제조 및 공정에서 제품 또는 서비스의 품질을 모니터링하고 제어하는 데 사용되는 강력한 도구입니다. SPC는 데이터를 수집하고 분석하여 공정 불안정성, 불규칙성 및 변동성을 식별하며 품질을 개선하는 데 도움이 됩니다.
+
+### SPC의 목적
+
+1. **품질 향상**: SPC는 제품 또는 서비스의 일관된 품질을 유지하고 개선하는 데 사용됩니다.
+
+2. **불량 감소**: 불량품의 생산을 방지하고 불량율을 줄입니다.
+
+3. **비용 절감**: 품질을 모니터링하고 개선함으로써 리워크 및 반송을 줄이고 생산 비용을 절감합니다.
+
+### SPC 차트 종류
+
+1. **X-Bar 및 R 차트**: 공정에서 나온 제품 또는 샘플의 평균 (X-Bar) 및 범위 (R)를 추적하여 공정의 안정성을 확인합니다. 이러한 차트는 연속 데이터에 사용됩니다.
+
+2. **P 차트**: 비율 또는 비율 데이터의 불량률을 모니터링하는 데 사용됩니다.
+
+3. **NP 차트**: 개별 항목의 불량 또는 불량이 아닌 개수를 추적하는 데 사용됩니다.
+
+4. **C 차트**: 개별 항목의 불량 수를 추적하는 데 사용되며, 항목 수가 일정할 때 적합합니다.
+
+5. **U 차트**: 개별 항목의 단위당 불량 수를 추적하는 데 사용됩니다.
+
+6. **I 차트 (Individuals Chart)**: 개별 항목의 변동성을 추적하는 데 사용됩니다.
+
+7. **MR 차트 (Moving Range Chart)**: 변동성이 불규칙하거나 시간에 따라 변할 때 개별 항목 간의 이동 범위를 추적합니다.
+
+8. **Histogram 차트**: 데이터 분포를 히스토그램으로 표시하여 데이터의 분포 및 주요 특성을 시각화합니다.
+
+9. **Pareto 차트**: 주요 원인 또는 카테고리를 중요도에 따라 시각화하여 가장 중요한 문제를 식별합니다.
+
+### SPC의 주요 단계
+
+1. **데이터 수집**: 공정 또는 제조과정에서 데이터를 수집하고 기록합니다.
+
+2. **데이터 분석**: 수집한 데이터를 분석하여 통계적 특성을 확인하고 이상 현상을 탐지합니다.
+
+3. **차트 작성**: 적절한 SPC 차트를 선택하고 데이터를 차트에 입력하여 표시합니다.
+
+4. **관리 및 대응**: 차트를 모니터링하고 통계적 이상 현상 또는 규칙 위반을 식별하면 조치를 취하여 공정을 안정화하고 품질을 향상시킵니다.
+
+### SPC의 이점
+
+1. **품질 개선**: 불량품의 생산을 줄이고 제품 또는 서비스의 일관된 품질을 유지합니다.
+
+2. **비용 절감**: 리워크 및 반송 비용을 감소시키며 생산 효율성을 높입니다.
+
+3. **문제 식별**: 통계적 규칙을 통해 문제를 신속하게 식별하고 조치를 취할 수 있습니다.
+
+4. **결정 기반**: 데이터에 기반한 의사 결정을 내릴 수 있으며, 과학적인 방법으로 문제를 해결합니다.
+
+5. **고객 만족도 향상**: 일관된 품질로 인해 고객 만족도가 향상됩니다.
+
+### 마무리
+
+품질 통계 제어 차트(SPC)는 제조 및 공정에서 품질을 모니터링하고 제어하는 데 필수적인 도구입니다. 적절한 SPC 차트를 사용하고 데이터를 분석하여 품질 문제를 식별하고 해결함으로써 품질을 개선하고 비용을 절감할 수 있습니다. SPC는 효율적인 생산 및 고객 만족도 향상을 위한 중요한 도구 중 하나입니다.

package/helps/spc/spc-chart.md

@@ -0,0 +1,68 @@
+각각의 SPC(통계적 공정 통제) 차트는 다양한 특성을 가지고 있으며, 그 특성에 맞게 적절한 차트를 사용하여야 합니다.
+
+1. **X-bar (X-막대) 차트**:
+
+   - **목적**: 공정에서 발생하는 평균값의 변화를 모니터링하고 제어합니다.
+   - **특성**: 평균값의 변화를 추적하며 중심 경향성을 확인합니다.
+   - **측정값**: 연속적인 데이터 (예: 제품 무게, 길이 등)
+   - **제어 한계선**: UCL(Upper Control Limit), LCL(Lower Control Limit)로 평균값의 허용 범위 설정
+
+2. **R (범위) 차트**:
+
+   - **목적**: 공정의 변동성을 추적하고 제어합니다.
+   - **특성**: 데이터 범위의 변화를 확인하여 불규칙한 변동성을 감지합니다.
+   - **측정값**: 연속적인 데이터 (예: 제품 두께, 길이 등)
+   - **제어 한계선**: UCL, LCL로 범위의 허용 범위 설정
+
+3. **P 차트**:
+
+   - **목적**: 이항 데이터(성공 또는 실패)에서 비율을 추적하고 제어합니다.
+   - **특성**: 비율의 변화를 확인하여 불량품 비율의 변화를 감지합니다.
+   - **측정값**: 이항 데이터 (예: 제품 불량 여부)
+   - **제어 한계선**: UCL, LCL로 비율의 허용 범위 설정
+
+4. **NP 차트**:
+
+   - **목적**: 이항 데이터에서 표본 크기를 고려하여 비율을 추적하고 제어합니다.
+   - **특성**: 표본 크기를 고려한 비율의 변화를 확인하여 불량품 수의 변화를 감지합니다.
+   - **측정값**: 이항 데이터 및 표본 크기 (예: 제품 불량 여부 및 표본 크기)
+   - **제어 한계선**: UCL, LCL로 비율의 허용 범위 설정
+
+5. **C 차트**:
+
+   - **목적**: 개수 데이터에서 불량 수를 추적하고 제어합니다.
+   - **특성**: 불량품 수의 변화를 확인하여 불량품 수의 변화를 감지합니다.
+   - **측정값**: 개수 데이터 (예: 결함 수)
+   - **제어 한계선**: UCL, LCL로 불량품 수의 허용 범위 설정
+
+6. **U 차트**:
+
+   - **목적**: 개수 데이터에서 단위당 불량률을 추적하고 제어합니다.
+   - **특성**: 단위당 불량률의 변화를 확인하여 단위당 불량률의 변화를 감지합니다.
+   - **측정값**: 개수 데이터 (예: 결함 수) 및 단위 수
+   - **제어 한계선**: UCL, LCL로 단위당 불량률의 허용 범위 설정
+
+7. **I 차트**:
+
+   - **목적**: 개별 항목의 품질을 추적하고 제어합니다.
+   - **특성**: 개별 항목의 변화를 확인하여 개별 항목의 품질 변화를 감지합니다.
+   - **측정값**: 연속적인 데이터 (예: 길이, 무게)
+   - **제어 한계선**: UCL, LCL로 개별 항목의 품질의 허용 범위 설정
+
+8. **MR (이동 범위) 차트**:
+
+   - **목적**: 개별 항목의 이동 범위를 추적하고 제어합니다.
+   - **특성**: 이동 범위의 변화를 확인하여 개별 항목의 변동성 변화를 감지합니다.
+   - **측정값**: 연속적인 데이터 (예: 길이, 무게)
+   - **제어 한계선**: UCL, LCL로 이동 범위의 허용 범위 설정
+
+9. **Histogram (히스토그램) 차트**:
+
+   - **목적**: 데이터 분포를 시각화하여 데이터의 분포를 이해하고 품질 문제를 발견하는 데 도움을 줍니다.
+   - **특성**: 데이터 분포를 막대 그래프로 표현하여 주요 특성을 확인합니다.
+   - **측정값**: 연속적인 데이터 (예: 제품 무게, 길이 등)
+
+10. **Pareto (파레토) 차트**:
+    - **목적**: 주요 원인을 식별하고 우선 순위를 정하기 위한 도구로 사용됩니다.
+    - **특성**: 가장 중요한 원인부터 우선 순위대로 나열하여 시각화합니다.
+    - **측정값**: 주로 불량 종류 또는 문제 유형에 대한 데이터 (예: 불량 종류, 문제 유형)

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@things-factory/spc",
+  "version": "7.0.0-alpha.6",
+  "main": "dist-server/index.js",
+  "browser": "dist-client/index.js",
+  "things-factory": true,
+  "author": "heartyoh <heartyoh@hatiolab.com>",
+  "description": "module for handling SPC (Statistical Process Control)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "@things-factory:registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hatiolab/things-factory.git",
+    "directory": "packages/spc"
+  },
+  "scripts": {
+    "build": "npm run build:server && npm run build:client",
+    "copy:files": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
+    "build:client": "npm run copy:files && npx tsc --p ./client/tsconfig.json",
+    "build:server": "npx tsc --p ./server/tsconfig.json",
+    "clean:client": "npx rimraf dist-client",
+    "clean:server": "npx rimraf dist-server",
+    "clean": "npm run clean:server && npm run clean:client",
+    "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
+  },
+  "dependencies": {
+    "@operato/dataset": "^2.0.0-alpha.0",
+    "@operato/spc": "^2.0.0-alpha.0",
+    "@things-factory/dataset": "^7.0.0-alpha.6",
+    "@things-factory/shell": "^7.0.0-alpha.6"
+  },
+  "gitHead": "cf46b4e03d6312f7ccb366a3c9fc2df16c68b7fa"
+}

package/server/controllers/data-use-case-spc.ts

@@ -0,0 +1,44 @@
+import { DataItemSpecSet, DataUseCase, EvaluationResult } from '@things-factory/dataset'
+
+export class DataUseCaseSPC implements DataUseCase {
+  getSpecification(): DataItemSpecSet {
+    return {
+      name: 'SPC',
+      description: 'Statistical Process Control Data Spec',
+      help: '',
+      specs: [
+        {
+          type: 'spc-limits' /* 'A value which seperates acceptability from unacceptability' */,
+          label: 'control limits',
+          name: 'controlLimits'
+        }
+      ]
+    }
+  }
+
+  evaluate(spec: any, values: any | any[]): EvaluationResult {
+    const { minimum, maximum, acceptables } = spec['controlLimits']
+
+    if (!(values instanceof Array)) {
+      values = [values]
+    }
+
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i]
+
+      if (minimum != null && value < minimum) {
+        return { oos: true, ooc: true }
+      }
+
+      if (maximum != null && value > maximum) {
+        return { oos: true, ooc: true }
+      }
+
+      if (acceptables != null && !acceptables.includes(value)) {
+        return { oos: true, ooc: true }
+      }
+    }
+
+    return { oos: false, ooc: false }
+  }
+}

package/server/controllers/index.ts

@@ -0,0 +1 @@
+export * from './data-use-case-spc'

package/server/controllers/spc-/bchart/c.ts

@@ -0,0 +1,31 @@
+interface CChartData {
+  period: string // 샘플 기간 또는 단위 식별자
+  defects: number // 해당 기간 또는 단위에서 발생한 결함 수
+}
+
+interface CChartResult {
+  CBar: number // 평균 결함 수
+  UCL: number // 상한 제어선
+  LCL: number // 하한 제어선
+  data: CChartData[] // 입력된 결함 데이터
+}
+
+export function calculateCChart(data: CChartData[]): CChartResult {
+  // 총 결함 수를 계산합니다.
+  const totalDefects = data.reduce((sum, { defects }) => sum + defects, 0)
+
+  // 평균 결함 수(C-bar)를 계산합니다.
+  const CBar = totalDefects / data.length
+
+  // 상한 제어선(UCL)과 하한 제어선(LCL)을 계산합니다.
+  // 포아송 분포를 가정할 때, UCL = C-bar + 3*sqrt(C-bar), LCL = C-bar - 3*sqrt(C-bar) (단, LCL이 음수인 경우 0으로 설정)
+  const UCL = CBar + 3 * Math.sqrt(CBar)
+  const LCL = Math.max(CBar - 3 * Math.sqrt(CBar), 0)
+
+  return {
+    CBar,
+    UCL,
+    LCL,
+    data
+  }
+}

package/server/controllers/spc-/bchart/histogram.ts

@@ -0,0 +1,40 @@
+interface HistogramSample {
+  value: number
+}
+
+interface HistogramBin {
+  binRange: string // 구간을 나타내는 문자열, 예: "0-1"
+  count: number // 해당 구간에 속하는 데이터의 개수
+}
+
+interface HistogramResult {
+  chartType: 'Histogram'
+  variableName: string // 분석 대상 변수 이름
+  bins: HistogramBin[] // 히스토그램의 각 구간과 해당 구간의 데이터 개수
+}
+
+export function calculateHistogram(samples: HistogramSample[], variableName: string, numBins: number): HistogramResult {
+  const values = samples.map(sample => sample.value)
+  const minValue = Math.min(...values)
+  const maxValue = Math.max(...values)
+  const range = maxValue - minValue
+  const binWidth = range / numBins
+
+  // 초기화된 구간 배열 생성
+  const bins: HistogramBin[] = Array.from({ length: numBins }, (_, i) => ({
+    binRange: `${(minValue + i * binWidth).toFixed(2)}-${(minValue + (i + 1) * binWidth).toFixed(2)}`,
+    count: 0
+  }))
+
+  // 각 샘플을 적절한 구간에 할당하고 개수를 세어 구간의 개수를 업데이트합니다.
+  samples.forEach(sample => {
+    const binIndex = Math.min(numBins - 1, Math.floor((sample.value - minValue) / binWidth))
+    bins[binIndex].count++
+  })
+
+  return {
+    chartType: 'Histogram',
+    variableName,
+    bins
+  }
+}

package/server/controllers/spc-/bchart/i.ts

@@ -0,0 +1,35 @@
+interface ISample {
+  sampleId: string
+  value: number // 개별 측정값
+}
+
+interface IChartResult {
+  chartType: 'I'
+  variableName: string
+  CL: number // 중심선
+  UCL: number // 상한 제어선
+  LCL: number // 하한 제어선
+  samples: ISample[] // 개별 측정값 배열
+}
+
+export function calculateIChartAnalysisResult(samples: ISample[], variableName: string): IChartResult {
+  // 개별 측정값의 평균을 계산하여 중심선(CL)을 구합니다.
+  const CL = samples.reduce((acc, sample) => acc + sample.value, 0) / samples.length
+
+  // 개별 측정값의 표준편차를 계산합니다.
+  const standardDeviation = Math.sqrt(samples.reduce((acc, sample) => acc + Math.pow(sample.value - CL, 2), 0) / samples.length)
+
+  // 공정 변동을 고려하여 상한 제어선(UCL)과 하한 제어선(LCL)을 계산합니다.
+  // 여기서는 3시그마(3 * 표준편차)를 사용합니다. 상황에 따라 적절한 시그마 수준을 조정할 수 있습니다.
+  const UCL = CL + 3 * standardDeviation
+  const LCL = CL - 3 * standardDeviation
+
+  return {
+    chartType: 'I',
+    variableName,
+    CL,
+    UCL,
+    LCL,
+    samples
+  }
+}

package/server/controllers/spc-/bchart/index.ts

@@ -0,0 +1,171 @@
+const result = {
+  dataset: {
+    id: 'aaa',
+    name: 'bbb'
+  },
+  query: {},
+  analysisResults: [
+    {
+      chartType: 'X-bar',
+      variables: [
+        {
+          name: 'variable1',
+          stats: {
+            mean: 22,
+            UCL: 25,
+            LCL: 19,
+            CL: 22
+          },
+          samples: [
+            { sampleId: '1', value: 22 },
+            { sampleId: '2', value: 23 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'R',
+      variables: [
+        {
+          name: 'variable2',
+          stats: {
+            range: 1.3,
+            UCL: 2.1,
+            LCL: 0.5,
+            CL: 1.3
+          },
+          samples: [
+            { sampleId: '1', value: 1.2 },
+            { sampleId: '2', value: 1.3 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'p',
+      variables: [
+        {
+          name: 'variable3',
+          stats: {
+            proportion: 0.05,
+            UCL: 0.1,
+            LCL: 0.01
+          },
+          samples: [
+            { sampleId: '1', value: 0.05 },
+            { sampleId: '2', value: 0.06 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'np',
+      variables: [
+        {
+          name: 'variable4',
+          stats: {
+            nonconforming: 5,
+            UCL: 10,
+            LCL: 1
+          },
+          samples: [
+            { sampleId: '1', value: 5 },
+            { sampleId: '2', value: 4 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'c',
+      variables: [
+        {
+          name: 'variable5',
+          stats: {
+            count: 20,
+            UCL: 25,
+            LCL: 15
+          },
+          samples: [
+            { sampleId: '1', value: 20 },
+            { sampleId: '2', value: 21 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'u',
+      variables: [
+        {
+          name: 'variable6',
+          stats: {
+            defectsPerUnit: 1.2,
+            UCL: 1.5,
+            LCL: 0.9
+          },
+          samples: [
+            { sampleId: '1', value: 1.2 },
+            { sampleId: '2', value: 1.1 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'I',
+      variables: [
+        {
+          name: 'variable7',
+          stats: {
+            individualValue: 10,
+            UCL: 12,
+            LCL: 8
+          },
+          samples: [
+            { sampleId: '1', value: 10 },
+            { sampleId: '2', value: 11 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'MR',
+      variables: [
+        {
+          name: 'variable8',
+          stats: {
+            movingRange: 2,
+            UCL: 3,
+            LCL: 1
+          },
+          samples: [
+            { sampleId: '1', value: 2 },
+            { sampleId: '2', value: 2.5 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'Histogram',
+      variables: [
+        {
+          name: 'variable9',
+          bins: [
+            { binRange: '0-1', count: 5 },
+            { binRange: '1-2', count: 10 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'Pareto',
+      variables: [
+        {
+          name: 'defectType',
+          categories: [
+            { category: 'Scratch', count: 20 },
+            { category: 'Dent', count: 15 }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/server/controllers/spc-/bchart/mr.ts

@@ -0,0 +1,37 @@
+interface MRSample {
+  sampleId: string
+  value: number // 측정값
+}
+
+interface MRChartResult {
+  chartType: 'MR'
+  variableName: string
+  CL: number // 중심선
+  UCL: number // 상한 제어선
+  LCL: number // 하한 제어선 (MR 차트에서는 일반적으로 0으로 설정됩니다)
+  movingRanges: number[] // 연속된 측정값 간의 변동 범위
+}
+
+export function calculateMRChartAnalysisResult(samples: MRSample[], variableName: string): MRChartResult {
+  // 연속된 측정값 간의 변동 범위를 계산합니다.
+  const movingRanges = samples.slice(1).map((sample, index) => Math.abs(sample.value - samples[index].value))
+
+  // 변동 범위의 평균을 계산하여 중심선(CL)을 구합니다.
+  const CL = movingRanges.reduce((acc, range) => acc + range, 0) / movingRanges.length
+
+  // 공정 변동을 고려하여 상한 제어선(UCL)을 계산합니다.
+  // MR 차트에서는 3.267 * MR-Bar을 사용합니다 (2개의 측정값을 사용하는 경우).
+  const UCL = 3.267 * CL
+
+  // MR 차트에서 하한 제어선(LCL)은 일반적으로 사용되지 않거나 0으로 설정됩니다.
+  const LCL = 0 // 하한 제어선
+
+  return {
+    chartType: 'MR',
+    variableName,
+    CL,
+    UCL,
+    LCL,
+    movingRanges
+  }
+}

package/server/controllers/spc-/bchart/np.ts

@@ -0,0 +1,35 @@
+interface NPSampleGroup {
+  groupId: string
+  nonConforming: number // 각 샘플 그룹의 불량품 수
+  totalUnits: number // 샘플 그룹의 총 단위 수
+}
+
+interface NPChartResult {
+  chartType: 'NP'
+  variableName: string
+  NPBar: number // 샘플 그룹의 평균 불량품 수
+  UCL: number
+  LCL: number
+  sampleGroups: NPSampleGroup[]
+}
+
+export function calculateNPChartAnalysisResult(sampleGroups: NPSampleGroup[], variableName: string): NPChartResult {
+  const totalNonConforming = sampleGroups.reduce((acc, group) => acc + group.nonConforming, 0)
+  const totalUnits = sampleGroups.reduce((acc, group) => acc + group.totalUnits, 0)
+  const NPBar = totalNonConforming / sampleGroups.length // 평균 불량품 수
+
+  // p 차트 공식을 사용하여 UCL과 LCL을 계산합니다.
+  const pBar = totalNonConforming / totalUnits // 전체 불량품 비율
+  const UCL = NPBar + 3 * Math.sqrt(NPBar * (1 - pBar))
+  let LCL = NPBar - 3 * Math.sqrt(NPBar * (1 - pBar))
+  LCL = LCL < 0 ? 0 : LCL // LCL이 음수인 경우 0으로 설정
+
+  return {
+    chartType: 'NP',
+    variableName,
+    NPBar,
+    UCL,
+    LCL,
+    sampleGroups
+  }
+}

package/server/controllers/spc-/bchart/p.ts

@@ -0,0 +1,34 @@
+interface PSampleGroup {
+  groupId: string // 샘플 그룹 ID
+  defectiveUnits: number // 그룹 내 결함 있는 단위 수
+  totalUnits: number // 그룹 내 총 단위 수
+}
+
+interface PChartResult {
+  chartType: 'P'
+  variableName: string
+  PBar: number // 결함 있는 단위의 평균 비율
+  UCL: number // 상한 제어선
+  LCL: number // 하한 제어선
+  sampleGroups: PSampleGroup[]
+}
+
+export function calculatePChartAnalysisResult(sampleGroups: PSampleGroup[], variableName: string): PChartResult {
+  // 결함 있는 단위의 평균 비율(PBar)을 계산합니다.
+  const totalDefectiveUnits = sampleGroups.reduce((acc, group) => acc + group.defectiveUnits, 0)
+  const totalUnits = sampleGroups.reduce((acc, group) => acc + group.totalUnits, 0)
+  const PBar = totalDefectiveUnits / totalUnits
+
+  // 샘플 그룹의 크기(n)에 따라 UCL과 LCL을 계산합니다.
+  const UCL = PBar + 3 * Math.sqrt((PBar * (1 - PBar)) / totalUnits)
+  const LCL = PBar - 3 * Math.sqrt((PBar * (1 - PBar)) / totalUnits) < 0 ? 0 : PBar - 3 * Math.sqrt((PBar * (1 - PBar)) / totalUnits) // LCL이 음수가 되지 않도록 처리
+
+  return {
+    chartType: 'P',
+    variableName,
+    PBar,
+    UCL,
+    LCL,
+    sampleGroups
+  }
+}

package/server/controllers/spc-/bchart/pareto.ts

@@ -0,0 +1,34 @@
+interface ParetoCategory {
+  category: string // 카테고리 이름
+  count: number // 해당 카테고리의 데이터 개수 또는 중요도
+}
+
+interface ParetoResult {
+  chartType: 'Pareto'
+  variableName: string // 분석 대상 변수 이름
+  categories: ParetoCategory[] // Pareto 차트에 표시될 카테고리 및 중요도 정보
+}
+
+export function calculatePareto(data: { category: string }[], variableName: string): ParetoResult {
+  // 각 카테고리별 데이터 개수 계산
+  const categoryCounts: { [category: string]: number } = {}
+  data.forEach(item => {
+    const category = item.category
+    categoryCounts[category] = (categoryCounts[category] || 0) + 1
+  })
+
+  // 카테고리와 데이터 개수를 배열로 변환
+  const categories: ParetoCategory[] = Object.keys(categoryCounts).map(category => ({
+    category,
+    count: categoryCounts[category]
+  }))
+
+  // 데이터 개수에 따라 내림차순으로 정렬
+  categories.sort((a, b) => b.count - a.count)
+
+  return {
+    chartType: 'Pareto',
+    variableName,
+    categories
+  }
+}

package/server/controllers/spc-/bchart/r.ts

@@ -0,0 +1,40 @@
+interface SampleGroup {
+  groupId: string
+  values: number[]
+}
+
+interface RChartResult {
+  chartType: 'R'
+  variableName: string
+  RBar: number
+  UCL: number
+  LCL: number
+  sampleGroups: SampleGroup[]
+}
+
+export function calculateRChartAnalysisResult(sampleGroups: SampleGroup[], variableName: string): RChartResult {
+  // 각 샘플 그룹의 범위를 계산합니다.
+  const ranges = sampleGroups.map(group => Math.max(...group.values) - Math.min(...group.values))
+
+  // 모든 샘플 그룹의 범위의 평균값(R-bar)을 계산합니다.
+  const RBar = ranges.reduce((acc, cur) => acc + cur, 0) / ranges.length
+
+  // 샘플 그룹의 크기(n)에 따라 D3와 D4 값을 설정합니다.
+  // 예시에서는 n=5인 경우의 D3와 D4 값을 사용합니다. 실제 구현에서는 샘플 크기에 맞는 값을 사용해야 합니다.
+  const n = sampleGroups[0].values.length // 가정: 모든 샘플 그룹의 크기가 동일합니다.
+  const D3 = 0 // n=5에 대한 D3 값
+  const D4 = 2.114 // n=5에 대한 D4 값
+
+  // UCL과 LCL을 계산합니다.
+  const UCL = D4 * RBar
+  const LCL = D3 * RBar // D3가 0인 경우, LCL은 0이 됩니다.
+
+  return {
+    chartType: 'R',
+    variableName,
+    RBar,
+    UCL,
+    LCL,
+    sampleGroups
+  }
+}