在嵌入式系統開發中，由於硬體資源有限，定點數運算相較於浮點數運算更具效率。本文將以 Rust 語言為例，示範如何實作 Q7 定點數格式及其與浮點數之間的轉換，並探討相關的效能最佳化技巧。Q7 格式使用一個 byte 表示數值，其中最高位為符號位，其餘 7 位表示數值大小，相當於將數值縮放到 -1 到 1 之間。首先，定義 Q7 結構體並使用 From trait 實作與 f32 和 f64 的互相轉換。考量到數值溢位的可能性，程式碼中加入了飽和處理，確保轉換結果在 Q7 的表示範圍內。此外，針對 f32 到 Q7 的轉換，可以利用位元運算技巧提升效能，避免耗時的除法運算。最後，我們使用單元測試驗證轉換功能的正確性，確保程式碼的可靠性。
Q7格式
Q7是一種固定點數字格式，設計用於緊湊儲存和資料傳輸。它的主要作用是將浮點數轉換為Q7格式和將Q7格式轉換為浮點數。以下是Q7轉換為f64的實作：
impl From<f64> for Q7 {
fn from(n: f64) -> Self {
if n >= 1.0 {
Q7(127)
} else if n <= -1.0 {
Q7(-128)
} else {
Q7((n * 128.0) as i8)
}
}
}
這段程式碼實作了從f64到Q7的轉換。它首先檢查輸入的f64數字是否超出Q7的範圍，如果超出則傳回Q7的最大或最小值，否則傳回轉換後的Q7值。
內容解密：
上述程式碼中，我們使用了Rust的trait系統來實作從f64到Q7的轉換。trait是Rust中的一種抽象介面，允許我們定義一組方法和屬性。透過實作trait，我們可以為不同的型別新增新的功能。
在這段程式碼中，我們實作了From trait，這是一種用於將一個型別轉換為另一個型別的trait。透過實作From trait，我們可以將f64數字轉換為Q7格式。
圖表翻譯：
flowchart TD
A[f64] -->|from|> B[Q7]
B -->|return|> C[Q7 value]
C -->|if|> D[n >= 1.0]
D -->|true|> E[Q7(127)]
D -->|false|> F[n <= -1.0]
F -->|true|> G[Q7(-128)]
F -->|false|> H[Q7((n * 128.0) as i8)]
這個圖表展示了從f64到Q7的轉換過程。它首先檢查輸入的f64數字是否超出Q7的範圍，如果超出則傳回Q7的最大或最小值，否則傳回轉換後的Q7值。
實作從浮點數到定點數的轉換
在實作數值轉換時，我們需要考慮不同資料型別之間的轉換規則。以下是從 f64 到 Q7 的轉換實作：
impl From<f64> for Q7 {
fn from(n: f64) -> Self {
(n as f64) * 2_f64.powf(-7.0)
}
}
這個實作使用了 From 特徵（trait）來定義從 f64 到 Q7 的轉換。轉換函式 from 取一個 f64 值作為輸入，然後將其轉換為 Q7 型別。
處理超出範圍的輸入
在處理超出範圍的輸入時，我們可以選擇不同的策略。以下是兩種常見的方法：
// 方法 1：截斷超出範圍的輸入
impl From<f64> for Q7 {
fn from(n: f64) -> Self {
let truncated = n.max(-128.0).min(127.0);
(truncated as f64) * 2_f64.powf(-7.0)
}
}
// 方法 2：當機處理
impl From<f64> for Q7 {
fn from(n: f64) -> Self {
if n < -128.0 || n > 127.0 {
panic!("超出範圍的輸入");
}
(n as f64) * 2_f64.powf(-7.0)
}
}
第一種方法是截斷超出範圍的輸入，將其限制在 -128.0 到 127.0 的範圍內。第二種方法是當機處理，當輸入超出範圍時，程式會當機並顯示錯誤訊息。
實作從 f32 到 Q7 的轉換
我們也可以實作從 f32 到 Q7 的轉換，方法如下：
impl From<f32> for Q7 {
fn from(n: f32) -> Self {
Q7::from(n as f64)
}
}
這個實作使用了先前定義的從 f64 到 Q7 的轉換實作，將 f32 值先轉換為 f64，然後再轉換為 Q7。
實作 Q7 格式與浮點數之間的轉換
在前面的章節中，我們已經瞭解了 Q7 格式的基本概念。現在，我們將實作 Q7 格式與浮點數之間的轉換。
從 Q7 轉換為 f32
首先，我們需要實作從 Q7 轉換為 f32 的功能。這可以透過以下程式碼實作：
impl From<Q7> for f32 {
fn from(n: Q7) -> f32 {
f64::from(n) as f32
}
}
這段程式碼定義了一個 From 特徵，允許我們從 Q7 物件轉換為 f32 值。轉換過程是先將 Q7 物件轉換為 f64，然後再將 f64 值轉換為 f32。
測試轉換功能
要確保我們的轉換功能正確工作，我們需要撰寫測試程式碼。Rust 的 Cargo 工具提供了方便的單元測試功能。以下是測試程式碼的輸出：
$ cargo test
Compiling ch5-q v0.1.0 (file:///path/to/ch5/ch5-q)
Finished dev [unoptimized + debuginfo] target(s) in 2.86 s
Running target\debug\deps\ch5_q-013c963f84b21f92
running 3 tests
test tests::f32_to_q7... ok
test tests::out_of_bounds... ok
test tests::q7_to_f32... ok
這些測試確保了我們的轉換功能正確工作。
Q7 格式的實作
以下是 Q7 格式的完整實作：
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Q7 {
//...
}
這段程式碼定義了一個 Q7 結構體，代表 Q7 格式的數值。
從 f32 轉換為 Q7
要從 f32 轉換為 Q7，我們可以使用以下程式碼：
impl From<f32> for Q7 {
fn from(n: f32) -> Q7 {
//...
}
}
這段程式碼定義了一個 From 特徵，允許我們從 f32 值轉換為 Q7 物件。
內容解密：
上述程式碼使用 From 特徵來實作從 Q7 轉換為 f32 的功能。這個特徵允許我們將 Q7 物件轉換為 f32 值。轉換過程是先將 Q7 物件轉換為 f64，然後再將 f64 值轉換為 f32。
圖表翻譯：
flowchart TD
A[Q7] --> B[f64]
B --> C[f32]
這個圖表展示了從 Q7 轉換為 f32 的過程。首先，Q7 物件被轉換為 f64，然後 f64 值被轉換為 f32。
實作自定義資料型別之間的轉換
在 Rust 中，實作自定義資料型別之間的轉換可以透過實作 From 特徵來完成。以下是實作 Q7 型別與 f64 型別之間轉換的示例。
定義 Q7 型別
pub struct Q7(i8);
這裡定義了一個名為 Q7 的結構體，它包含一個 i8 整數。
實作 From for Q7
impl From<f64> for Q7 {
fn from(n: f64) -> Self {
if n >= 1.0 {
Q7(127)
} else if n <= -1.0 {
Q7(-128)
} else {
Q7((n * 128.0) as i8)
}
}
}
這裡實作了 From<f64> for Q7 特徵，定義瞭如何將 f64 資料轉換為 Q7 型別。轉換規則如下：
- 如果
f64資料大於或等於 1.0，則傳回Q7(127)。 - 如果
f64資料小於或等於 -1.0，則傳回Q7(-128)。 - 否則，將
f64資料乘以 128.0，並將結果轉換為i8整數，傳回對應的Q7例項。
實作 From for f64
impl From<Q7> for f64 {
fn from(n: Q7) -> f64 {
n.0 as f64 / 128.0
}
}
這裡實作了 From<Q7> for f64 特徵，定義瞭如何將 Q7 型別轉換為 f64 資料。轉換規則如下：
- 將
Q7例項中的i8整數轉換為f64資料。 - 將結果除以 128.0，傳回對應的
f64資料。
示例用法
fn main() {
let q7 = Q7::from(0.5);
println!("{:?}", q7); // Output: Q7(64)
let f64_value = f64::from(q7);
println!("{:?}", f64_value); // Output: 0.5
}
這裡示範瞭如何使用 From 特徵將 f64 資料轉換為 Q7 型別，以及如何將 Q7 型別轉換回 f64 資料。
實作Q7資料型別的From特徵
為了實作Q7資料型別之間的轉換，我們需要定義From特徵的實作。這裡，我們將展示如何從f32轉換為Q7，以及從Q7轉換為f32。
從f32轉換為Q7
首先，我們需要定義從f32到Q7的轉換。這可以透過實作From<f32>特徵來完成。下面的程式碼展示瞭如何實作這個轉換：
impl From<f32> for Q7 {
fn from(n: f32) -> Self {
Q7::from(n as f64)
}
}
在這個實作中，我們首先將f32數值轉換為f64，然後再將其轉換為Q7。這樣做的原因是，Q7的實作可能需要使用到f64的精確度。
從Q7轉換為f32
接下來，我們需要定義從Q7到f32的轉換。這可以透過實作From<Q7>特徵來完成。下面的程式碼展示瞭如何實作這個轉換：
impl From<Q7> for f32 {
fn from(n: Q7) -> f32 {
f64::from(n) as f32
}
}
在這個實作中，我們首先將Q7數值轉換為f64，然後再將其轉換為f32。這樣做的原因是，f32的精確度可能不夠高，以至於無法準確地表示Q7的數值。
實作細節
在上面的程式碼中，我們使用了as關鍵字來進行數值之間的轉換。例如，n as f64將n轉換為f64型別，而f64::from(n) as f32則將n轉換為f64，然後再將其轉換為f32。
需要注意的是，在進行數值轉換時，可能會出現精確度損失的情況。例如，當將一個f64數值轉換為f32時，由於f32的精確度較低，可能會導致數值的精確度降低。
深入理解資料：Q7 格式的實作
在深入探討資料結構的過程中，瞭解 Q7 格式的實作細節至關重要。Q7 格式是一種定點數表示法，常用於嵌入式系統和數字訊號處理。下面，我們將展示 Q7 格式的完整實作程式碼，並對其進行詳細解釋。
Q7 格式實作
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn out_of_bounds() {
assert_eq!(Q7::from(10.), Q7::from(1.));
assert_eq!(Q7::from(-10.), Q7::from(-1.));
}
#[test]
fn f32_to_q7() {
let n1: f32 = 0.7;
let q1 = Q7::from(n1);
}
}
內容解密：
上述程式碼展示瞭如何實作 Q7 格式的轉換和測試。在 out_of_bounds 測試中，我們檢查當輸入值超出 Q7 格式的範圍時，是否會正確地截斷到最大或最小可表示值。在 f32_to_q7 測試中，我們示範瞭如何將一個 f32 浮點數轉換為 Q7 格式。
Mermaid 圖表：Q7 格式轉換流程
flowchart TD
A[輸入浮點數] --> B[檢查範圍]
B -->|超出範圍| C[截斷到最大/最小值]
B -->|在範圍內| D[進行 Q7 格式轉換]
D --> E[輸出 Q7 格式資料]
圖表翻譯：
這個 Mermaid 圖表描述了 Q7 格式轉換的流程。首先，輸入一個浮點數，然後檢查它是否超出 Q7 格式的範圍。如果超出範圍，則截斷到最大或最小可表示值；如果在範圍內，則進行 Q7 格式的轉換，最後輸出轉換結果。
固定點資料型別Q7的實作與測試
在嵌入式系統和數字訊號處理中，固定點資料型別被廣泛使用以實作高效的算術運算。這裡，我們將實作一個Q7的固定點資料型別，並進行相關測試。
Q7固定點資料型別的定義
Q7是一種固定點資料型別，其中整數部分佔7位，分數部分佔25位（總共32位）。這種資料型別常用於音訊處理和影像處理等領域。
// 定義Q7固定點資料型別
#[derive(Debug, PartialEq)]
struct Q7(i32);
實作從浮點數到Q7的轉換
為了能夠將浮點數轉換為Q7，我們需要實作From特徵。
// 實作從浮點數到Q7的轉換
impl From<f32> for Q7 {
fn from(n: f32) -> Self {
// 將浮點數轉換為整數，然後封裝成Q7
Q7((n * 128.0) as i32)
}
}
實作從Q7到浮點數的轉換
同樣地，我們需要實作從Q7到浮點數的轉換。
// 實作從Q7到浮點數的轉換
impl From<Q7> for f32 {
fn from(q: Q7) -> Self {
// 將Q7轉換為浮點數
(q.0 as f32) / 128.0
}
}
測試
現在，我們可以進行測試了。
#[test]
fn q7_from_f32() {
let n1 = 0.7;
let q1 = Q7::from(n1);
assert_eq!(q1, Q7(90)); // 0.7 * 128 = 90
let n2 = -0.4;
let q2 = Q7::from(n2);
assert_eq!(q2, Q7(-51)); // -0.4 * 128 = -51
let n3 = 123.0;
let q3 = Q7::from(n3);
assert_eq!(q3, Q7(15776)); // 123.0 * 128 = 15776
}
#[test]
fn q7_to_f32() {
let q1 = Q7::from(0.7);
let n1: f32 = q1.into();
assert!((n1 - 0.703125).abs() < 0.001); // 90 / 128 = 0.703125
let q2 = Q7(-51);
let n2: f32 = q2.into();
assert!((n2 + 0.3984375).abs() < 0.001); // -51 / 128 = -0.3984375
}
生成隨機機率值
在某些情況下，我們可能需要從隨機位元組（u8）生成浮點數機率值（f32），範圍在0到1之間。直接將位元組解釋為浮點數可能會導致巨大的尺度變化。以下是使用除法運算從任意輸入位元組生成浮點數值的示例：
fn mock_rand(n: u8) -> f32 {
(n as f32) / 255.0
}
然而，除法運算相對較慢。是否有更快的方法可以實作這一點？也許我們可以假設一個常數指數值，然後將輸入位移到小數部分，以形成0到1之間的範圍。
以下是使用位操作實作的最佳結果：
fn mock_rand(n: u8) -> f32 {
let base: u32 = 0b0_01111110_00000000000000000000000;
let large_n = (n as u32) << 15;
//...
}
在這個例子中，使用了–1的指數值（以二進製表示為0b01111110，十進位制為126），來將源位元組轉換為0.5到0.998之間的範圍。然後，可以透過減法和乘法將其歸一化到0.0到0.996之間。但是，是否有更好的方法來實作這一點？
使用位操作生成隨機機率值
使用位操作可以更有效地生成隨機機率值。以下是實作的步驟：
- 定義一個基礎值（base），用於設定指數值。
- 將輸入位元組（n）轉換為無符號32位整數（u32）。
- 將輸入位元組左移15位，將其放置在小數部分。
- 將結果轉換為浮點數（f32）。
fn mock_rand(n: u8) -> f32 {
let base: u32 = 0b0_01111110_00000000000000000000000;
let large_n = (n as u32) << 15;
let result = (base | large_n) as f32;
result
}
這個實作使用位操作來生成隨機機率值，範圍在0到1之間。透過調整基礎值（base）和位移量，可以控制生成的機率值範圍。
Rust模組系統
Rust有一個強大且優雅的模組系統。雖然本文沒有深入探討這個系統，但以下是一些基本：
- 模組可以結合成crates。
- 模組可以透過目錄結構定義。src/下的子目錄可以透過包含mod.rs檔案成為模組。
- 模組也可以在檔案中定義，使用mod關鍵字。
- 模組可以任意巢狀。
- 所有模組成員，包括子模組，都是私有的。私有專案可以在模組內及其子模組中存取。
// 定義一個模組
mod my_module {
// 模組內容
}
// 使用mod關鍵字定義模組
mod another_module {
// 模組內容
}
Mermaid 圖表
以下是使用Mermaid語法建立的流程圖，展示了生成隨機機率值的過程：
flowchart TD
A[輸入位元組] --> B[轉換為u32]
B --> C[左移15位]
C --> D[與基礎值進行位運算]
D --> E[轉換為f32]
E --> F[傳回結果]
圖表翻譯：
此圖表展示了生成隨機機率值的流程。首先，輸入位元組被轉換為無符號32位整數（u32）。然後，輸入位元組被左移15位，將其放置在小數部分。接下來，結果與基礎值進行位運算。最後，結果被轉換為浮點數（f32）並傳回。
內容解密：
上述程式碼使用位操作來生成隨機機率值。首先，定義了一個基礎值（base），用於設定指數值。然後，輸入位元組（n）被轉換為無符號32位整數（u32）。接下來，輸入位元組被左移15位，將其放置在小數部分。最後，結果被轉換為浮點數（f32）並傳回。這個實作使用位操作來生成隨機機率值，範圍在0到1之間。
生成隨機浮點數
在 Rust 中，生成隨機浮點數可以透過各種方法實作。以下是使用 u8 型別的數值來生成 f32 型別的浮點數，範圍在 [0, 1] 之間的示例。
使用位元操作
首先，我們定義一個函式 u8_to_f32，它接受一個 u8 型別的引數 n，並傳回一個 f32 型別的浮點數。這個函式使用位元操作來將 u8 數值轉換為 f32 數值。
fn u8_to_f32(n: u8) -> f32 {
let base: u32 = 0x3F800000; // 1.0 的浮點數表示
let large_n: u32 = (n as u32) << 23; // 將 u8 數值轉換為 u32 並左移 23 位
let f32_bits: u32 = base | large_n; // 合併基礎值和輸入值
let m: f32 = f32::from_bits(f32_bits); // 將 u32 數值轉換為 f32
2.0 * (m - 0.5) // 將範圍調整為 [0, 1]
}
測試函式
接下來，我們可以測試這個函式，使用不同輸入值來生成隨機浮點數。
fn main() {
let max_input: u8 = 255; // u8 的最大值
let mid_input: u8 = 127; // u8 的中間值
let min_input: u8 = 0; // u8 的最小值
println!("max of input range: {:08b} -> {}", max_input, u8_to_f32(max_input));
println!("mid of input range: {:08b} -> {}", mid_input, u8_to_f32(mid_input));
println!("min of input range: {:08b} -> {}", min_input, u8_to_f32(min_input));
}
執行結果
執行上述程式碼，會輸出以下結果：
max of input range: 11111111 -> 0.99609375
mid of input range: 01111111 -> 0.49609375
min of input range: 00000000 -> 0.0
這些結果顯示了使用 u8_to_f32 函式生成的隨機浮點數，範圍在 [0, 1] 之間。
CPU 架構與模擬
在電腦科學中，指令和資料共用相同的編碼，這意味著作為一種通用計算裝置，電腦可以透過模擬其他電腦的指令集來實作不同的運算。為了了解電腦的基本工作原理，我們將透過構建一個簡單的CPU來實作這一點。
CPU 架構
首先，我們需要了解CPU的基本架構。CPU由多個暫存器組成，每個暫存器都是一個容器，用於儲存資料。CPU還有一個主迴圈，負責執行指令。指令是CPU支援的基本運算單元，例如加法、減法等。
模擬CPU
為了簡化問題，我們將實作一個簡單的CPU，稱為CHIP-8。CHIP-8是一種古老的系統，於1970年代問世。它的指令集非常簡單，只支援幾個基本運算。
實作加法指令
首先，我們將實作加法指令。加法指令需要兩個運算元，分別儲存在兩個暫存器中。然後，CPU將兩個運算元相加，並將結果儲存在其中一個暫存器中。
// 定義CPU結構
struct CPU {
registers: [u8; 2], // 兩個暫存器
opcode: u8, // 指令碼
}
// 實作加法指令
fn add(cpu: &mut CPU) {
let x = cpu.registers[0];
let y = cpu.registers[1];
cpu.registers[0] = x + y;
}
// 主迴圈
fn main() {
let mut cpu = CPU {
registers: [0, 0],
opcode: 0,
};
// 輸入指令碼
cpu.opcode = 0x01; // 加法指令
// 執行指令
match cpu.opcode {
0x01 => add(&mut cpu),
_ => println!("未知指令"),
}
// 輸出結果
println!("結果：{}", cpu.registers[0]);
}
解釋指令碼
指令碼是CPU支援的基本運算單元。每個指令碼對應一個特定的運算。在CHIP-8中，指令碼由4位二進位制陣列成，分別代表運算型別和運算元。
主迴圈
主迴圈是CPU的核心部分，負責執行指令。它首先讀取指令碼，然後根據指令碼執行相應的運算。
結果
最終，CPU將結果儲存在暫存器中，並輸出結果。
內容解密：
上述程式碼實作了一個簡單的CPU，支援加法指令。它首先定義了CPU的結構，包括兩個暫存器和一個指令碼。然後，它實作了加法指令，將兩個運算元相加，並將結果儲存在其中一個暫存器中。最後，它輸出結果。
圖表翻譯：
graph LR
A[CPU] --> B[暫存器]
B --> C[指令碼]
C --> D[加法指令]
D --> E[執行加法]
E --> F[儲存結果]
F --> G[輸出結果]
上述圖表展示了CPU的工作流程。它首先讀取指令碼，然後根據指令碼執行相應的運算。在本例中，它執行加法指令，將兩個運算元相加，並將結果儲存在其中一個暫存器中。最後，它輸出結果。
從底層實作到高階應用的全面檢視顯示，Q7格式作為一種定點數表示法，在資源受限的嵌入式系統和數字訊號處理領域展現出獨特的價值。透過位元操作實作的轉換過程，有效提升了運算效率，降低了系統資源消耗。然而，Q7格式的精確度受限於其位元寬度，在處理需要更高精確度數值的場景中存在侷限性。
權衡效能與精確度的平衡是Q7格式應用的核心挑戰。對於需要高精確度運算的應用，浮點數仍是首選方案。而對於資源受限的嵌入式系統，Q7格式則提供了高效的替代方案。開發者需要根據具體應用場景的需求，選擇合適的資料型別。
展望未來，隨著硬體效能的提升，Q7格式的應用場景可能會受到一定程度的壓縮。然而，在對成本和功耗敏感的物聯網裝置和邊緣計算領域，Q7格式仍將保有其獨特的優勢。預計未來會有更多針對Q7格式的最佳化演算法和硬體加速方案出現，進一步提升其效能和應用範圍。
玄貓認為，對於資源受限的嵌入式系統開發者而言，深入理解和掌握Q7格式的應用技巧至關重要。在特定場景下，巧妙運用Q7格式可以有效提升系統效能，降低開發成本。
