display tf and ss

Author: TorBorve

src/systems/polynom.rs

@@ -332,13 +332,32 @@ impl<T> RationalFunction<T>
 where
     T: Zero + fmt::Display,
 {
-    pub fn to_string_variable(&self, var_name: &str) -> String {
-        let num_str = self.num.to_string_variable(var_name);
-        let den_str = self.den.to_string_variable(var_name);
+    pub fn display_with_var_name(
+        &self,
+        formatter: &mut std::fmt::Formatter<'_>,
+        var_name: &str,
+    ) -> std::fmt::Result {
+        let mut num_str = self.numerator().to_string_variable(var_name);
+        let mut den_str = self.denominator().to_string_variable(var_name);
+        let max_len = num_str.len().max(den_str.len());
+        let dash_line = "\u{2500}".repeat(max_len);
+
+        let center_pad_fn = |s: &str| -> String {
+            let padding = max_len.saturating_sub(s.len()) / 2;
+            format!("{}{}", " ".repeat(padding), s)
+        };
+
+        num_str = center_pad_fn(&num_str);
+        den_str = center_pad_fn(&den_str);
 
-        let dash_line = "\u{2500}".repeat(num_str.len().max(den_str.len()));
+        assert!(num_str.len() <= max_len);
+        assert!(den_str.len() <= max_len);
 
-        num_str + "\n" + &dash_line + "\n" + &den_str
+        write!(
+            formatter,
+            "\n  {}\n  {}\n  {}\n\n",
+            num_str, dash_line, den_str
+        )
     }
 }
 
@@ -347,7 +366,7 @@ where
     T: Zero + fmt::Display,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.to_string_variable("x"))
+        self.display_with_var_name(f, "x")
     }
 }
 

src/systems/state_space.rs

@@ -1,12 +1,14 @@
 use std::{
+    any::TypeId,
     error::Error,
+    fmt,
     marker::PhantomData,
     ops::{
         Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign,
     },
 };
 
-use crate::utils::traits::Time;
+use crate::{Continuous, Discrete, utils::traits::Time};
 extern crate nalgebra as na;
 use na::DMatrix;
 
@@ -593,6 +595,27 @@ macro_rules! impl_scalar_math_operator_ss {
 
 impl_scalar_math_operator_ss!([(Add, add), (Sub, sub), (Mul, mul), (Div, div)]);
 
+impl<U: Time + 'static> fmt::Display for Ss<U> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "\nA = {} B = {} C = {} D = {}",
+            self.a(),
+            self.b(),
+            self.c(),
+            self.d()
+        )?;
+        let time_domain = if TypeId::of::<U>() == TypeId::of::<Continuous>() {
+            "Continuous"
+        } else if TypeId::of::<U>() == TypeId::of::<Discrete>() {
+            "Discrete"
+        } else {
+            "Unknown"
+        };
+        write!(f, "{}-time state-space model\n\n", time_domain)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use core::f64;
@@ -857,4 +880,18 @@ mod tests {
             assert_abs_diff_eq!(tf_fb, ss_fb, epsilon = 1e-1);
         }
     }
+
+    #[test]
+    fn ss_display() {
+        let sys = (1.0 / Tf::s()).to_ss().unwrap();
+        println!("1: {}", sys);
+
+        let sys = Ss::<Discrete>::new_from_scalar(2.0);
+        println!("2: {}", sys);
+
+        let sys = ((1.0 + Tf::s()) / ((Tf::s() - 1.0) * Tf::s()).powi(2))
+            .to_ss()
+            .unwrap();
+        println!("3: {}after", sys);
+    }
 }

src/systems/transfer_function.rs

@@ -175,8 +175,7 @@ where
         } else {
             "x"
         };
-        let rf_str = self.rf.to_string_variable(var_name);
-        write!(f, "{}", rf_str)
+        self.rf.display_with_var_name(f, var_name)
     }
 }
 
@@ -579,4 +578,15 @@ mod tests {
         let tf_series = tf1.clone().series(tf2.clone());
         assert_eq!(tf_series, tf_mul);
     }
+
+    #[test]
+    fn tf_display() {
+        let tf = 1.0 / Tf::s();
+        println!("1: {}", tf);
+        let tf = 1.0 / Tf::s().powi(5) * (Tf::s() + 1.0);
+        println!("2: {}", tf);
+        let tf =
+            2.1 / Tf::s() * (Tf::s() - 1.2).powi(5) / (Tf::s() + 1.0).powi(3);
+        println!("3: {}", tf);
+    }
 }