rfconversions 0.7.4

Common Radio Frequency conversion equations for RF Modeling
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

/// Integration tests matching every code example in README.md

// === Section 1: Power Conversions ===

#[test]
fn power_watts_to_dbm() {
    let dbm = rfconversions::power::watts_to_dbm(1.0);
    assert_eq!(dbm, 30.0);
}

#[test]
fn power_dbm_to_watts() {
    let watts = rfconversions::power::dbm_to_watts(30.0);
    assert_eq!(watts, 1.0);
}

#[test]
fn power_db_to_linear() {
    let linear = rfconversions::power::db_to_linear(30.0);
    assert_eq!(linear, 1000.0);
}

#[test]
fn power_linear_to_db() {
    let db = rfconversions::power::linear_to_db(1000.0);
    assert_eq!(db, 30.0);
}

// === Section 2: Frequency Conversions ===

#[test]
fn frequency_mhz_to_ghz() {
    let ghz = rfconversions::frequency::mhz_to_ghz(2400.0);
    assert_eq!(ghz, 2.4);
}

#[test]
fn frequency_ghz_to_hz() {
    let hz = rfconversions::frequency::ghz_to_hz(1.0);
    assert_eq!(hz, 1_000_000_000.0);
}

#[test]
fn frequency_khz_to_mhz() {
    let mhz = rfconversions::frequency::khz_to_mhz(1500.0);
    assert_eq!(mhz, 1.5);
}

#[test]
fn frequency_ghz_to_thz() {
    let thz = rfconversions::frequency::ghz_to_thz(1000.0);
    assert_eq!(thz, 1.0);
}

#[test]
fn frequency_to_wavelength() {
    let wavelength = rfconversions::frequency::frequency_to_wavelength(1.0e9);
    assert_eq!(wavelength, 0.299792458);
}

// === Section 3: Noise ===

#[test]
fn noise_figure_from_noise_factor() {
    let nf_db = rfconversions::noise::noise_figure_from_noise_factor(2.0);
    assert!((nf_db - 3.010299956639812).abs() < 1e-12);
}

#[test]
fn noise_factor_from_noise_figure() {
    let nf_linear = rfconversions::noise::noise_factor_from_noise_figure(3.010299956639812);
    assert_eq!(nf_linear, 2.0);
}

#[test]
fn noise_temperature_from_noise_factor() {
    let temp = rfconversions::noise::noise_temperature_from_noise_factor(2.0);
    assert_eq!(temp, 290.0);
}

#[test]
fn noise_factor_from_noise_temperature() {
    let factor = rfconversions::noise::noise_factor_from_noise_temperature(290.0);
    assert_eq!(factor, 2.0);
}

#[test]
fn noise_temperature_from_noise_figure() {
    let temp = rfconversions::noise::noise_temperature_from_noise_figure(6.0);
    assert!((temp - 864.510794605142).abs() < 1e-6);
}

#[test]
fn noise_figure_from_noise_temperature() {
    let nf_db = rfconversions::noise::noise_figure_from_noise_temperature(290.0);
    assert!((nf_db - 3.010299956639812).abs() < 1e-12);
}

#[test]
fn noise_power_from_bandwidth() {
    let noise_power = rfconversions::noise::noise_power_from_bandwidth(290.0, 100.0e6);
    // Verify it's kTB using exact Boltzmann constant
    let expected = rfconversions::constants::BOLTZMANN * 290.0 * 100.0e6;
    assert_eq!(noise_power, expected);
}

// === Section 4: P1dB ===

#[test]
fn p1db_input_to_output() {
    let output_p1db = rfconversions::p1db::input_to_output_db(5.0, 30.0);
    assert_eq!(output_p1db, 34.0);
}

#[test]
fn p1db_output_to_input() {
    let input_p1db = rfconversions::p1db::output_to_input_db(34.0, 30.0);
    assert_eq!(input_p1db, 5.0);
}

// === Section 5: Constants ===

#[test]
fn speed_of_light() {
    let c = rfconversions::constants::SPEED_OF_LIGHT;
    assert_eq!(c, 299_792_458.0);
}