removed blas and dependencies

Author: hammal

deltasigma/_PlotExampleSpectrum.py

@@ -41,7 +41,7 @@ def PlotExampleSpectrum(ntf, M=1, osr=64, f0=0, quadrature=False):
 
     **Parameters:**
 
-    ntf : scipy 'lti' object, tuple or ndarray
+    ntf : scipy 'dlti' object, tuple or ndarray
            The first argument may be one of the various supported
            representations for a (SISO) transfer function or an
            ABCD matrix. See :func:`evalTF` for a more detailed
@@ -79,66 +79,109 @@ def PlotExampleSpectrum(ntf, M=1, osr=64, f0=0, quadrature=False):
     """
     f1, f2 = ds_f1f2(osr, f0, quadrature)
     delta = 2
-    Amp = undbv(-3) # Test tone amplitude, relative to full-scale.
+    Amp = undbv(-3)  # Test tone amplitude, relative to full-scale.
     # f below is the test tone frequency offset from f0, relative to bw.
     # (It will be adjusted to be an fft bin)
     f = 0.3
     N = 2**12
-    f1_bin = int(np.round(f1*N))
-    f2_bin = int(np.round(f2*N))
-    fin = round(((1 - f)/2*f1 + (f + 1)/2*f2) * N)
+    f1_bin = int(np.round(f1 * N))
+    f2_bin = int(np.round(f2 * N))
+    fin = round(((1 - f) / 2 * f1 + (f + 1) / 2 * f2) * N)
     if not quadrature:
         t = np.arange(0, N).reshape((1, -1))
-        u = Amp*M*np.cos((2*np.pi/N)*fin*t)
-        v, _, xmax, y = simulateDSM(u, ntf, M+1)
+        u = Amp * M * np.cos((2 * np.pi / N) * fin * t)
+        v, _, xmax, y = simulateDSM(u, ntf, M + 1)
     else:
         t = np.arange(0, N).reshape((1, -1))
-        u = Amp*M*np.exp((2j*np.pi/N)*fin*t)
-        v, _, xmax, y = simulateQDSM(u, ntf, M+1)
+        u = Amp * M * np.exp((2j * np.pi / N) * fin * t)
+        v, _, xmax, y = simulateQDSM(u, ntf, M + 1)
     window = ds_hann(N)
-    NBW = 1.5/N
-    spec0 = fft(v * window)/(M*N/4)
+    NBW = 1.5 / N
+    spec0 = fft(v * window) / (M * N / 4)
     if not quadrature:
-        freq = np.linspace(0, 0.5, int(N/2) + 1)
-        plt.plot(freq, dbv(spec0[:int(N/2) + 1]), 'c', linewidth=1)
-        #plt.hold(True)
-        spec_smoothed = circ_smooth(np.abs(spec0)**2., 16)
-        plt.plot(freq, dbp(spec_smoothed[:int(N/2) + 1]), 'b', linewidth=3)
-        Snn = np.abs(evalTF(ntf, np.exp(2j*np.pi*freq)))**2 * 2/12*(delta/M)**2
-        plt.plot(freq, dbp(Snn*NBW), 'm', linewidth=1)
-        snr = calculateSNR(spec0[f1_bin:f2_bin + 1], fin - f1_bin)
-        msg = 'SQNR  =  %.1fdB\n @ A = %.1fdBFS & osr = %.0f\n' % \
-              (snr, dbv(spec0[fin]), osr)
+        freq = np.linspace(0, 0.5, int(N / 2) + 1)
+        plt.plot(freq, dbv(spec0[: int(N / 2) + 1]), "c", linewidth=1)
+        # plt.hold(True)
+        spec_smoothed = circ_smooth(np.abs(spec0) ** 2.0, 16)
+        plt.plot(freq, dbp(spec_smoothed[: int(N / 2) + 1]), "b", linewidth=3)
+        Snn = (
+            np.abs(evalTF(ntf, np.exp(2j * np.pi * freq))) ** 2
+            * 2
+            / 12
+            * (delta / M) ** 2
+        )
+        plt.plot(freq, dbp(Snn * NBW), "m", linewidth=1)
+        snr = calculateSNR(spec0[f1_bin : f2_bin + 1], fin - f1_bin)
+        msg = "SQNR  =  %.1fdB\n @ A = %.1fdBFS & osr = %.0f\n" % (
+            snr,
+            dbv(spec0[fin]),
+            osr,
+        )
         if f0 < 0.25:
-            plt.text(f0 + 1 / osr, - 15, msg, horizontalalignment='left',
-                     verticalalignment='center')
+            plt.text(
+                f0 + 1 / osr,
+                -15,
+                msg,
+                horizontalalignment="left",
+                verticalalignment="center",
+            )
         else:
-            plt.text(f0 - 1 / osr, - 15, msg, horizontalalignment='right',
-                     verticalalignment='center')
-        plt.text(0.5, - 135, 'NBW = %.1e ' % NBW, horizontalalignment='right',
-                 verticalalignment='bottom')
-        figureMagic((0, 0.5), 1./16, None, (-140, 0), 10, None)
+            plt.text(
+                f0 - 1 / osr,
+                -15,
+                msg,
+                horizontalalignment="right",
+                verticalalignment="center",
+            )
+        plt.text(
+            0.5,
+            -135,
+            "NBW = %.1e " % NBW,
+            horizontalalignment="right",
+            verticalalignment="bottom",
+        )
+        figureMagic((0, 0.5), 1.0 / 16, None, (-140, 0), 10, None)
     else:
         spec0 = fftshift(spec0 / 2)
         freq = np.linspace(-0.5, 0.5, N + 1)
         freq = freq[:-1]
-        plt.plot(freq, dbv(spec0), 'c', linewidth=1)
-        #plt.hold(True)
-        spec_smoothed = circ_smooth(abs(spec0)**2, 16)
-        plt.plot(freq, dbp(spec_smoothed), 'b', linewidth=3)
-        Snn = abs(evalTF(ntf, np.exp(2j * np.pi * freq))) ** 2 * 2 / 12 * (delta / M) ** 2
-        plt.plot(freq, dbp(Snn*NBW), 'm', linewidth=1)
-        snr = calculateSNR(spec0[N//2 + f1_bin:N//2 + f2_bin + 1], fin - f1_bin)
-        msg = 'SQNR  =  %.1fdB\n @ A = %.1fdBFS & osr = %.0f' % \
-              (snr, dbv(spec0[N//2 + fin]), osr)
-        if f0 >=  0:
-            plt.text(f0 - 0.05, - 15, msg, horizontalalignment='right',
-                     verticalalignment='bottom')
+        plt.plot(freq, dbv(spec0), "c", linewidth=1)
+        # plt.hold(True)
+        spec_smoothed = circ_smooth(abs(spec0) ** 2, 16)
+        plt.plot(freq, dbp(spec_smoothed), "b", linewidth=3)
+        Snn = (
+            abs(evalTF(ntf, np.exp(2j * np.pi * freq))) ** 2 * 2 / 12 * (delta / M) ** 2
+        )
+        plt.plot(freq, dbp(Snn * NBW), "m", linewidth=1)
+        snr = calculateSNR(spec0[N // 2 + f1_bin : N // 2 + f2_bin + 1], fin - f1_bin)
+        msg = "SQNR  =  %.1fdB\n @ A = %.1fdBFS & osr = %.0f" % (
+            snr,
+            dbv(spec0[N // 2 + fin]),
+            osr,
+        )
+        if f0 >= 0:
+            plt.text(
+                f0 - 0.05,
+                -15,
+                msg,
+                horizontalalignment="right",
+                verticalalignment="bottom",
+            )
         else:
-            plt.text(f0 + 0.05, - 15, msg, horizontalalignment='left',
-                     verticalalignment='bottom')
-        plt.text(-0.5, -135, ' NBW = %.1e' % NBW, horizontalalignment='left',
-                 verticalalignment='bottom')
+            plt.text(
+                f0 + 0.05,
+                -15,
+                msg,
+                horizontalalignment="left",
+                verticalalignment="bottom",
+            )
+        plt.text(
+            -0.5,
+            -135,
+            " NBW = %.1e" % NBW,
+            horizontalalignment="left",
+            verticalalignment="bottom",
+        )
         figureMagic((-0.5, 0.5), 0.125, None, (-140, 0), 10, None)
-    plt.xlabel('frequency')
+    plt.xlabel("frequency")
     return

deltasigma/__init__.py

@@ -899,7 +899,7 @@
 __copyright__ = "Copyright 2013, Giuseppe Venturini"
 __credits__ = ["Giuseppe Venturini"]
 __license__ = "BSD 2-Clause License"
-__version__ = '0.2.5'
+__version__ = "0.2.5"
 __maintainer__ = "Giuseppe Venturini"
 __email__ = "ggventurini+github@gmail.com"
 __status__ = "Stable"
@@ -914,10 +914,11 @@
 # if not os.system('python -c "import matplotlib.pyplot as plt;plt.figure()"')
 import matplotlib
 import os
-if not ('DISPLAY' in os.environ
-        or os.name =='nt'
-        or os.environ.get('READTHEDOCS', None)):
-    matplotlib.use('Agg')
+
+if not (
+    "DISPLAY" in os.environ or os.name == "nt" or os.environ.get("READTHEDOCS", None)
+):
+    matplotlib.use("Agg")
 
 from ._DocumentNTF import DocumentNTF
 from ._PlotExampleSpectrum import PlotExampleSpectrum
@@ -983,7 +984,7 @@
 from ._rms import rms
 from ._rmsGain import rmsGain
 from ._scaleABCD import scaleABCD
-from ._simulateDSM import simulateDSM, simulation_backends
+from ._simulateDSM import simulateDSM
 from ._simulateQDSM import simulateQDSM
 from ._simulateQSNR import simulateQSNR
 from ._simulateSNR import simulateSNR
@@ -998,4 +999,5 @@
 from ._undbv import undbv
 from ._utils import circshift, cplxpair, mfloor, mround, pretty_lti, rat, gcd, lcm
 from ._zinc import zinc
+
 # from . import PosInvSet

deltasigma/_calculateTF.py

@@ -19,14 +19,14 @@
 from warnings import warn
 
 import numpy as np
-from scipy.signal import lti, ss2zpk
+from scipy.signal import dlti, ss2zpk
 
 from ._constants import eps
 from ._partitionABCD import partitionABCD
 from ._utils import carray, minreal
 
 
-def calculateTF(ABCD, k=1.):
+def calculateTF(ABCD, k=1.0):
     """Calculate the NTF and STF of a delta-sigma modulator.
 
     The calculation is performed for a given loop filter
@@ -48,9 +48,9 @@ def calculateTF(ABCD, k=1.):
     **Returns:**
 
     (NTF, STF) : a tuple of two LTI objects (or of two lists of LTI objects).
-                 If a version of the ``scipy`` library equal to 0.16.x or 
+                 If a version of the ``scipy`` library equal to 0.16.x or
                  greater is in use, the objects will be ``ZeroPolesGain``
-                 objects, a subclass of ``scipy.signal.lti``.
+                 objects, a subclass of ``scipy.signal.dlti``.
 
     If the system has multiple quantizers, multiple STFs and NTFs will be
     returned.
@@ -123,7 +123,7 @@ def calculateTF(ABCD, k=1.):
     """
 
     nq = len(k) if type(k) in (tuple, list) else 1
-    A, B, C, D = partitionABCD(ABCD, m=nq+1, r=nq)
+    A, B, C, D = partitionABCD(ABCD, m=nq + 1, r=nq)
     k = carray(k)
     diagk = np.atleast_2d(np.diag(k))
 
@@ -158,25 +158,24 @@ def calculateTF(ABCD, k=1.):
 
     # Find the noise transfer function by forming the closed-loop
     # system (sys_cl) in state-space form.
-    Ct = np.linalg.inv(np.eye(nq) - D2*diagk)
+    Ct = np.linalg.inv(np.eye(nq) - D2 * diagk)
     Acl = A + np.dot(B2, np.dot(Ct, np.dot(diagk, C)))
-    Bcl = np.hstack((B1 + np.dot(B2, np.dot(Ct, np.dot(diagk, D1))),
-                     np.dot(B2, Ct)))
+    Bcl = np.hstack((B1 + np.dot(B2, np.dot(Ct, np.dot(diagk, D1))), np.dot(B2, Ct)))
     Ccl = np.dot(Ct, np.dot(diagk, C))
     Dcl = np.dot(Ct, np.hstack((np.dot(diagk, D1), np.eye(nq))))
-    tol = min(1e-3, max(1e-6, eps**(1/ABCD.shape[0])))
+    tol = min(1e-3, max(1e-6, eps ** (1 / ABCD.shape[0])))
     ntfs = np.empty((nq, Dcl.shape[0]), dtype=np.object_)
     stfs = np.empty((Dcl.shape[0],), dtype=np.object_)
 
     # sweep the outputs 'cause scipy is silly but we love it anyhow.
     for i in range(Dcl.shape[0]):
         # input #0 is the signal
         # inputs #1,... are quantization noise
-        stf_z, stf_p, stf_k  = ss2zpk(Acl, Bcl, Ccl[i, :], Dcl[i, :], input=0)
-        stf = lti(stf_z, stf_p, stf_k)
+        stf_z, stf_p, stf_k = ss2zpk(Acl, Bcl, Ccl[i, :], Dcl[i, :], input=0)
+        stf = dlti(stf_z, stf_p, stf_k)
         for j in range(nq):
-            ntf_z, ntf_p, ntf_k = ss2zpk(Acl, Bcl, Ccl[i, :], Dcl[i, :], input=j+1)
-            ntf = lti(ntf_z, ntf_p, ntf_k)
+            ntf_z, ntf_p, ntf_k = ss2zpk(Acl, Bcl, Ccl[i, :], Dcl[i, :], input=j + 1)
+            ntf = dlti(ntf_z, ntf_p, ntf_k)
             stf_min, ntf_min = minreal((stf, ntf), tol)
             ntfs[i, j] = ntf_min
         stfs[i] = stf_min
@@ -185,4 +184,3 @@ def calculateTF(ABCD, k=1.):
     if ntfs.shape == (1, 1):
         return [ntfs[0, 0], stfs[0]]
     return ntfs, stfs
-

deltasigma/_cancelPZ.py

@@ -4,7 +4,7 @@
 # Copyright 2013 Giuseppe Venturini
 # This file is part of python-deltasigma.
 #
-# python-deltasigma is a 1:1 Python replacement of Richard Schreier's 
+# python-deltasigma is a 1:1 Python replacement of Richard Schreier's
 # MATLAB delta sigma toolbox (aka "delsigma"), upon which it is heavily based.
 # The delta sigma toolbox is (c) 2009, Richard Schreier.
 #
@@ -21,7 +21,7 @@
 import copy
 
 import numpy as np
-from scipy.signal import lti
+from scipy.signal import dlti
 
 
 def cancelPZ(arg1, tol=1e-6):
@@ -32,7 +32,7 @@ def cancelPZ(arg1, tol=1e-6):
     arg1 : LTI system description
         Multiple descriptions are supported for the LTI system.
 
-        If one argument is used, it is a scipy ``lti`` object.
+        If one argument is used, it is a scipy ``dlti`` object.
 
         If more arguments are used, they should be arranged in a tuple, the
         following gives the number of elements in the tuple and their
@@ -50,12 +50,12 @@ def cancelPZ(arg1, tol=1e-6):
     **Returns:**
 
     (z, p, k) : tuple
-        A tuple containing zeros, poles and gain (unchanged) after poles, zeros 
+        A tuple containing zeros, poles and gain (unchanged) after poles, zeros
         cancellation.
 
     """
-    if not isinstance(arg1, lti):
-        arg1 = lti(*arg1)
+    if not isinstance(arg1, dlti):
+        arg1 = dlti(*arg1)
     z = copy.copy(arg1.zeros)
     p = copy.copy(arg1.poles)
     k = arg1.gain

deltasigma/_evalTFP.py

@@ -69,7 +69,7 @@ def evalTFP(Hs, Hz, f):
 
         import numpy as np
         import pylab as plt
-        from scipy.signal import lti
+        from scipy.signal import dlti
         from deltasigma import *
         from deltasigma._utils import _get_zpk
         Ac = np.array([[0, 0], [1, 0]])
@@ -80,7 +80,7 @@ def evalTFP(Hs, Hz, f):
         L0c = _get_zpk((Ac, Bc[:, 0].reshape((-1, 1)), Cc, Dc[0, 0].reshape(1, 1)))
         tdac = [0, 1]
         LF, Gp = mapCtoD(LFc, tdac)
-        LF = lti(*LF)
+        LF = dlti(*LF)
         ABCD = np.vstack((np.hstack((LF.A, LF.B)),
                           np.hstack((LF.C, LF.D))
                         ))
@@ -98,7 +98,7 @@ def evalTFP(Hs, Hz, f):
 
         import numpy as np
         import pylab as plt
-        from scipy.signal import lti
+        from scipy.signal import dlti
         from deltasigma import *
         from deltasigma._utils import _get_zpk
         Ac = np.array([[0, 0], [1, 0]])
@@ -109,7 +109,7 @@ def evalTFP(Hs, Hz, f):
         L0c = _get_zpk((Ac, Bc[:, 0].reshape((-1, 1)), Cc, Dc[0, 0].reshape(1, 1)))
         tdac = [0, 1]
         LF, Gp = mapCtoD(LFc, tdac)
-        LF = lti(*LF)
+        LF = dlti(*LF)
         ABCD = np.vstack((np.hstack((LF.A, LF.B)),
                           np.hstack((LF.C, LF.D))
                         ))