src/tf.rs

   1 //! transfer function
   2
   3 use crate::float;
   4 use crate::uint;
   5
   6 /// transfer function
   7 #[repr(C)]
   8 pub struct tf {
   9     /// input
  10     input: *mut float,
  11     /// output
  12     output: *mut float,
  13     /// numerator
  14     num_p: *const float,
  15     /// denominator
  16     den_p: *const float,
  17     /// numerator number
  18     num_n: uint,
  19     /// denominator number
  20     den_n: uint,
  21 }
  22
  23 extern "C" {
  24     fn a_tf_set_num(ctx: *mut tf, num_n: uint, num_p: *const float, input: *mut float);
  25     fn a_tf_set_den(ctx: *mut tf, den_n: uint, den_p: *const float, output: *mut float);
  26     fn a_tf_init(
  27         ctx: *mut tf,
  28         num_n: uint,
  29         num_p: *const float,
  30         input: *mut float,
  31         den_n: uint,
  32         den_p: *const float,
  33         output: *mut float,
  34     );
  35     fn a_tf_iter(ctx: *const tf, x: float) -> float;
  36     fn a_tf_zero(ctx: *const tf);
  37 }
  38
  39 impl tf {
  40     /// initialize for transfer function
  41     pub fn new(num: &[float], input: &mut [float], den: &[float], output: &mut [float]) -> Self {
  42         let mut ctx: Self = Self {
  43             input: core::ptr::null_mut(),
  44             output: core::ptr::null_mut(),
  45             num_p: core::ptr::null(),
  46             den_p: core::ptr::null(),
  47             num_n: 0,
  48             den_n: 0,
  49         };
  50         unsafe {
  51             a_tf_init(
  52                 &mut ctx,
  53                 num.len() as uint,
  54                 num.as_ptr(),
  55                 input.as_mut_ptr(),
  56                 den.len() as uint,
  57                 den.as_ptr(),
  58                 output.as_mut_ptr(),
  59             )
  60         };
  61         ctx
  62     }
  63
  64     /// calculate for transfer function
  65     pub fn iter(&mut self, x: float) -> float {
  66         unsafe { a_tf_iter(self, x) }
  67     }
  68
  69     /// zeroing for transfer function
  70     pub fn zero(&mut self) -> &mut Self {
  71         unsafe { a_tf_zero(self) };
  72         self
  73     }
  74
  75     /// get input for transfer function
  76     pub fn input(&self) -> &[float] {
  77         unsafe { core::slice::from_raw_parts(self.input, self.num_n as usize) }
  78     }
  79
  80     /// get numerator for transfer function
  81     pub fn num(&self) -> &[float] {
  82         unsafe { core::slice::from_raw_parts(self.num_p, self.num_n as usize) }
  83     }
  84
  85     /// set numerator for transfer function
  86     pub fn set_num(&mut self, num: &[float], input: &mut [float]) -> &mut Self {
  87         unsafe { a_tf_set_num(self, num.len() as uint, num.as_ptr(), input.as_mut_ptr()) };
  88         self
  89     }
  90
  91     /// get output for transfer function
  92     pub fn output(&self) -> &[float] {
  93         unsafe { core::slice::from_raw_parts(self.output, self.den_n as usize) }
  94     }
  95
  96     /// get denominator for transfer function
  97     pub fn den(&self) -> &[float] {
  98         unsafe { core::slice::from_raw_parts(self.den_p, self.den_n as usize) }
  99     }
 100
 101     /// set denominator for transfer function
 102     pub fn set_den(&mut self, den: &[float], output: &mut [float]) -> &mut Self {
 103         unsafe { a_tf_set_den(self, den.len() as uint, den.as_ptr(), output.as_mut_ptr()) };
 104         self
 105     }
 106 }
 107
 108 #[test]
 109 fn tf() {
 110     extern crate std;
 111     let num = [6.59492796e-05, 6.54019884e-05];
 112     let den = [-1.97530991, 0.97530991];
 113     let mut input = [0.0; 2];
 114     let mut output = [0.0; 2];
 115     let mut a = crate::tf::tf::new(&num, &mut input, &den, &mut output);
 116     a.set_num(&num, &mut input).set_den(&den, &mut output);
 117     std::println!("{} {}", a.iter(10.0), a.iter(10.0));
 118     std::println!("{:?} {:?}", a.num(), a.input());
 119     std::println!("{:?} {:?}", a.den(), a.output());
 120     a.zero();
 121 }