import HealthKit
 
class HeartRateMonitor {
    let healthStore = HKHealthStore()
 
    func requestAuthorization() {
        let heartRateType = HKQuantityType.quantityType(
            forIdentifier: .heartRate)!
        let typesToRead: Set<HKSampleType> = [heartRateType]
 
        healthStore.requestAuthorization(
            toShare: nil, read: typesToRead
        ) { success, error in
            if success {
                print("HealthKit認証成功")
                self.fetchRecentHeartRates()
            }
        }
    }
 
    func fetchRecentHeartRates() {
        let heartRateType = HKQuantityType.quantityType(
            forIdentifier: .heartRate)!
 
        // 過去24時間のデータを取得
        let predicate = HKQuery.predicateForSamples(
            withStart: Date().addingTimeInterval(-86400),
            end: Date(), options: .strictEndDate
        )
 
        let query = HKSampleQuery(
            sampleType: heartRateType,
            predicate: predicate,
            limit: HKObjectQueryNoLimit,
            sortDescriptors: [
                NSSortDescriptor(key: HKSampleSortIdentifierStartDate,
                               ascending: false)
            ]
        ) { _, samples, error in
            guard let samples = samples as? [HKQuantitySample] else { return }
 
            for sample in samples.prefix(10) {
                let bpm = sample.quantity.doubleValue(
                    for: HKUnit(from: "count/min"))
                let date = sample.startDate
                print("\(date): \(Int(bpm)) BPM")
            }
 
            // 異常検出
            let avgBPM = samples.map {
                $0.quantity.doubleValue(for: HKUnit(from: "count/min"))
            }.reduce(0, +) / Double(samples.count)
 
            if avgBPM > 100 {
                print("安静時心拍数が高めです: \(Int(avgBPM)) BPM")
            }
        }
 
        healthStore.execute(query)
    }
}

import androidx.health.connect.client.HealthConnectClient
import androidx.health.connect.client.records.StepsRecord
import androidx.health.connect.client.request.ReadRecordsRequest
import androidx.health.connect.client.time.TimeRangeFilter
import java.time.Instant
import java.time.temporal.ChronoUnit
 
suspend fun readStepsData(healthClient: HealthConnectClient) {
    val now = Instant.now()
    val startOfDay = now.truncatedTo(ChronoUnit.DAYS)
 
    val request = ReadRecordsRequest(
        recordType = StepsRecord::class,
        timeRangeFilter = TimeRangeFilter.between(startOfDay, now)
    )
 
    val response = healthClient.readRecords(request)
    var totalSteps = 0L
 
    for (record in response.records) {
        totalSteps += record.count
        println("${record.startTime} - ${record.endTime}: ${record.count}歩")
    }
 
    println("本日の合計: ${totalSteps}歩")
 
    // 目標達成チェック
    val goal = 10000L
    val progress = (totalSteps.toFloat() / goal * 100).toInt()
    println("目標達成率: ${progress}% ($totalSteps / $goal)")
 
    if (totalSteps >= goal) {
        println("目標達成おめでとうございます！")
    } else {
        println("あと${goal - totalSteps}歩です。頑張りましょう！")
    }
}

import numpy as np
from scipy import signal
from scipy.interpolate import interp1d
 
def analyze_hrv(rr_intervals_ms):
    """
    RR間隔（心拍間隔）からHRV指標を計算しストレスを推定
    rr_intervals_ms: 連続するRR間隔（ミリ秒）のリスト
    """
    rr = np.array(rr_intervals_ms)
 
    # --- 時間領域指標 ---
    mean_rr = np.mean(rr)
    sdnn = np.std(rr, ddof=1)  # 全RR間隔の標準偏差
    rmssd = np.sqrt(np.mean(np.diff(rr) ** 2))  # 連続差のRMS
 
    # --- 周波数領域指標 ---
    # RR間隔を等間隔に補間
    cumulative_time = np.cumsum(rr) / 1000.0
    f_interp = interp1d(cumulative_time, rr, kind='cubic')
    fs = 4.0  # 4Hzでリサンプリング
    t_uniform = np.arange(cumulative_time[0], cumulative_time[-1], 1/fs)
    rr_uniform = f_interp(t_uniform)
 
    # パワースペクトル密度
    freqs, psd = signal.welch(rr_uniform, fs=fs, nperseg=256)
 
    # LF (0.04-0.15Hz): 交感神経 + 副交感神経
    lf_mask = (freqs >= 0.04) & (freqs < 0.15)
    lf_power = np.trapz(psd[lf_mask], freqs[lf_mask])
 
    # HF (0.15-0.4Hz): 副交感神経
    hf_mask = (freqs >= 0.15) & (freqs < 0.4)
    hf_power = np.trapz(psd[hf_mask], freqs[hf_mask])
 
    lf_hf_ratio = lf_power / hf_power if hf_power > 0 else float('inf')
 
    # --- ストレス推定 ---
    # RMSSD低下 + LF/HF比上昇 → ストレス高
    if rmssd < 20 and lf_hf_ratio > 3.0:
        stress_level = "高"
    elif rmssd < 40 or lf_hf_ratio > 2.0:
        stress_level = "中"
    else:
        stress_level = "低"
 
    return {
        "mean_hr": 60000 / mean_rr,
        "sdnn_ms": sdnn,
        "rmssd_ms": rmssd,
        "lf_power": lf_power,
        "hf_power": hf_power,
        "lf_hf_ratio": lf_hf_ratio,
        "stress_level": stress_level
    }
 
# 使用例
rr_data = [820, 835, 790, 810, 845, 800, 815, 830, 795, 810]
result = analyze_hrv(rr_data)
print(f"心拍数: {result['mean_hr']:.0f} BPM")
print(f"RMSSD: {result['rmssd_ms']:.1f} ms")
print(f"LF/HF比: {result['lf_hf_ratio']:.2f}")
print(f"ストレスレベル: {result['stress_level']}")

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
 
def extract_sleep_features(accel_data, window_sec=30, fs=50):
    """
    加速度計データから睡眠特徴量を抽出
    accel_data: shape (N, 3) - x, y, z 軸の加速度
    """
    window_size = window_sec * fs
    features_list = []
 
    for i in range(0, len(accel_data) - window_size, window_size):
        window = accel_data[i:i + window_size]
        magnitude = np.sqrt(np.sum(window**2, axis=1))
 
        features = {
            'mean_mag': np.mean(magnitude),
            'std_mag': np.std(magnitude),
            'max_mag': np.max(magnitude),
            'activity_count': np.sum(np.abs(np.diff(magnitude)) > 0.1),
            'zero_crossing': np.sum(np.diff(np.sign(magnitude - np.mean(magnitude))) != 0),
            'energy': np.sum(magnitude**2) / len(magnitude),
            'entropy': -np.sum(np.histogram(magnitude, bins=20, density=True)[0]
                              * np.log2(np.histogram(magnitude, bins=20, density=True)[0] + 1e-10))
        }
        features_list.append(features)
 
    return features_list
 
def classify_sleep_stages(features):
    """
    睡眠段階分類: 覚醒 / 浅い睡眠 / 深い睡眠 / REM
    （学習済みモデルを使用する想定）
    """
    # 閾値ベースの簡易分類
    stages = []
    for f in features:
        if f['activity_count'] > 50:
            stages.append('覚醒')
        elif f['std_mag'] < 0.01:
            stages.append('深い睡眠')
        elif f['zero_crossing'] > 30:
            stages.append('REM')
        else:
            stages.append('浅い睡眠')
    return stages
 
# 使用例
accel = np.random.randn(50 * 3600 * 8, 3) * 0.05  # 8時間分
features = extract_sleep_features(accel)
stages = classify_sleep_stages(features)
print(f"睡眠段階: {len(stages)}エポック分析完了")
print(f"深い睡眠: {stages.count('深い睡眠')}エポック "
      f"({stages.count('深い睡眠') / len(stages) * 100:.1f}%)")

import HealthKit
import WatchKit
 
class WorkoutManager: NSObject, HKWorkoutSessionDelegate,
                      HKLiveWorkoutBuilderDelegate {
 
    let healthStore = HKHealthStore()
    var session: HKWorkoutSession?
    var builder: HKLiveWorkoutBuilder?
 
    func startRunningWorkout() {
        let config = HKWorkoutConfiguration()
        config.activityType = .running
        config.locationType = .outdoor
 
        do {
            session = try HKWorkoutSession(
                healthStore: healthStore, configuration: config
            )
            builder = session?.associatedWorkoutBuilder()
 
            session?.delegate = self
            builder?.delegate = self
 
            builder?.dataSource = HKLiveWorkoutDataSource(
                healthStore: healthStore,
                workoutConfiguration: config
            )
 
            let startDate = Date()
            session?.startActivity(with: startDate)
            builder?.beginCollection(withStart: startDate) { success, error in
                if success {
                    print("ワークアウト開始: ランニング")
                }
            }
        } catch {
            print("エラー: \(error)")
        }
    }
 
    // リアルタイムデータ更新
    func workoutBuilder(_ workoutBuilder: HKLiveWorkoutBuilder,
                       didCollectDataOf collectedTypes: Set<HKSampleType>) {
        for type in collectedTypes {
            guard let quantityType = type as? HKQuantityType else { continue }
 
            if let stats = workoutBuilder.statistics(for: quantityType) {
                switch quantityType {
                case HKQuantityType.quantityType(forIdentifier: .heartRate):
                    let bpm = stats.mostRecentQuantity()?.doubleValue(
                        for: HKUnit(from: "count/min")) ?? 0
                    print("心拍数: \(Int(bpm)) BPM")
 
                    // AIゾーン判定
                    let zone = heartRateZone(bpm: bpm, maxHR: 190)
                    print("ゾーン: \(zone)")
 
                case HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning):
                    let km = stats.sumQuantity()?.doubleValue(
                        for: .meterUnit(with: .kilo)) ?? 0
                    print("距離: \(String(format: "%.2f", km)) km")
 
                default: break
                }
            }
        }
    }
 
    func heartRateZone(bpm: Double, maxHR: Double) -> String {
        let percentage = bpm / maxHR * 100
        switch percentage {
        case ..<60: return "ゾーン1 (回復)"
        case 60..<70: return "ゾーン2 (脂肪燃焼)"
        case 70..<80: return "ゾーン3 (有酸素)"
        case 80..<90: return "ゾーン4 (無酸素)"
        default: return "ゾーン5 (最大)"
        }
    }
 
    func workoutSession(_ workoutSession: HKWorkoutSession,
                       didChangeTo toState: HKWorkoutSessionState,
                       from fromState: HKWorkoutSessionState,
                       date: Date) {}
    func workoutSession(_ workoutSession: HKWorkoutSession,
                       didFailWithError error: Error) {}
}

import HealthKit
import UserNotifications
 
class HealthBackgroundMonitor {
    let healthStore = HKHealthStore()
 
    /// バックグラウンドデリバリーの設定
    func enableBackgroundDelivery() {
        let heartRateType = HKQuantityType.quantityType(
            forIdentifier: .heartRate)!
 
        // バックグラウンドで心拍データ更新を受け取る
        healthStore.enableBackgroundDelivery(
            for: heartRateType,
            frequency: .immediate  // 即時通知
        ) { success, error in
            if success {
                print("バックグラウンドデリバリー有効化成功")
                self.setupObserverQuery()
            }
        }
    }
 
    /// オブザーバークエリで新しいデータを監視
    func setupObserverQuery() {
        let heartRateType = HKQuantityType.quantityType(
            forIdentifier: .heartRate)!
 
        let query = HKObserverQuery(
            sampleType: heartRateType,
            predicate: nil
        ) { [weak self] query, completionHandler, error in
            // 新しい心拍データが記録された
            self?.checkForAbnormalHeartRate()
            completionHandler()
        }
 
        healthStore.execute(query)
    }
 
    /// 異常心拍の検出とユーザー通知
    func checkForAbnormalHeartRate() {
        let heartRateType = HKQuantityType.quantityType(
            forIdentifier: .heartRate)!
 
        // 直近5分間のデータを取得
        let predicate = HKQuery.predicateForSamples(
            withStart: Date().addingTimeInterval(-300),
            end: Date(), options: .strictEndDate
        )
 
        let query = HKSampleQuery(
            sampleType: heartRateType,
            predicate: predicate,
            limit: HKObjectQueryNoLimit,
            sortDescriptors: nil
        ) { _, samples, _ in
            guard let samples = samples as? [HKQuantitySample],
                  !samples.isEmpty else { return }
 
            let bpmValues = samples.map {
                $0.quantity.doubleValue(for: HKUnit(from: "count/min"))
            }
 
            let avgBPM = bpmValues.reduce(0, +) / Double(bpmValues.count)
            let maxBPM = bpmValues.max() ?? 0
            let minBPM = bpmValues.min() ?? 0
 
            // 異常検出ロジック
            // 1. 安静時頻脈（100BPM以上が5分以上継続）
            if avgBPM > 100 {
                self.sendAlert(
                    title: "高心拍数検出",
                    body: "安静時心拍数が\(Int(avgBPM)) BPMです。" +
                          "長時間続く場合は医療機関にご相談ください。"
                )
            }
 
            // 2. 徐脈（40BPM以下）
            if minBPM < 40 && minBPM > 0 {
                self.sendAlert(
                    title: "低心拍数検出",
                    body: "心拍数が\(Int(minBPM)) BPMに低下しました。"
                )
            }
 
            // 3. 心拍変動の急激な変化
            if bpmValues.count >= 3 {
                let diffs = zip(bpmValues, bpmValues.dropFirst()).map {
                    abs($0.0 - $0.1)
                }
                let maxDiff = diffs.max() ?? 0
                if maxDiff > 30 {
                    self.sendAlert(
                        title: "心拍変動異常",
                        body: "短時間で\(Int(maxDiff)) BPMの変動を検出しました。"
                    )
                }
            }
        }
 
        healthStore.execute(query)
    }
 
    func sendAlert(title: String, body: String) {
        let content = UNMutableNotificationContent()
        content.title = title
        content.body = body
        content.sound = .default
 
        let request = UNNotificationRequest(
            identifier: UUID().uuidString,
            content: content,
            trigger: nil  // 即時通知
        )
 
        UNUserNotificationCenter.current().add(request)
    }
}

import CoreMotion
import CoreML
 
class GaitAnalyzer {
    let motionManager = CMMotionManager()
    let pedometer = CMPedometer()
    var accelerometerBuffer: [(x: Double, y: Double, z: Double, t: Double)] = []
 
    /// 加速度計のバッチ収集開始
    func startGaitCollection() {
        guard motionManager.isAccelerometerAvailable else { return }
 
        // 50Hzでサンプリング（バッテリー効率を考慮）
        motionManager.accelerometerUpdateInterval = 1.0 / 50.0
 
        motionManager.startAccelerometerUpdates(to: .main) {
            [weak self] data, error in
            guard let data = data else { return }
 
            self?.accelerometerBuffer.append((
                x: data.acceleration.x,
                y: data.acceleration.y,
                z: data.acceleration.z,
                t: data.timestamp
            ))
 
            // 10秒分のデータが溜まったら分析
            if let self = self,
               self.accelerometerBuffer.count >= 500 {
                self.analyzeGait()
            }
        }
    }
 
    /// 歩行パターン分析
    func analyzeGait() {
        let buffer = accelerometerBuffer
        accelerometerBuffer.removeAll()
 
        // 特徴量の計算
        let magnitudes = buffer.map {
            sqrt($0.x * $0.x + $0.y * $0.y + $0.z * $0.z)
        }
 
        let mean = magnitudes.reduce(0, +) / Double(magnitudes.count)
        let variance = magnitudes.map { ($0 - mean) * ($0 - mean) }
            .reduce(0, +) / Double(magnitudes.count)
        let stdDev = sqrt(variance)
 
        // ステップ検出（ゼロクロッシング法）
        let detrended = magnitudes.map { $0 - mean }
        var stepCount = 0
        for i in 1..<detrended.count {
            if detrended[i-1] < 0 && detrended[i] >= 0 {
                stepCount += 1
            }
        }
 
        // 歩行対称性の計算
        let halfLen = magnitudes.count / 2
        let firstHalf = Array(magnitudes[..<halfLen])
        let secondHalf = Array(magnitudes[halfLen...])
        let symmetryScore = calculateSymmetry(firstHalf, secondHalf)
 
        // 歩行品質スコア
        let gaitScore = evaluateGaitQuality(
            stepRegularity: stdDev,
            symmetry: symmetryScore,
            cadence: Double(stepCount) * 6.0  // 10秒間 → 1分換算
        )
 
        print("歩数(10秒): \(stepCount)")
        print("ケイデンス: \(stepCount * 6) steps/min")
        print("対称性スコア: \(String(format: "%.2f", symmetryScore))")
        print("歩行品質スコア: \(String(format: "%.0f", gaitScore))/100")
    }
 
    func calculateSymmetry(_ a: [Double], _ b: [Double]) -> Double {
        let minLen = min(a.count, b.count)
        var correlation = 0.0
        let meanA = a.prefix(minLen).reduce(0, +) / Double(minLen)
        let meanB = b.prefix(minLen).reduce(0, +) / Double(minLen)
 
        var numerator = 0.0
        var denomA = 0.0
        var denomB = 0.0
 
        for i in 0..<minLen {
            let da = a[i] - meanA
            let db = b[i] - meanB
            numerator += da * db
            denomA += da * da
            denomB += db * db
        }
 
        let denom = sqrt(denomA * denomB)
        return denom > 0 ? numerator / denom : 0
    }
 
    func evaluateGaitQuality(stepRegularity: Double,
                             symmetry: Double,
                             cadence: Double) -> Double {
        // 正常範囲: ケイデンス 100-130, 対称性 0.8+
        var score = 100.0
 
        if cadence < 80 || cadence > 150 {
            score -= 20  // 異常なケイデンス
        }
        if symmetry < 0.7 {
            score -= 30  // 非対称な歩行
        } else if symmetry < 0.85 {
            score -= 15
        }
        if stepRegularity > 0.3 {
            score -= 15  // 不規則な歩行
        }
 
        return max(0, min(100, score))
    }
}

import androidx.health.connect.client.HealthConnectClient
import androidx.health.connect.client.records.SleepSessionRecord
import androidx.health.connect.client.records.SleepStageRecord
import androidx.health.connect.client.request.ReadRecordsRequest
import androidx.health.connect.client.time.TimeRangeFilter
import java.time.Instant
import java.time.ZoneOffset
import java.time.LocalDate
import java.time.Duration
 
class SleepAnalyzer(private val healthClient: HealthConnectClient) {
 
    /**
     * 睡眠セッションの記録
     */
    suspend fun recordSleepSession(
        startTime: Instant,
        endTime: Instant,
        stages: List<Pair<Instant, SleepStageRecord.StageType>>
    ) {
        // 睡眠段階レコードの作成
        val stageRecords = stages.zipWithNext().map { (current, next) ->
            SleepStageRecord(
                startTime = current.first,
                startZoneOffset = ZoneOffset.ofHours(9),
                endTime = next.first,
                endZoneOffset = ZoneOffset.ofHours(9),
                stage = current.second
            )
        }
 
        // 睡眠セッションレコードの作成
        val sessionRecord = SleepSessionRecord(
            startTime = startTime,
            startZoneOffset = ZoneOffset.ofHours(9),
            endTime = endTime,
            endZoneOffset = ZoneOffset.ofHours(9),
            stages = stageRecords.map {
                SleepSessionRecord.Stage(
                    startTime = it.startTime,
                    endTime = it.endTime,
                    stage = when (it.stage) {
                        SleepStageRecord.StageType.AWAKE ->
                            SleepSessionRecord.STAGE_TYPE_AWAKE
                        SleepStageRecord.StageType.LIGHT ->
                            SleepSessionRecord.STAGE_TYPE_LIGHT
                        SleepStageRecord.StageType.DEEP ->
                            SleepSessionRecord.STAGE_TYPE_DEEP
                        SleepStageRecord.StageType.REM ->
                            SleepSessionRecord.STAGE_TYPE_REM
                        else -> SleepSessionRecord.STAGE_TYPE_UNKNOWN
                    }
                )
            }
        )
 
        healthClient.insertRecords(listOf(sessionRecord))
        println("睡眠セッションを記録しました")
    }
 
    /**
     * 過去7日間の睡眠分析レポート
     */
    suspend fun generateWeeklySleepReport(): SleepReport {
        val now = Instant.now()
        val weekAgo = now.minus(Duration.ofDays(7))
 
        val request = ReadRecordsRequest(
            recordType = SleepSessionRecord::class,
            timeRangeFilter = TimeRangeFilter.between(weekAgo, now)
        )
 
        val sessions = healthClient.readRecords(request).records
 
        val dailyStats = sessions.map { session ->
            val duration = Duration.between(session.startTime, session.endTime)
            val stages = session.stages
 
            val deepSleep = stages
                .filter { it.stage == SleepSessionRecord.STAGE_TYPE_DEEP }
                .sumOf { Duration.between(it.startTime, it.endTime).toMinutes() }
 
            val remSleep = stages
                .filter { it.stage == SleepSessionRecord.STAGE_TYPE_REM }
                .sumOf { Duration.between(it.startTime, it.endTime).toMinutes() }
 
            val awakeTime = stages
                .filter { it.stage == SleepSessionRecord.STAGE_TYPE_AWAKE }
                .sumOf { Duration.between(it.startTime, it.endTime).toMinutes() }
 
            DailySleep(
                date = session.startTime,
                totalMinutes = duration.toMinutes(),
                deepMinutes = deepSleep,
                remMinutes = remSleep,
                awakeMinutes = awakeTime,
                sleepEfficiency = ((duration.toMinutes() - awakeTime).toFloat()
                    / duration.toMinutes() * 100)
            )
        }
 
        return SleepReport(
            averageDuration = dailyStats.map { it.totalMinutes }.average(),
            averageDeepSleep = dailyStats.map { it.deepMinutes }.average(),
            averageRemSleep = dailyStats.map { it.remMinutes }.average(),
            averageEfficiency = dailyStats.map { it.sleepEfficiency.toDouble() }.average(),
            sleepScore = calculateSleepScore(dailyStats),
            recommendation = generateRecommendation(dailyStats)
        )
    }
 
    private fun calculateSleepScore(stats: List<DailySleep>): Int {
        var score = 100
        val avgDuration = stats.map { it.totalMinutes }.average()
        val avgEfficiency = stats.map { it.sleepEfficiency.toDouble() }.average()
        val avgDeep = stats.map { it.deepMinutes }.average()
 
        // 睡眠時間: 7-9時間が理想
        if (avgDuration < 360) score -= 25       // 6時間未満
        else if (avgDuration < 420) score -= 10  // 6-7時間
        else if (avgDuration > 600) score -= 5   // 10時間超過
 
        // 睡眠効率: 85%以上が理想
        if (avgEfficiency < 75) score -= 20
        else if (avgEfficiency < 85) score -= 10
 
        // 深い睡眠: 総睡眠時間の15-25%が理想
        val deepRatio = avgDeep / avgDuration * 100
        if (deepRatio < 10) score -= 15
        else if (deepRatio < 15) score -= 5
 
        return score.coerceIn(0, 100)
    }
 
    private fun generateRecommendation(stats: List<DailySleep>): String {
        val avgDuration = stats.map { it.totalMinutes }.average()
        val avgDeep = stats.map { it.deepMinutes }.average()
 
        return when {
            avgDuration < 360 -> "睡眠時間が不足しています。就寝時間を30分早めることをお勧めします。"
            avgDeep < avgDuration * 0.10 -> "深い睡眠が少なめです。就寝前のカフェインやスクリーンタイムを減らしましょう。"
            else -> "良好な睡眠パターンです。この調子を維持しましょう。"
        }
    }
}
 
data class DailySleep(
    val date: Instant,
    val totalMinutes: Long,
    val deepMinutes: Long,
    val remMinutes: Long,
    val awakeMinutes: Long,
    val sleepEfficiency: Float
)
 
data class SleepReport(
    val averageDuration: Double,
    val averageDeepSleep: Double,
    val averageRemSleep: Double,
    val averageEfficiency: Double,
    val sleepScore: Int,
    val recommendation: String
)

class AIFitnessCoach:
    """
    ウェアラブルデータに基づくAIフィットネスコーチ
    心拍ゾーン、HRV、睡眠スコアから最適なトレーニングを推奨
    """
    def __init__(self, user_profile):
        self.max_hr = 220 - user_profile['age']  # 最大心拍数の推定
        self.resting_hr = user_profile.get('resting_hr', 60)
        self.fitness_level = user_profile.get('fitness_level', 'intermediate')
 
    def calculate_training_readiness(self, hrv_rmssd, sleep_score,
                                      previous_training_load):
        """
        トレーニング準備度スコアの計算
        HRV、睡眠、前日のトレーニング負荷から総合判定
        """
        # HRV スコア (0-40点): 自律神経回復度
        hrv_baseline = 45.0  # 個人のベースライン（学習で更新）
        hrv_score = min(40, max(0, (hrv_rmssd / hrv_baseline) * 30))
 
        # 睡眠スコア (0-30点)
        sleep_component = min(30, sleep_score * 0.3)
 
        # 回復スコア (0-30点): 前日の負荷が高いほど低い
        recovery_score = max(0, 30 - previous_training_load * 0.3)
 
        total = hrv_score + sleep_component + recovery_score
 
        return {
            'total_score': round(total),
            'hrv_component': round(hrv_score),
            'sleep_component': round(sleep_component),
            'recovery_component': round(recovery_score),
            'recommendation': self._get_recommendation(total)
        }
 
    def _get_recommendation(self, readiness_score):
        if readiness_score >= 80:
            return {
                'intensity': 'high',
                'suggestion': '高強度トレーニング推奨（インターバル、テンポ走）',
                'hr_zone_target': 'ゾーン4-5 (80-100% max HR)',
                'duration_minutes': 45
            }
        elif readiness_score >= 60:
            return {
                'intensity': 'moderate',
                'suggestion': '中強度トレーニング推奨（ペース走、筋トレ）',
                'hr_zone_target': 'ゾーン3 (70-80% max HR)',
                'duration_minutes': 60
            }
        elif readiness_score >= 40:
            return {
                'intensity': 'low',
                'suggestion': '軽めのトレーニング推奨（ジョグ、ヨガ、ストレッチ）',
                'hr_zone_target': 'ゾーン1-2 (50-70% max HR)',
                'duration_minutes': 30
            }
        else:
            return {
                'intensity': 'rest',
                'suggestion': '完全休養推奨。回復に集中してください。',
                'hr_zone_target': 'なし',
                'duration_minutes': 0
            }
 
    def analyze_workout(self, hr_data, duration_minutes):
        """ワークアウト後の分析"""
        hr_reserve = self.max_hr - self.resting_hr
 
        trimp = 0  # Training Impulse
        for hr in hr_data:
            hr_ratio = (hr - self.resting_hr) / hr_reserve
            trimp += hr_ratio * 0.64 * (2.718 ** (1.92 * hr_ratio))
 
        trimp *= (duration_minutes / len(hr_data))
 
        zone_distribution = self._calculate_zone_distribution(hr_data)
 
        return {
            'trimp_score': round(trimp, 1),
            'training_effect': self._training_effect(trimp),
            'zone_distribution': zone_distribution,
            'peak_hr': max(hr_data),
            'avg_hr': sum(hr_data) / len(hr_data),
            'calories_estimated': round(trimp * 0.8)
        }
 
    def _calculate_zone_distribution(self, hr_data):
        zones = {f'ゾーン{i}': 0 for i in range(1, 6)}
        for hr in hr_data:
            pct = hr / self.max_hr * 100
            if pct < 60: zones['ゾーン1'] += 1
            elif pct < 70: zones['ゾーン2'] += 1
            elif pct < 80: zones['ゾーン3'] += 1
            elif pct < 90: zones['ゾーン4'] += 1
            else: zones['ゾーン5'] += 1
 
        total = len(hr_data)
        return {k: f"{v/total*100:.1f}%" for k, v in zones.items()}
 
    def _training_effect(self, trimp):
        if trimp < 50: return "リカバリー"
        elif trimp < 100: return "有酸素基盤強化"
        elif trimp < 200: return "有酸素能力向上"
        elif trimp < 300: return "高強度持久力向上"
        else: return "オーバーリーチ（注意）"
 
# 使用例
coach = AIFitnessCoach({'age': 35, 'resting_hr': 55})
readiness = coach.calculate_training_readiness(
    hrv_rmssd=52.0, sleep_score=82, previous_training_load=65
)
print(f"トレーニング準備度: {readiness['total_score']}/100")
print(f"推奨: {readiness['recommendation']['suggestion']}")

// HealthKit の権限確認
let status = healthStore.authorizationStatus(
    for: HKQuantityType.quantityType(forIdentifier: .heartRate)!
)
 
switch status {
case .notDetermined:
    // まだ権限をリクエストしていない
    requestAuthorization()
case .sharingAuthorized:
    // 書き込み権限あり（読み取り権限は確認できない仕様）
    print("権限OK")
case .sharingDenied:
    // 権限が拒否されている
    // 設定アプリに誘導
    print("設定 > プライバシー > ヘルスケア から権限を有効にしてください")
}

# Core ML モデルの量子化で推論速度とバッテリー効率を改善
import coremltools as ct
 
# 学習済みモデルの読み込み
model = ct.models.MLModel("HeartRateClassifier.mlpackage")
 
# INT8 量子化（メモリ使用量を75%削減）
quantized_model = ct.models.neural_network.quantization_utils.quantize_weights(
    model,
    nbits=8,  # 32bit → 8bit
    quantization_mode="linear"
)
quantized_model.save("HeartRateClassifier_INT8.mlpackage")
 
# パフォーマンス比較
# FP32: 推論時間 5ms, モデルサイズ 2.4MB, メモリ 8MB
# INT8: 推論時間 2ms, モデルサイズ 0.6MB, メモリ 2MB
# Neural Engine 使用時はさらに高速化

// BLE データ転送の最適化パターン
class OptimizedBLETransfer {
    // NG: 毎秒データを送信
    // → BLE接続の維持とデータ転送で電力消費大
 
    // OK: データをバッファリングし、5分ごとにまとめて送信
    var dataBuffer: [HealthSample] = []
    let transferInterval: TimeInterval = 300  // 5分
 
    func addSample(_ sample: HealthSample) {
        dataBuffer.append(sample)
 
        // バッファが閾値に達したら送信
        if dataBuffer.count >= 300 {  // 5分 × 1Hz = 300サンプル
            transferData()
        }
    }
 
    func transferData() {
        // Delta圧縮: 前のサンプルとの差分のみ送信
        let compressed = deltaCompress(dataBuffer)
 
        // BLE MTU に合わせてチャンク分割
        let chunks = compressed.chunked(into: 512)  // 512 bytes/chunk
 
        for chunk in chunks {
            peripheral.writeValue(chunk, for: characteristic, type: .withResponse)
        }
 
        dataBuffer.removeAll()
    }
 
    func deltaCompress(_ samples: [HealthSample]) -> Data {
        // 心拍値の差分エンコーディング
        // [72, 73, 72, 74, 71] → [72, +1, -1, +2, -3]
        // 差分は小さい値なので少ないビット数で表現可能
        var encoded = Data()
        encoded.append(contentsOf: withUnsafeBytes(of: samples[0].value) {
            Array($0)
        })
 
        for i in 1..<samples.count {
            let diff = Int8(samples[i].value - samples[i-1].value)
            encoded.append(contentsOf: withUnsafeBytes(of: diff) { Array($0) })
        }
 
        return encoded
    }
}

import Combine
import HealthKit
 
class ReactiveHealthPipeline {
    private var cancellables = Set<AnyCancellable>()
    private let healthStore = HKHealthStore()
 
    /// 心拍データのリアクティブストリーム
    func heartRateStream() -> AnyPublisher<Double, Never> {
        let subject = PassthroughSubject<Double, Never>()
 
        let heartRateType = HKQuantityType.quantityType(
            forIdentifier: .heartRate)!
 
        let query = HKAnchoredObjectQuery(
            type: heartRateType,
            predicate: nil,
            anchor: nil,
            limit: HKObjectQueryNoLimit
        ) { _, samples, _, _, _ in
            guard let samples = samples as? [HKQuantitySample] else { return }
            for sample in samples {
                let bpm = sample.quantity.doubleValue(
                    for: HKUnit(from: "count/min"))
                subject.send(bpm)
            }
        }
 
        query.updateHandler = { _, samples, _, _, _ in
            guard let samples = samples as? [HKQuantitySample] else { return }
            for sample in samples {
                let bpm = sample.quantity.doubleValue(
                    for: HKUnit(from: "count/min"))
                subject.send(bpm)
            }
        }
 
        healthStore.execute(query)
 
        return subject.eraseToAnyPublisher()
    }
 
    /// パイプライン構築: フィルタ → 分析 → アラート
    func setupPipeline() {
        heartRateStream()
            // ノイズ除去: 生理学的にありえない値を除外
            .filter { $0 > 30 && $0 < 250 }
            // 移動平均: 5サンプルの平均を取る
            .scan([Double]()) { buffer, newValue in
                var buf = buffer
                buf.append(newValue)
                if buf.count > 5 { buf.removeFirst() }
                return buf
            }
            .map { buffer -> Double in
                buffer.reduce(0, +) / Double(buffer.count)
            }
            // 異常検出
            .sink { avgBPM in
                if avgBPM > 120 {
                    NotificationCenter.default.post(
                        name: .highHeartRate,
                        object: nil,
                        userInfo: ["bpm": avgBPM]
                    )
                }
            }
            .store(in: &cancellables)
    }
}
 
extension Notification.Name {
    static let highHeartRate = Notification.Name("highHeartRate")
}