在接口耗时、QPS、资源利用率等指标中，“稳定不抖”往往比“偶尔快一点”更重要：

某段时间内，这个指标到底稳不稳定？
哪一段时间的波动最大，需要重点关注？
能不能给这条指标打一个“稳定度评分”？

本案例基于 Kotlin Multiplatform（KMP）与 OpenHarmony，实现了一个滚动窗口波动率分析与稳定度评估器：

• 在滑动窗口内计算标准差与变异系数 (Coefficient of Variation, CV)；
• 输出每个时间窗口的平均值、标准差及相对波动率；
• 计算整体平均 CV / 最大 CV，并给出 0~1 的“稳定度评分”；
• 通过 ArkTS 单页面展示结果，帮助你快速判断指标在不同阶段的稳定性。

---

一、问题背景与典型场景

常见的波动率与稳定性需求包括：

1. 接口耗时稳定度评估
   即便 P95/P99 看起来还行，但如果在部分时间段内耗时波动剧烈，用户体验仍会很差。

2. QPS / 流量平稳性分析
   判断流量是平滑增长还是存在很多“抖峰”，为限流与容量规划提供依据。

3. 资源利用率抖动检测
   CPU / 内存 / IO 使用率是否平稳，或者是否存在高频严重抖动，可能预示着 GC、抖动性任务或调度问题。

4. 业务指标稳定度打分
   对订单量、支付成功率、点击率等指标的波动进行量化，为产品和运营活动的“稳定性”做评估。

这些问题可以抽象为：

给定时序数据 \( x_0, x_1, \dots, x_{n-1} \) 和窗口大小 \( w \)，
对每个滑动窗口 \([i, i+w-1]\) 计算平均值 \( \mu \)、标准差 \( \sigma \)、变异系数 \( \text{CV} = \sigma / |\mu| \)，
进而汇总整体的平均 CV 与最大 CV。

---

二、Kotlin 滚动波动率分析引擎

1. 输入格式设计

本案例沿用统一的文本输入风格：

window=3
series=10,12,11,13,15,18,20,19,17

• window：滑动窗口大小，例如 3；
• series：一串以 , / 空格 / ; / 换行分隔的数值样本。

如果未提供 window，会默认使用 3，并确保不小于 2、不大于样本数。

---

2. Kotlin 分析主入口

在 App.kt 中，我们定义了对外暴露的波动率分析函数，并通过 @JsExport 让 OpenHarmony 端可以直接调用：

@JsExport
fun rollingVolatilityAnalyzer(inputData: String): String {
    val sanitized = inputData.trim()
    if (sanitized.isEmpty()) {
        return "❌ 输入为空，请按 window=3\\nseries=10,12,11,13,... 形式提供数据"
    }

    val lines = sanitized.lines()
        .map { it.trim() }
        .filter { it.isNotEmpty() }

    var windowSize: Int? = null
    val values = mutableListOf<Double>()

    for (line in lines) {
        when {
            line.startsWith("window=", ignoreCase = true) -> {
                windowSize = line.substringAfter("=").trim().toIntOrNull()
            }
            line.startsWith("series=", ignoreCase = true) -> {
                val parsed = line.substringAfter("=")
                    .split(",", " ", ";", "\n")
                    .mapNotNull { it.trim().takeIf { s -> s.isNotEmpty() }?.toDoubleOrNull() }
                values += parsed
            }
            else -> {
                val parsed = line.split(",", " ", ";", "\n")
                    .mapNotNull { it.trim().takeIf { s -> s.isNotEmpty() }?.toDoubleOrNull() }
                values += parsed
            }
        }
    }

    if (values.size < 3) {
        return "❌ 至少需要 3 个及以上样本点才能进行滚动波动率分析"
    }
    val w = (windowSize ?: 3).coerceAtLeast(2)
    if (w > values.size) {
        return "❌ 窗口大小 window 不可大于样本数量 (${values.size})"
    }

    fun mean(list: List<Double>): Double = list.sum() / list.size

    fun std(list: List<Double>): Double {
        val m = mean(list)
        val varSum = list.fold(0.0) { acc, v -> acc + (v - m) * (v - m) } / list.size
        return kotlin.math.sqrt(varSum)
    }

    data class VolWindow(val start: Int, val end: Int, val mean: Double, val std: Double, val cv: Double)

    val windows = mutableListOf<VolWindow>()
    for (start in 0..(values.size - w)) {
        val end = start + w - 1
        val slice = values.subList(start, end + 1)
        val m = mean(slice)
        val s = std(slice)
        val cv = if (m == 0.0) 0.0 else s / kotlin.math.abs(m)
        windows += VolWindow(start, end, m, s, cv)
    }

    val avgCv = windows.map { it.cv }.average()
    val maxCv = windows.maxOf { it.cv }
    val stabilityScore = (1.0 - avgCv).coerceIn(0.0, 1.0)

    val builder = StringBuilder()
    builder.appendLine("📊 滚动窗口波动率分析与稳定度评估报告")
    builder.appendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
    builder.appendLine("样本数量: ${values.size}")
    builder.appendLine("窗口大小: $w")
    builder.appendLine("窗口数量: ${windows.size}")
    builder.appendLine("平均变异系数 (Avg CV): ${round2(avgCv)}")
    builder.appendLine("最大变异系数 (Max CV): ${round2(maxCv)}")
    builder.appendLine("整体稳定度评分 (0~1, 越高越稳定): ${round2(stabilityScore)}")
    builder.appendLine()

    builder.appendLine("🧮 原始序列")
    builder.appendLine(values.joinToString(prefix = "[", postfix = "]"))
    builder.appendLine()

    builder.appendLine("📉 滚动窗口波动率明细")
    windows.forEachIndexed { index, vw ->
        builder.appendLine(
            "窗口 ${index + 1} [${vw.start}, ${vw.end}] -> mean=${round2(vw.mean)}, std=${round2(vw.std)}, CV=${round2(vw.cv)}"
        )
    }

    builder.appendLine()
    builder.appendLine("🧠 工程化解读")
    builder.appendLine("- 变异系数 (CV = std/mean) 是衡量相对波动程度的指标，越小表示越稳定；")
    builder.appendLine("- 平均 CV 反映整体波动水平，最大 CV 可以帮助识别“最不稳定阶段”；")
    builder.appendLine("- 在 AIOps 场景中，可基于稳定度评分做“波动异常告警”，或对稳定指标给予更高权重。")

    return builder.toString().trim()
}

该实现采用了简单直接的滑动窗口方式：

• 对每个窗口子序列计算均值与标准差；
• 使用 CV = std / |mean| 表示相对波动程度；
• 通过平均 CV 与最大 CV 描述整体稳定性，并构造稳定度评分。

---

三、OpenHarmony 侧调用与 UI 展示思路

在 ArkTS 页面中，可以像前面案例一样导入该函数：

import { rollingVolatilityAnalyzer } from './hellokjs'

页面状态建议包括：

• windowSize: 滑动窗口大小（默认 "3"）；
• seriesInput: 时间序列样本，例如 "10,12,11,13,15,18,20,19,17"。

调用示例：

const seriesLine = this.seriesInput.includes('series=') ? this.seriesInput : `series=${this.seriesInput}`
const payload = `window=${this.windowSize}\n${seriesLine}`
this.result = rollingVolatilityAnalyzer(payload)

展示层可以：

• 使用等宽字体展示“原始序列 + 滚动窗口波动率明细 + 稳定度评分”；
• 对高 CV 的窗口行做高亮，便于快速锁定“最不稳定阶段”；
• 如有简单图形化能力，可以在折线图上以彩色背景块标出高波动窗口。

---

四、复杂度与工程实践建议

复杂度分析：

• 对每个窗口进行均值/标准差计算，朴素实现的时间复杂度为 \( O(nw) \)，其中 \( n \) 为样本数，\( w \) 为窗口大小；
• 对于端侧指标分析，通常 \( n \) 与 \( w \) 都不会过大，完全可接受；
• 若需要进一步优化，可使用前缀和与前缀平方和技巧将复杂度降为 \( O(n) \)。

工程实践建议：

1. 波动性分级
   将 CV 按阈值分级（例如 <0.05 为“高稳定”，0.05~0.15 为“中等波动”，>0.15 为“高波动”），在 UI 上以不同颜色标注。

2. 与异常检测联动
   在高波动窗口内再叠加 Z-Score 或分位数异常检测，用于识别“波动期内的极端异常点”。

3. 多维波动度对比
   对多条指标分别计算滚动 CV，并在终端上对比“哪条指标更不稳定”，用于优先级排序。

4. 端侧稳定性评分
   将稳定度评分同步上报或者在本地持久化，用于对设备/实例进行“健康度打分”或“稳定性评估”。

通过这个滚动窗口波动率分析与稳定度评估案例，你可以在 OpenHarmony 终端上快速量化指标在不同阶段的波动程度，
与前面实现的异常检测、预测和相关性分析模块组合使用，构建一套完整的时序健康度分析工具链。