Struct br_maths::spc::Spc

source · 
pub struct Spc {
Show 30 fields
    pub data: Vec<f64>,
    pub data_len: usize,
    pub group_len: usize,
    pub upper: f64,
    pub lower: f64,
    pub value: f64,
    pub max: f64,
    pub min: f64,
    pub avg: f64,
    pub total: f64,
    pub group_avg: Vec<f64>,
    pub group_range: Vec<f64>,
    pub group_range_max: f64,
    pub group_range_min: f64,
    pub group_data: Vec<Vec<f64>>,
    pub avg_r: f64,
    pub decimal: usize,
    pub cpu: f64,
    pub cpl: f64,
    pub d2: f64,
    pub cp: f64,
    pub cpk: f64,
    pub cr: f64,
    pub stdev: f64,
    pub stdevp: f64,
    pub var: f64,
    pub varp: f64,
    pub pp: f64,
    pub pr: f64,
    pub ppk: f64,

}

Fields§

§data: Vec<f64>

数据

§data_len: usize

数据长度

§group_len: usize

样本分组数量

§upper: f64

规格上限

§lower: f64

规格下限

§value: f64

标准值

§max: f64

最大值

§min: f64

最小值

§avg: f64

平均值

§total: f64

总值

§group_avg: Vec<f64>

组均值

§group_range: Vec<f64>

组极差

§group_range_max: f64

组极差-最大

§group_range_min: f64

组极差-最小

§group_data: Vec<Vec<f64>>

组数据

§avg_r: f64

均值-R

§decimal: usize

小数位

§cpu: f64

能力指数上限(CPU)

§cpl: f64

能力指数下限(CPL)

§d2: f64

样本d2系数

§cp: f64

能力指数 (Cp)

§cpk: f64

过程能力指数 (Cpk)

§cr: f64

过程能力比值 (CR)

§stdev: f64

标准差 (n-1)

§stdevp: f64

标准差 (n)

§var: f64

变差 (n-1)

§varp: f64

变差 (n)

§pp: f64

性能指数 (PP)

§pr: f64

性能比率 (PR)

§ppk: f64

性能指数 (PPK)

Implementations§

source§

impl Spc

source

pub fn new( upper: f64, lower: f64, value: f64, array: Vec<f64>, group_len: usize, decimal: usize ) -> Self

初始化

  • usl 上限值
  • lsl 下限值
  • value 标准值
  • array 测量数据
  • group_len 样本组数量
  • decimal 小数位
Examples found in repository?
examples/spc.rs (line 56)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    let list = vec![
        20.470,
        20.480,
        20.470,
        20.450,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.470,
        20.450,
        20.450,
        20.450,
        20.440,
    ];
    let mut spc = Spc::new(20.570, 20.37, 20.47, list, 5, 4);
    let data = spc.compute();

    println!("data_len: {}", data.data_len);
    println!("total: {}", data.total);
    println!("upper: {}", data.upper);
    println!("value: {}", data.value);
    println!("lower: {}", data.lower);

    println!("avg: {}", data.avg);
    println!("max: {}", data.max);
    println!("min: {}", data.min);

    println!("stddev : {}", data.stdev);
    println!("stdevp : {}", data.stdevp);


    println!("均值 -(R): {}", data.avg_r);
    println!("样本系数 {}", data.d2);
    println!("能力指数上限 (CPU) {}", data.cpu);
    println!("能力指数下限(CPL) {}", data.cpl);
    println!("能力指数(Cp) {}", data.cp);
    println!("cp: {} {:?}", data.cp, data.cp_rating_criteria());
    println!("过程能力指数 (Cpk) {}", data.cpk);
    println!("cpk: {} {:?}", data.cpk, data.cpk_rating_criteria());

    println!("性能指数 (PP) {}", data.pp);
    println!("性能比率(PR) {}", data.pr);
    println!("性能指数 (Ppk) {}", data.ppk);

    println!("变差 (n-1) {}", data.var);
    println!("变差 (n) {}", data.varp);

    println!("==================================均值图==================================");

    println!("均值图(均值) {:?}", data.data);
    println!("均值图(平均值) {:?}", data.avg);
    println!("均值图(最大值) {}", data.max);
    println!("均值图(最小值) {}", data.min);
    println!("==================================极差(R图)==================================");

    println!("极差(R)图(极差) {:?}", data.group_range);
    println!("极差(R)图(平均值) {:?}", data.avg_r);
    println!("极差(R)图(最大值) {}", data.group_range_max);
    println!("极差(R)图(最小值) {}", data.group_range_min);

    println!("==================================SPC推移图==================================");

    println!("SPC推移图-最大值 {:?}", data.max);
    println!("SPC推移图-上限 {:?}", data.upper);
    println!("SPC推移图-数据 {:?}", data.data);
    println!("SPC推移图-下限 {:?}", data.lower);
    println!("SPC推移图-最小值 {:?}", data.min);

}
source

pub fn compute(&mut self) -> &mut Self

Examples found in repository?
examples/spc.rs (line 57)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    let list = vec![
        20.470,
        20.480,
        20.470,
        20.450,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.470,
        20.450,
        20.450,
        20.450,
        20.440,
    ];
    let mut spc = Spc::new(20.570, 20.37, 20.47, list, 5, 4);
    let data = spc.compute();

    println!("data_len: {}", data.data_len);
    println!("total: {}", data.total);
    println!("upper: {}", data.upper);
    println!("value: {}", data.value);
    println!("lower: {}", data.lower);

    println!("avg: {}", data.avg);
    println!("max: {}", data.max);
    println!("min: {}", data.min);

    println!("stddev : {}", data.stdev);
    println!("stdevp : {}", data.stdevp);


    println!("均值 -(R): {}", data.avg_r);
    println!("样本系数 {}", data.d2);
    println!("能力指数上限 (CPU) {}", data.cpu);
    println!("能力指数下限(CPL) {}", data.cpl);
    println!("能力指数(Cp) {}", data.cp);
    println!("cp: {} {:?}", data.cp, data.cp_rating_criteria());
    println!("过程能力指数 (Cpk) {}", data.cpk);
    println!("cpk: {} {:?}", data.cpk, data.cpk_rating_criteria());

    println!("性能指数 (PP) {}", data.pp);
    println!("性能比率(PR) {}", data.pr);
    println!("性能指数 (Ppk) {}", data.ppk);

    println!("变差 (n-1) {}", data.var);
    println!("变差 (n) {}", data.varp);

    println!("==================================均值图==================================");

    println!("均值图(均值) {:?}", data.data);
    println!("均值图(平均值) {:?}", data.avg);
    println!("均值图(最大值) {}", data.max);
    println!("均值图(最小值) {}", data.min);
    println!("==================================极差(R图)==================================");

    println!("极差(R)图(极差) {:?}", data.group_range);
    println!("极差(R)图(平均值) {:?}", data.avg_r);
    println!("极差(R)图(最大值) {}", data.group_range_max);
    println!("极差(R)图(最小值) {}", data.group_range_min);

    println!("==================================SPC推移图==================================");

    println!("SPC推移图-最大值 {:?}", data.max);
    println!("SPC推移图-上限 {:?}", data.upper);
    println!("SPC推移图-数据 {:?}", data.data);
    println!("SPC推移图-下限 {:?}", data.lower);
    println!("SPC推移图-最小值 {:?}", data.min);

}
source

pub fn cpk_rating_criteria(&self) -> (&'static str, &'static str)

Examples found in repository?
examples/spc.rs (line 80)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    let list = vec![
        20.470,
        20.480,
        20.470,
        20.450,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.470,
        20.450,
        20.450,
        20.450,
        20.440,
    ];
    let mut spc = Spc::new(20.570, 20.37, 20.47, list, 5, 4);
    let data = spc.compute();

    println!("data_len: {}", data.data_len);
    println!("total: {}", data.total);
    println!("upper: {}", data.upper);
    println!("value: {}", data.value);
    println!("lower: {}", data.lower);

    println!("avg: {}", data.avg);
    println!("max: {}", data.max);
    println!("min: {}", data.min);

    println!("stddev : {}", data.stdev);
    println!("stdevp : {}", data.stdevp);


    println!("均值 -(R): {}", data.avg_r);
    println!("样本系数 {}", data.d2);
    println!("能力指数上限 (CPU) {}", data.cpu);
    println!("能力指数下限(CPL) {}", data.cpl);
    println!("能力指数(Cp) {}", data.cp);
    println!("cp: {} {:?}", data.cp, data.cp_rating_criteria());
    println!("过程能力指数 (Cpk) {}", data.cpk);
    println!("cpk: {} {:?}", data.cpk, data.cpk_rating_criteria());

    println!("性能指数 (PP) {}", data.pp);
    println!("性能比率(PR) {}", data.pr);
    println!("性能指数 (Ppk) {}", data.ppk);

    println!("变差 (n-1) {}", data.var);
    println!("变差 (n) {}", data.varp);

    println!("==================================均值图==================================");

    println!("均值图(均值) {:?}", data.data);
    println!("均值图(平均值) {:?}", data.avg);
    println!("均值图(最大值) {}", data.max);
    println!("均值图(最小值) {}", data.min);
    println!("==================================极差(R图)==================================");

    println!("极差(R)图(极差) {:?}", data.group_range);
    println!("极差(R)图(平均值) {:?}", data.avg_r);
    println!("极差(R)图(最大值) {}", data.group_range_max);
    println!("极差(R)图(最小值) {}", data.group_range_min);

    println!("==================================SPC推移图==================================");

    println!("SPC推移图-最大值 {:?}", data.max);
    println!("SPC推移图-上限 {:?}", data.upper);
    println!("SPC推移图-数据 {:?}", data.data);
    println!("SPC推移图-下限 {:?}", data.lower);
    println!("SPC推移图-最小值 {:?}", data.min);

}
source

pub fn cp_rating_criteria(&self) -> (&'static str, &'static str)

Examples found in repository?
examples/spc.rs (line 78)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    let list = vec![
        20.470,
        20.480,
        20.470,
        20.450,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.450,
        20.470,
        20.450,
        20.450,
        20.440,
        20.470,
        20.470,
        20.450,
        20.450,
        20.450,
        20.440,
    ];
    let mut spc = Spc::new(20.570, 20.37, 20.47, list, 5, 4);
    let data = spc.compute();

    println!("data_len: {}", data.data_len);
    println!("total: {}", data.total);
    println!("upper: {}", data.upper);
    println!("value: {}", data.value);
    println!("lower: {}", data.lower);

    println!("avg: {}", data.avg);
    println!("max: {}", data.max);
    println!("min: {}", data.min);

    println!("stddev : {}", data.stdev);
    println!("stdevp : {}", data.stdevp);


    println!("均值 -(R): {}", data.avg_r);
    println!("样本系数 {}", data.d2);
    println!("能力指数上限 (CPU) {}", data.cpu);
    println!("能力指数下限(CPL) {}", data.cpl);
    println!("能力指数(Cp) {}", data.cp);
    println!("cp: {} {:?}", data.cp, data.cp_rating_criteria());
    println!("过程能力指数 (Cpk) {}", data.cpk);
    println!("cpk: {} {:?}", data.cpk, data.cpk_rating_criteria());

    println!("性能指数 (PP) {}", data.pp);
    println!("性能比率(PR) {}", data.pr);
    println!("性能指数 (Ppk) {}", data.ppk);

    println!("变差 (n-1) {}", data.var);
    println!("变差 (n) {}", data.varp);

    println!("==================================均值图==================================");

    println!("均值图(均值) {:?}", data.data);
    println!("均值图(平均值) {:?}", data.avg);
    println!("均值图(最大值) {}", data.max);
    println!("均值图(最小值) {}", data.min);
    println!("==================================极差(R图)==================================");

    println!("极差(R)图(极差) {:?}", data.group_range);
    println!("极差(R)图(平均值) {:?}", data.avg_r);
    println!("极差(R)图(最大值) {}", data.group_range_max);
    println!("极差(R)图(最小值) {}", data.group_range_min);

    println!("==================================SPC推移图==================================");

    println!("SPC推移图-最大值 {:?}", data.max);
    println!("SPC推移图-上限 {:?}", data.upper);
    println!("SPC推移图-数据 {:?}", data.data);
    println!("SPC推移图-下限 {:?}", data.lower);
    println!("SPC推移图-最小值 {:?}", data.min);

}

Auto Trait Implementations§

§

impl RefUnwindSafe for Spc

§

impl Send for Spc

§

impl Sync for Spc

§

impl Unpin for Spc

§

impl UnwindSafe for Spc

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.