Explorative Datenanalyse

val responseTimeMs =
    doubleArrayOf(
        89.2,
        95.1,
        87.6,
        102.3,
        91.8,
        88.4,
        96.7,
        103.5,
        90.1,
        94.3,
        88.9,
        97.2,
        105.8,
        91.4,
        93.6,
        87.1,
        99.0,
        92.5,
        96.1,
        104.2,
        90.7,
        88.3,
        101.6,
        93.9,
        95.4,
        89.8,
        98.3,
        106.1,
        91.0,
        94.7,
    )

val errorsPerHour =
    doubleArrayOf(
        2.0,
        3.0,
        1.0,
        5.0,
        2.0,
        1.0,
        4.0,
        6.0,
        2.0,
        3.0,
        1.0,
        4.0,
        7.0,
        2.0,
        3.0,
        1.0,
        5.0,
        2.0,
        4.0,
        6.0,
        2.0,
        1.0,
        5.0,
        3.0,
        3.0,
        1.0,
        4.0,
        8.0,
        2.0,
        3.0,
    )

val memoryUsageMb =
    doubleArrayOf(
        512.3,
        528.1,
        505.7,
        545.2,
        519.6,
        508.4,
        534.8,
        551.3,
        515.0,
        526.7,
        509.2,
        537.1,
        558.4,
        517.8,
        524.3,
        503.1,
        541.6,
        520.9,
        531.5,
        549.7,
        514.2,
        506.8,
        543.9,
        522.5,
        529.0,
        511.4,
        539.3,
        561.2,
        516.3,
        527.4,
    )

val throughputRps =
    doubleArrayOf(
        245.0,
        238.0,
        251.0,
        225.0,
        242.0,
        249.0,
        232.0,
        218.0,
        244.0,
        236.0,
        250.0,
        230.0,
        212.0,
        243.0,
        237.0,
        253.0,
        227.0,
        241.0,
        233.0,
        220.0,
        246.0,
        252.0,
        224.0,
        239.0,
        235.0,
        248.0,
        228.0,
        210.0,
        243.0,
        234.0,
    )

val rtSummary = responseTimeMs.describe()
val errSummary = errorsPerHour.describe()
val memSummary = memoryUsageMb.describe()
val tpSummary = throughputRps.describe()

rtSummary.mean
rtSummary.standardDeviation
rtSummary.min
rtSummary.max
errSummary.mean
errSummary.standardDeviation
errSummary.min
errSummary.max
memSummary.mean
memSummary.standardDeviation
memSummary.min
memSummary.max
tpSummary.mean
tpSummary.standardDeviation
tpSummary.min
tpSummary.max

val rtBins = responseTimeMs.frequencyTable(binCount = 5)
rtBins.forEach { bin ->
    // bin.range, bin.count, bin.relativeFrequency
}

val errBins = errorsPerHour.frequencyTable(binSize = 2.0)
errBins.forEach { bin ->
    // bin.range, bin.count, bin.cumulativeFrequency
}

responseTimeMs.skewness() // positive = right-skewed
responseTimeMs.kurtosis() // positive excess = heavier tails than Normal

errorsPerHour.skewness()
errorsPerHour.kurtosis()

memoryUsageMb.skewness()
throughputRps.skewness()

shapiroWilkTest(responseTimeMs).pValue
shapiroWilkTest(errorsPerHour).pValue
shapiroWilkTest(memoryUsageMb).pValue
shapiroWilkTest(throughputRps).pValue

val rtFit =
    NormalDistribution(
        mu = responseTimeMs.mean(),
        sigma = responseTimeMs.standardDeviation(),
    )
kolmogorovSmirnovTest(responseTimeMs, rtFit).pValue

val memFit =
    NormalDistribution(
        mu = memoryUsageMb.mean(),
        sigma = memoryUsageMb.standardDeviation(),
    )
kolmogorovSmirnovTest(memoryUsageMb, memFit).pValue

// Correlation matrix across all four metrics
val matrix = correlationMatrix(responseTimeMs, errorsPerHour, memoryUsageMb, throughputRps)
// matrix[i][j] gives Pearson r between metrics i and j

// Deeper look at specific relationships
val rtVsErrors = pearsonCorrelation(responseTimeMs, errorsPerHour)
rtVsErrors.coefficient // positive = errors rise with latency
rtVsErrors.pValue

val rtVsThroughput = spearmanCorrelation(responseTimeMs, throughputRps)
rtVsThroughput.coefficient // negative = latency rises when throughput drops
rtVsThroughput.pValue

// Model: how does error count relate to response time?
val regression = simpleLinearRegression(errorsPerHour, responseTimeMs)

regression.slope // ms increase per additional error/hour
regression.intercept // baseline response time at zero errors
regression.rSquared // proportion of variance explained

regression.predict(4.0) // expected latency at 4 errors/hour

val firstHalfRt = responseTimeMs.sliceArray(0 until 15)
val secondHalfRt = responseTimeMs.sliceArray(15 until 30)

val periodComparison = tTest(firstHalfRt, secondHalfRt)
periodComparison.pValue
periodComparison.isSignificant()

// Non-parametric alternative
val periodRank = mannWhitneyUTest(firstHalfRt, secondHalfRt)
periodRank.pValue

val firstHalfTp = throughputRps.sliceArray(0 until 15)
val secondHalfTp = throughputRps.sliceArray(15 until 30)

val tpComparison = tTest(firstHalfTp, secondHalfTp)
tpComparison.pValue

// Z-score: values become standard deviations from mean
val rtNormalized = responseTimeMs.zScore()
val memNormalized = memoryUsageMb.zScore()
// Both are now on the same scale and can be compared directly

// Min-max scaling to [0, 1]
val rtScaled = responseTimeMs.minMaxNormalize()
val tpScaled = throughputRps.minMaxNormalize()

// Rank the days by response time (worst days get highest rank)
val rtRanked = responseTimeMs.rank()