FSharp.Stats/tests/FSharp.Stats.Tests/TestExtensions.fs at developer · fslaborg/FSharp.Stats · GitHub

1
2
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
module TestExtensions

    open Expecto
    open FsMath
    open FSharp.Stats
    open FSharp.Stats.Testing
    open System
    open System.IO
    open System.Text
    open System.Reflection

    module Accuracy =
        /// <summary>veryLow accuracy: absolute = 1e-4, relative = 1e-1</summary>
        let veryLow      = { absolute = 1e-4; relative = 1e-1 }


    type TestExtensions() =
        static member sequenceEqual(digits: int) =
            let round (v:float) = System.Math.Round(v,digits)
            fun actual expected message ->
                Expect.sequenceEqual (actual |> Seq.map round) (expected |> Seq.map round) message

        static member sequenceEqual(accuracy: Expecto.Accuracy) =
            fun actual expected message ->
                if Seq.length actual <> Seq.length expected then Expect.isTrue false message
                Seq.iter2 (fun a b -> Expect.floatClose accuracy a b message) actual expected

        static member sequenceEqualRoundedNaN (digits: int) =
            let round (v:float) = System.Math.Round(v,digits)
            fun actual expected message ->
                if Seq.length actual <> Seq.length expected then Expect.isTrue false message
                Seq.iter2 (fun a b ->
                    if nan.Equals a then
                        Expect.isTrue (nan.Equals b) message
                    else
                        Expect.equal (round a) (round b) message
                    )
                    actual
                    expected

        static member floatMatrixClose accuracy (A: Matrix<float>) (B: Matrix<float>) message =
            Expect.equal A.NumCols B.NumCols "Column count mismatch"
            Expect.equal A.NumRows B.NumRows "Row count mismatch"
            for i = 0 to A.NumRows - 1 do
                for j = 0 to A.NumCols - 1 do
                    Expect.floatClose accuracy A.[i, j] B.[i, j] $"{message} at ({i},{j})"

    let assembly = Assembly.GetExecutingAssembly()
    let resnames = assembly.GetManifestResourceNames();
    let readEmbeddedRessource (name:string) =
        match Array.tryFind (fun (r:string) -> r.Contains(name)) resnames with
        | Some path ->
            use stream = assembly.GetManifestResourceStream(path)
            use reader = new StreamReader(stream, encoding=Text.Encoding.UTF8)
            reader.ReadToEnd()

        | _ -> failwithf "could not embedded ressources, check package integrity"

    let readCsv path =
        readEmbeddedRessource path
        |> fun s ->
            s.Replace("\r\n","\n").Split("\n")
        |> Array.skip 1
        |> Array.map (fun x ->
            match x.Split(", ") with
            | [|a;b|] -> a, float b
            | _ -> failwith "invalid csv format"
         )

    let comparisonMetricsEqualRounded (digits : int) (actual: ComparisonMetrics) (expected: ComparisonMetrics) message =
        let actual =
            [
                actual.P
                actual.N
                actual.SampleSize
                actual.TP
                actual.TN
                actual.FP
                actual.FN
                actual.Sensitivity
                actual.Specificity
                actual.Precision
                actual.NegativePredictiveValue
                actual.Missrate
                actual.FallOut
                actual.FalseDiscoveryRate
                actual.FalseOmissionRate
                actual.PositiveLikelihoodRatio
                actual.NegativeLikelihoodRatio
                actual.PrevalenceThreshold
                actual.ThreatScore
                actual.Prevalence
                actual.Accuracy
                actual.BalancedAccuracy
                actual.F1
                actual.PhiCoefficient
                actual.FowlkesMallowsIndex
                actual.Informedness
                actual.Markedness
                actual.DiagnosticOddsRatio
            ]

        let expected =
            [
                expected.P
                expected.N
                expected.SampleSize
                expected.TP
                expected.TN
                expected.FP
                expected.FN
                expected.Sensitivity
                expected.Specificity
                expected.Precision
                expected.NegativePredictiveValue
                expected.Missrate
                expected.FallOut
                expected.FalseDiscoveryRate
                expected.FalseOmissionRate
                expected.PositiveLikelihoodRatio
                expected.NegativeLikelihoodRatio
                expected.PrevalenceThreshold
                expected.ThreatScore
                expected.Prevalence
                expected.Accuracy
                expected.BalancedAccuracy
                expected.F1
                expected.PhiCoefficient
                expected.FowlkesMallowsIndex
                expected.Informedness
                expected.Markedness
                expected.DiagnosticOddsRatio
            ]
        TestExtensions.sequenceEqualRoundedNaN digits actual expected message