Merge pull request #25 from TorBorve/feature/restructure-files

Feature/restructure files

Author: TorBorve

.github/workflows/ci.yml

@@ -13,7 +13,10 @@ jobs:
         uses: actions/checkout@v4
         with:
           submodules: true
-
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v2
+        with:
+          cmake-version: '3.28.x'
       - name: Setup | Toolchain
         uses: dtolnay/rust-toolchain@nightly
         with:
@@ -36,6 +39,11 @@ jobs:
         with:
           submodules: true       
 
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v2
+        with:
+          cmake-version: '3.28.x'
+
       - name: Setup | Rust
         uses: dtolnay/rust-toolchain@nightly
 
@@ -53,6 +61,13 @@ jobs:
         with:
           submodules: true
 
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v2
+        with:
+          cmake-version: '3.28.x'
+      
+      - name: Use cmake
+        run: cmake --version
       - name: Setup | Rust
         uses: dtolnay/rust-toolchain@nightly
 
@@ -69,6 +84,11 @@ jobs:
         uses: actions/checkout@v4
         with:
           submodules: true
+      
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v2
+        with:
+          cmake-version: '3.28.x'
 
       - run: |
           echo "CC=$(brew --prefix gcc@13)/bin/gcc-13" >> "${GITHUB_ENV}"

.github/workflows/coverage.yml

@@ -12,6 +12,11 @@ jobs:
         with:
           submodules: true
 
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v2
+        with:
+          cmake-version: '3.28.x'
+
       - name: Setup | Toolchain
         uses: dtolnay/rust-toolchain@nightly
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "control_systems_torbox"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2024"
 authors = ["Tor Børve Rasmussen <tor.jobb.skule@gmail.com>"]
 description = "Control systems toolbox"

TODO.md

@@ -3,8 +3,8 @@
 - [X] Transfer functions
 - [X] State Space
 - [ ] General Linear Time Invariant systems. (delays in feedback)
-- [ ] Connecting and feedback of LTI systems.
-- [ ] poles and zeros of LTI systems
+- [X] Connecting and feedback of LTI systems.
+- [X] poles and zeros of LTI systems
 - [X] Bodeplot
 - [X] Nyquistplot
 - [ ] pole zero plot
@@ -23,6 +23,7 @@
 - [x] Home button in nyquist and bodeplot
 - [x] Tf^(i) implement
 - [x] Can SLICOT be used to implement some routines and transforms?
+- [ ] Make better system/code for calling SLICOT and so on.
 
 
 ## Resources

examples/plotting.rs

@@ -1,9 +1,6 @@
 use control_systems_torbox as cst;
 
-use cst::{
-    BodePlot, BodePlotData, BodePlotOptions, Continuous, NyquistPlot,
-    NyquistPlotData, NyquistPlotOptions, Plot, RGBAColor, Tf, bode, nyquist,
-};
+use cst::{plot::*, systems::Tf, utils::traits::Continuous};
 
 fn main() {
     let sys: Tf<f64, Continuous> = Tf::new(&[1.0], &[0.0, 1.0]);
@@ -15,14 +12,14 @@ fn main() {
 
     let nyq_opts = NyquistPlotOptions::default().set_y_limits([-2., 2.]);
     let mut nyq_plot = NyquistPlot::new(nyq_opts);
-    let nyq_data = nyquist(sys, 0.01, 100.);
+    let nyq_data = sys.nyquist(0.01, 100.);
     nyq_plot.add_system(nyq_data.into());
 
-    let data = NyquistPlotData::new(nyquist(sys_p1, 0.01, 100.))
+    let data = NyquistPlotData::new(sys_p1.nyquist(0.01, 100.))
         .set_name("Pade 1")
         .set_color(RGBAColor::RED);
     nyq_plot.add_system(data);
-    let data = NyquistPlotData::new(nyquist(sys_p2, 0.01, 100.))
+    let data = NyquistPlotData::new(sys_p2.nyquist(0.01, 100.))
         .set_name("Pade 2")
         .set_color(RGBAColor::GREEN);
     nyq_plot.add_system(data);
@@ -35,7 +32,7 @@ fn main() {
     let mut bodeplot = BodePlot::new(bodeopts);
 
     let sys: Tf<f64, Continuous> = Tf::new(&[0.0, 1.0], &[1.0, 1.0]);
-    let mag_phase_freq_vec = bode(sys, 0.1, 100.);
+    let mag_phase_freq_vec = sys.bode(0.1, 100.);
 
     bodeplot.add_system(
         BodePlotData::from(mag_phase_freq_vec.clone()).set_name("System 1"),
@@ -47,7 +44,7 @@ fn main() {
     bodeplot.add_system(data);
 
     let sys2: Tf<f64, Continuous> = Tf::new(&[1.0], &[1.0, 1.0]);
-    let mag_phase_freq_vec = bode(sys2, 0.1, 100.);
+    let mag_phase_freq_vec = sys2.bode(0.1, 100.);
 
     bodeplot.add_system(mag_phase_freq_vec.into());
 

src/analysis/frequency_response.rs

@@ -0,0 +1,152 @@
+use num_complex::{Complex64, c64};
+
+use crate::{
+    systems::Tf,
+    utils::traits::{Mag2Db, Rad2Deg, Time},
+};
+/// Generates a linearly spaced iterator between `start` and `end`, inclusive.
+///
+/// # Arguments
+/// - `start`: The starting value of the sequence.
+/// - `end`: The ending value of the sequence.
+/// - `n`: The number of points to generate (must be greater than 1).
+///
+/// # Returns
+/// - An iterator producing `n` evenly spaced `f64` values from `start` to
+///   `end`.
+///
+/// # Panics
+/// - Panics if `n` is less than or equal to 1.
+pub fn lin_space(
+    start: f64,
+    end: f64,
+    n: usize,
+) -> impl ExactSizeIterator<Item = f64> {
+    assert!(n >= 1, "n must be greater than or equal to one");
+    let step = (end - start) / (n as f64 - 1.0);
+    (0..n).map(move |i| start + step * i as f64)
+}
+
+/// Generates a logarithmically spaced iterator between `start` and `end`, using
+/// the specified logarithmic base.
+///
+/// # Arguments
+/// - `start`: The starting value of the sequence (must be greater than 0).
+/// - `end`: The ending value of the sequence (must be greater than 0).
+/// - `n`: The number of points to generate.
+/// - `base`: The logarithmic base to use for spacing.
+///
+/// # Returns
+/// - An iterator producing `n` logarithmically spaced `f64` values from `start`
+///   to `end`.
+///
+/// # Panics
+/// - Panics if `start` or `end` is less than or equal to 0.
+pub fn log_space(
+    start: f64,
+    end: f64,
+    n: usize,
+    base: usize,
+) -> impl ExactSizeIterator<Item = f64> {
+    assert!(
+        start > 0.,
+        "logarithm of negative numbers are not implemented"
+    );
+    assert!(
+        end > 0.,
+        "logarithm of negative numbers are not implemented"
+    );
+    assert!(base > 1, "log_base() must be well defined");
+    let start_log = start.log(base as f64);
+    let end_log = end.log(base as f64);
+
+    let nums = lin_space(start_log, end_log, n);
+
+    nums.map(move |x| (base as f64).powf(x))
+}
+
+impl<U: Time> Tf<f64, U> {
+    /// Computes the Bode plot (magnitude and phase) for a transfer function
+    /// over a frequency range.
+    ///
+    /// # Arguments
+    /// - `sys`: The transfer function of the system to evaluate.
+    /// - `min_freq`: The minimum frequency for the plot.
+    /// - `max_freq`: The maximum frequency for the plot.
+    ///
+    /// # Returns
+    /// - A vector of `[magnitude (dB), phase (degrees), frequency]` tuples for
+    ///   each evaluated frequency.
+    pub fn bode(&self, min_freq: f64, max_freq: f64) -> Vec<[f64; 3]> {
+        let freqs = log_space(min_freq, max_freq, 1000, 10);
+        self.bode_freqs(freqs)
+    }
+
+    /// Computes the Bode plot (magnitude and phase) for a transfer function
+    /// over a given set of frequencies.
+    ///
+    /// # Arguments
+    /// - `sys`: The transfer function of the system to evaluate.
+    /// - `freqs`: An iterator of frequencies to evaluate the system at.
+    ///
+    /// # Returns
+    /// - A vector of `[magnitude (dB), phase (degrees), frequency]` tuples for
+    ///   each evaluated frequency.
+    pub fn bode_freqs(
+        &self,
+        freqs: impl Iterator<Item = f64>,
+    ) -> Vec<[f64; 3]> {
+        let mut mag_phase_freq_vec = Vec::with_capacity(freqs.size_hint().0);
+
+        for omega in freqs {
+            let c = c64(0., omega);
+            let sys_val = self.eval(&c);
+            mag_phase_freq_vec.push([
+                sys_val.norm().mag2db(),
+                sys_val.arg().rad2deg(),
+                omega,
+            ]);
+        }
+        mag_phase_freq_vec
+    }
+
+    /// Computes the Nyquist plot for a transfer function over a frequency
+    /// range.
+    ///
+    /// # Arguments
+    /// - `sys`: The transfer function of the system to evaluate.
+    /// - `min_freq`: The minimum frequency for the plot.
+    /// - `max_freq`: The maximum frequency for the plot.
+    ///
+    /// # Returns
+    /// - A vector of complex numbers representing the Nyquist plot.
+    pub fn nyquist(&self, min_freq: f64, max_freq: f64) -> Vec<Complex64> {
+        let freqs = log_space(min_freq, max_freq, 1000, 10);
+        self.nyquist_freqs(freqs)
+    }
+
+    /// Computes the Nyquist plot for a transfer function over a given set of
+    /// frequencies.
+    ///
+    /// # Arguments
+    /// - `sys`: The transfer function of the system to evaluate.
+    /// - `freqs`: An iterator of frequencies to evaluate the system at.
+    ///
+    /// # Returns
+    /// - A vector of complex numbers representing the Nyquist plot.
+    pub fn nyquist_freqs(
+        &self,
+        freqs: impl Iterator<Item = f64>,
+    ) -> Vec<Complex64> {
+        let mut pos_vals = Vec::with_capacity(freqs.size_hint().0);
+        let mut neg_vals = Vec::with_capacity(freqs.size_hint().0);
+
+        for freq in freqs {
+            pos_vals.push(self.eval(&c64(0., freq)));
+            neg_vals.push(self.eval(&c64(0., -freq)));
+        }
+
+        pos_vals.extend(neg_vals.iter().rev());
+        pos_vals
+    }
+}

src/analysis/mod.rs

@@ -0,0 +1,2 @@
+pub mod frequency_response;
+pub mod system_properties;