Move damp, c2d, rlocus from matlab into control

cwrowley · cwrowley · commit a3fb4f583c48 · 2015-04-26T19:16:07.000-04:00
diff --git a/control/__init__.py b/control/__init__.py
@@ -48,17 +48,17 @@
 # Should probably only import the exact functions we use...
 from .bdalg import series, parallel, negate, feedback
 from .delay import pade
-from .dtime import sample_system
+from .dtime import *
 from .freqplot import bode_plot, nyquist_plot, gangof4_plot
 from .freqplot import bode, nyquist, gangof4
-from .lti import issiso, timebase, timebaseEqual, isdtime, isctime
-from .margins import stability_margins, phase_crossover_frequencies
+from .lti import *
+from .margins import *
 from .mateqn import lyap, dlyap, care, dare
 from .modelsimp import hsvd, modred, balred, era, markov, minreal
 from .nichols import *
 from .phaseplot import phase_plot, box_grid
 from .pzmap import pzmap
-from .rlocus import root_locus
+from .rlocus import *
 from .statefbk import place, lqr, ctrb, obsv, gram, acker
 from .statesp import *
 from .timeresp import forced_response, initial_response, step_response, \
@@ -86,10 +86,6 @@
 #! of defaults from the main package.  At that point, the matlab module will
 #! allow provide compatibility with MATLAB but no package functionality.
 #!
-from .matlab import dcgain
-from .matlab import nichols, rlocus, margin
-        # bode and nyquist come directly from freqplot.py
-from .matlab import step, impulse, initial, lsim
 
 # The following is to use Numpy's testing framework
 # Tests go under directory tests/, benchmarks under directory benchmarks/
diff --git a/control/dtime.py b/control/dtime.py
@@ -47,6 +47,9 @@
 """
 
 from .lti import isctime
+from .statesp import StateSpace, _convertToStateSpace
+
+__all__ = ['sample_system', 'c2d']
 
 # Sample a continuous time system
 def sample_system(sysc, Ts, method='zoh', alpha=None):
@@ -85,3 +88,30 @@ def sample_system(sysc, Ts, method='zoh', alpha=None):
         raise ValueError("First argument must be continuous time system")
 
     return sysc.sample(Ts, method, alpha)
+
+
+def c2d(sysc, Ts, method='zoh'):
+    '''
+    Return a discrete-time system
+
+    Parameters
+    ----------
+    sysc: LTI (StateSpace or TransferFunction), continuous
+        System to be converted
+
+    Ts: number
+        Sample time for the conversion
+
+    method: string, optional
+        Method to be applied,
+        'zoh'        Zero-order hold on the inputs (default)
+        'foh'        First-order hold, currently not implemented
+        'impulse'    Impulse-invariant discretization, currently not implemented
+        'tustin'     Bilinear (Tustin) approximation, only SISO
+        'matched'    Matched pole-zero method, only SISO
+    '''
+    #  Call the sample_system() function to do the work
+    sysd = sample_system(sysc, Ts, method)
+    if isinstance(sysc, StateSpace) and not isinstance(sysd, StateSpace):
+        return _convertToStateSpace(sysd)
+    return sysd
diff --git a/control/lti.py b/control/lti.py
@@ -15,7 +15,7 @@
 from numpy import absolute, real
 
 __all__ = ['issiso', 'timebase', 'timebaseEqual', 'isdtime', 'isctime',
-           'pole', 'zero', 'evalfr', 'freqresp']
+           'pole', 'zero', 'damp', 'evalfr', 'freqresp']
 
 class LTI:
     """LTI is a parent class to linear time-invariant (LTI) system objects.
@@ -258,6 +258,44 @@ def zero(sys):
 
     return sys.zero()
 
+def damp(sys, doprint=True):
+    '''
+    Compute natural frequency, damping ratio, and poles of a system
+
+    The function takes 1 or 2 parameters
+
+    Parameters
+    ----------
+    sys: LTI (StateSpace or TransferFunction)
+        A linear system object
+    doprint:
+        if true, print table with values
+
+    Returns
+    -------
+    wn: array
+        Natural frequencies of the poles
+    damping: array
+        Damping values
+    poles: array
+        Pole locations
+
+    See Also
+    --------
+    pole
+    '''
+    wn, damping, poles = sys.damp()
+    if doprint:
+        print('_____Eigenvalue______ Damping___ Frequency_')
+        for p, d, w in zip(poles, damping, wn) :
+            if abs(p.imag) < 1e-12:
+                print("%10.4g            %10.4g %10.4g" %
+                      (p.real, 1.0, -p.real))
+            else:
+                print("%10.4g%+10.4gj %10.4g %10.4g" %
+                      (p.real, p.imag, d, w))
+    return wn, damping, poles
+
 def evalfr(sys, x):
     """
     Evaluate the transfer function of an LTI system for a single complex
diff --git a/control/margins.py b/control/margins.py
@@ -56,6 +56,8 @@
 from . import frdata
 import scipy as sp
 
+__all__ = ['stability_margins', 'phase_crossover_frequencies', 'margin']
+
 # helper functions for stability_margins
 def _polyimsplit(pol):
     """split a polynomial with (iw) applied into a real and an
@@ -271,3 +273,43 @@ def phase_crossover_frequencies(sys):
     gain = np.real(np.asarray([tf.evalfr(f)[0][0] for f in realposfreq]))
 
     return realposfreq, gain
+
+
+def margin(*args):
+    """Calculate gain and phase margins and associated crossover frequencies
+
+    Function ``margin`` takes either 1 or 3 parameters.
+
+    Parameters
+    ----------
+    sys : StateSpace or TransferFunction
+        Linear SISO system
+    mag, phase, w : array_like
+        Input magnitude, phase (in deg.), and frequencies (rad/sec) from
+        bode frequency response data
+
+    Returns
+    -------
+    gm, pm, Wcg, Wcp : float
+        Gain margin gm, phase margin pm (in deg), gain crossover frequency
+        (corresponding to phase margin) and phase crossover frequency
+        (corresponding to gain margin), in rad/sec of SISO open-loop.
+        If more than one crossover frequency is detected, returns the lowest
+        corresponding margin.
+
+    Examples
+    --------
+    >>> sys = tf(1, [1, 2, 1, 0])
+    >>> gm, pm, Wcg, Wcp = margin(sys)
+
+    """
+    if len(args) == 1:
+        sys = args[0]
+        margin = stability_margins(sys)
+    elif len(args) == 3:
+        margin = stability_margins(args)
+    else:
+        raise ValueError("Margin needs 1 or 3 arguments; received %i."
+            % len(args))
+
+    return margin[0], margin[1], margin[4], margin[3]
diff --git a/control/matlab/__init__.py b/control/matlab/__init__.py
@@ -54,7 +54,6 @@
 import scipy as sp              # SciPy library (used all over)
 import numpy as np              # NumPy library
 import re                       # regular expressions
-from copy import deepcopy
 
 # Import MATLAB-like functions that are defined in other packages
 from scipy.signal import zpk2ss, ss2zpk, tf2zpk, zpk2tf
@@ -81,7 +80,7 @@
 from ..exception import ControlArgument
 
 # Import MATLAB-like functions that can be used as-is
-from ..ctrlutil import unwrap
+from ..ctrlutil import *
 from ..freqplot import nyquist, gangof4
 from ..nichols import nichols, nichols_grid
 from ..bdalg import series, parallel, negate, feedback, append, connect
@@ -90,6 +89,9 @@
 from ..delay import pade
 from ..modelsimp import hsvd, balred, modred, minreal
 from ..mateqn import lyap, dlyap, dare, care
+from ..margins import margin
+from ..rlocus import rlocus
+from ..dtime import c2d
 
 # Import functions specific to Matlab compatibility package
 from .timeresp import *
@@ -386,47 +388,6 @@
 
 """
 
-from ..margins import stability_margins
-
-def margin(*args):
-    """Calculate gain and phase margins and associated crossover frequencies
-
-    Function ``margin`` takes either 1 or 3 parameters.
-
-    Parameters
-    ----------
-    sys : StateSpace or TransferFunction
-        Linear SISO system
-    mag, phase, w : array_like
-        Input magnitude, phase (in deg.), and frequencies (rad/sec) from
-        bode frequency response data
-
-    Returns
-    -------
-    gm, pm, Wcg, Wcp : float
-        Gain margin gm, phase margin pm (in deg), gain crossover frequency
-        (corresponding to phase margin) and phase crossover frequency
-        (corresponding to gain margin), in rad/sec of SISO open-loop.
-        If more than one crossover frequency is detected, returns the lowest
-        corresponding margin.
-
-    Examples
-    --------
-    >>> sys = tf(1, [1, 2, 1, 0])
-    >>> gm, pm, Wcg, Wcp = margin(sys)
-
-    """
-    if len(args) == 1:
-        sys = args[0]
-        margin = stability_margins(sys)
-    elif len(args) == 3:
-        margin = stability_margins(args)
-    else:
-        raise ValueError("Margin needs 1 or 3 arguments; received %i."
-            % len(args))
-
-    return margin[0], margin[1], margin[4], margin[3]
-
 def dcgain(*args):
     '''
     Compute the gain of the system in steady state.
@@ -480,68 +441,3 @@ def dcgain(*args):
     #gain = - C * A**-1 * B + D
     gain = sys.D - sys.C * sys.A.I * sys.B
     return gain
-
-def damp(sys, doprint=True):
-    '''
-    Compute natural frequency, damping and poles of a system
-
-    The function takes 1 or 2 parameters
-
-    Parameters
-    ----------
-    sys: LTI (StateSpace or TransferFunction)
-        A linear system object
-    doprint:
-        if true, print table with values
-
-    Returns
-    -------
-    wn: array
-        Natural frequencies of the poles
-    damping: array
-        Damping values
-    poles: array
-        Pole locations
-
-    See Also
-    --------
-    pole
-    '''
-    wn, damping, poles = sys.damp()
-    if doprint:
-        print('_____Eigenvalue______ Damping___ Frequency_')
-        for p, d, w in zip(poles, damping, wn) :
-            if abs(p.imag) < 1e-12:
-                print("%10.4g            %10.4g %10.4g" %
-                      (p.real, 1.0, -p.real))
-            else:
-                print("%10.4g%+10.4gj %10.4g %10.4g" %
-                      (p.real, p.imag, d, w))
-    return wn, damping, poles
-
-# Convert a continuous time system to a discrete time system
-def c2d(sysc, Ts, method='zoh'):
-    '''
-    Return a discrete-time system
-
-    Parameters
-    ----------
-    sysc: LTI (StateSpace or TransferFunction), continuous
-        System to be converted
-
-    Ts: number
-        Sample time for the conversion
-
-    method: string, optional
-        Method to be applied,
-        'zoh'        Zero-order hold on the inputs (default)
-        'foh'        First-order hold, currently not implemented
-        'impulse'    Impulse-invariant discretization, currently not implemented
-        'tustin'     Bilinear (Tustin) approximation, only SISO
-        'matched'    Matched pole-zero method, only SISO
-    '''
-    #  Call the sample_system() function to do the work
-    sysd = sample_system(sysc, Ts, method)
-    if isinstance(sysc, StateSpace) and not isinstance(sysd, StateSpace):
-        return _convertToStateSpace(sysd)
-    return sysd
diff --git a/control/matlab/plots.py b/control/matlab/plots.py
@@ -4,7 +4,7 @@
 
 import numpy as np
 
-__all__ = ['bode', 'rlocus', 'ngrid']
+__all__ = ['bode', 'ngrid']
 
 def bode(*args, **keywords):
     """Bode plot of the frequency response
@@ -103,8 +103,3 @@ def bode(*args, **keywords):
 def ngrid():
     return nichols_grid()
 ngrid.__doc__ = nichols_grid.__doc__
-
-from ..rlocus import root_locus
-def rlocus(*args, **kwargs):
-    return root_locus(*args, **kwargs)
-rlocus.__doc__ = root_locus.__doc__
diff --git a/control/rlocus.py b/control/rlocus.py
@@ -54,6 +54,8 @@
 from .exception import ControlMIMONotImplemented
 from functools import partial
 
+__all__ = ['root_locus', 'rlocus']
+
 # Main function: compute a root locus diagram
 def root_locus(sys, kvect=None, xlim=None, ylim=None, plotstr='-', Plot=True,
                PrintGain=True):
@@ -208,3 +210,5 @@ def _RLFeedbackClicks(event, sys):
     if abs(K.real) > 1e-8 and abs(K.imag/K.real) < 0.04:
         print("Clicked at %10.4g%+10.4gj gain %10.4g damp %10.4g" %
               (s.real, s.imag, K.real, -1*s.real/abs(s)))
+
+rlocus = root_locus
