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 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
// This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http://mozilla.org/MPL/2.0/. //! Traits for **classification of filters**. /// Trait for **stateful** systems. /// /// # Background: /// /// Stateful systems **can react to the same input differently depending on the current state**. pub trait Stateful { /// Resets the current state of `self`. fn reset(&mut self); } /// Trait for **arbitrarily phase shifting** systems. /// /// # Background: /// /// Phase shift is any change that occurs in the phase of one quantity, /// or in the phase difference between two or more quantities. /// /// This symbol: `φ` is sometimes referred to as a phase shift or phase offset /// because it represents a "shift" from zero phase. /// /// For infinitely long sinusoids, a change in `φ` is the same as a shift in time, /// such as a time delay. If `x(t)` is delayed (time-shifted) by `1/4` of its cycle, it becomes: /// /// ```plain /// x(t - 1/4 T) = A * cos(2π * f(t - 1/4 T) + φ) /// = A * cos(2π * f * t - π/2 + φ) /// ``` /// /// whose "phase" is now `φ - π/2`. It has been shifted by `π/2` radians /// (the variable `A` here just represents the amplitude of the wave). /// <sup>[Wikipedia](https://en.wikipedia.org/wiki/Phase_(waves)#Phase_shift)</sup> pub trait PhaseShift: Sized { /// Returns the current phase shift of `self`. fn phase_shift(&self) -> isize; } /// Trait for **linearly phase shifting** systems. /// /// # Background: /// /// A system is called linear if it follows these two principles: /// /// 1. **Superposition**: /// Let `x1(t)`, `x2(t)` be the inputs applied to a system and `y1(t)`, `y2(t)` be the outputs. /// For `x1(t)` the output of the system is `y1(t)` and for `x2(t)` output of the system `y2(t)` /// then for `x1(t) + x2(t)` if the output of the system is `y1(t) + y2(t)` then system is said /// to be obeying superposition principle. /// /// 2. **Homogeneity**: /// Consider for an input `x(t)` for which output of the system is `y(t)`. Then if for the input /// `ax(t)` (where a is some constant value) output is `ay(t)` then system is said to be obeying /// homogeneity principle. Consequence of the homogeneity (or scaling) property is that a zero /// input to the system yields a zero output. /// /// If the above two property are satisfied system is said to be a linear system. /// <sup>[Wikipedia](https://en.wikipedia.org/wiki/Linear_system)</sup> pub trait LinearPhaseShift: PhaseShift { /// Returns the constant linear phase shift of `self`. fn linear_phase_shift(&self) -> isize; } /// Trait for **time-invariant** systems. /// /// # Background: /// /// A time shift in the input does not affect the properties of the output. /// More specifically, if `f(x(t)) = y(t)`, then `f(x(t-T)) = y(t-T)`, where `T` is the time shift. /// /// A system is called time-invariant if a time shift (delay or advance) in the input signal /// causes the same time shift in the output signal. Consider for an input signal `x(t)` the /// `response(output)` of the system is `y(t)`, then for system to be time invariant, for an input /// `x(t-k)` `response(output)` should be `y(t-k)` (where `k` is some constant shift in time). /// /// Time invariance is the property of a system which makes the behavior of the system /// independent of time. This means the behavior of system does not depend on time at which /// input is applied. For the discrete time system time invariance is called shift invariance. /// <sup>[Wikipedia](https://en.wikipedia.org/wiki/Time-invariant_system)</sup> pub trait TimeInvariant: DiscreteTime { } /// Trait for **shift-invariant** filters. /// /// # Background: /// /// A shift invariant system is the **discrete equivalent of a time-invariant system /// (see [`TimeInvariant`](trait.TimeInvariant.html))**, defined such that if `y(n)` is the response of the system to `x(n)`, /// then `y(n–k)` is the response of the system to `x(n–k)`. /// /// That is, in a shift-invariant system /// the contemporaneous response of the output variable to a given value of the input variable /// does not depend on when the input occurs; time shifts are irrelevant in this regard. /// <sup>[Wikipedia](https://en.wikipedia.org/wiki/Shift-invariant_system)</sup> pub trait ShiftInvariant: ContinuousTime { } /// Trait for **causal** systems. /// /// # Background: /// /// A causal filter is a filter with **output and internal states that depends only on the current /// and previous input values**. /// /// Contrarily a system that **has some dependence on input values from the future** /// (in addition to possible past or current input values) **is termed an acausal system**, /// and a system that **depends solely on future input values is an anticausal system**. /// <sup>[Wikipedia](https://en.wikipedia.org/wiki/Causal_filter)</sup> pub trait Causal: Sized { } /// Trait for **discrete-time** systems. /// /// # Background: /// /// Discrete time views values of variables as **occurring at distinct, /// separate _points in time_** ("samples" or "time period"), or equivalently as being unchanged /// throughout each sample — that is, **time is viewed as a discrete variable**. /// /// Thus a non-time variable **jumps from one value to another** as **time moves from one /// sample/time period to the next**. (This view of time corresponds to a digital clock /// that gives a fixed reading of 10:37 for a while, and then jumps to a /// new fixed reading of 10:38, etc.) /// /// In this framework, each **variable of interest is measured once at each time period**. /// The **number of measurements** between any two time periods **is finite**. /// /// Measurements are typically made at sequential integer values of the variable "time". /// <sup>[Wikipedia](https://en.wikipedia.org/wiki/Discrete_time_and_continuous_time#Discrete_time_2)</sup> pub trait DiscreteTime: Sized { } /// Trait for **continuous-time** systems. /// /// # Background: /// /// Continuous time views variables as having a particular value for potentially only an /// **infinitesimally short amount of time**. /// /// Between any two points in time there are an **infinite number of other points in time**. /// /// The variable "time" **ranges over the non-negative entire real number line**, or depending on the context, /// over **some subset of it**. Thus **time is viewed as a continuous variable**. /// <sup>[Wikipedia](https://en.wikipedia.org/wiki/Discrete_time_and_continuous_time#Continuous_time_2)</sup> pub trait ContinuousTime: Sized { }