quantrs2-device 0.1.3

Quantum device connectors for the QuantRS2 framework
Documentation 
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
135
136
137
138

//! Resource scaling configurations

use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Resource scaling configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceScalingConfig {
    /// Auto-scaling
    pub auto_scaling: AutoScalingConfig,
    /// Manual scaling
    pub manual_scaling: ManualScalingConfig,
    /// Predictive scaling
    pub predictive_scaling: PredictiveScalingConfig,
}

/// Auto-scaling configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AutoScalingConfig {
    /// Enable auto-scaling
    pub enabled: bool,
    /// Scaling policies
    pub policies: Vec<ScalingPolicy>,
    /// Cooldown period
    pub cooldown_period: Duration,
    /// Scaling limits
    pub limits: ScalingLimits,
}

/// Scaling policy
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScalingPolicy {
    /// Policy name
    pub name: String,
    /// Trigger conditions
    pub conditions: Vec<ScalingCondition>,
    /// Scaling action
    pub action: ScalingAction,
    /// Priority
    pub priority: u8,
}

/// Scaling condition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScalingCondition {
    /// Metric name
    pub metric: String,
    /// Operator
    pub operator: ComparisonOperator,
    /// Threshold
    pub threshold: f64,
    /// Duration
    pub duration: Duration,
}

/// Comparison operators
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ComparisonOperator {
    GreaterThan,
    LessThan,
    Equal,
    GreaterThanOrEqual,
    LessThanOrEqual,
    NotEqual,
}

/// Scaling actions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScalingAction {
    /// Action type
    pub action_type: ScalingActionType,
    /// Scale amount
    pub amount: ScalingAmount,
    /// Target group
    pub target: String,
}

/// Scaling action types
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ScalingActionType {
    ScaleUp,
    ScaleDown,
    ScaleOut,
    ScaleIn,
}

/// Scaling amount
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ScalingAmount {
    Absolute(u32),
    Percentage(f64),
    Capacity(f64),
}

/// Scaling limits
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScalingLimits {
    /// Minimum instances
    pub min_instances: usize,
    /// Maximum instances
    pub max_instances: usize,
    /// Maximum scaling rate
    pub max_scaling_rate: f64,
}

/// Manual scaling configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ManualScalingConfig {
    /// Default instance count
    pub default_instances: usize,
    /// Scaling increments
    pub scaling_increments: Vec<usize>,
    /// Approval required
    pub approval_required: bool,
}

/// Predictive scaling configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PredictiveScalingConfig {
    /// Enable predictive scaling
    pub enabled: bool,
    /// Prediction models
    pub models: Vec<PredictionModel>,
    /// Forecast horizon
    pub forecast_horizon: Duration,
    /// Confidence threshold
    pub confidence_threshold: f64,
}

/// Prediction models
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum PredictionModel {
    ARIMA,
    LinearRegression,
    NeuralNetwork,
    EnsembleModel,
    Custom(String),
}