style: single quotes to double around strings

Author: idfah

cebl/sig/__init__.py

@@ -1,6 +1,5 @@
 """Signal processing.
 """
-
 from .bandpass import *
 from .cwt import *
 from .psd import *

cebl/sig/bandpass.py

@@ -33,7 +33,7 @@ def getPowers(self):
     def getFreqsPowers(self):
         return self.freqs, self.powers
 
-    def plotPower(self, scale='log', ax=None, **kwargs):
+    def plotPower(self, scale="log", ax=None, **kwargs):
         """Plot a PSD estimate on a log scale.
 
         Returns
@@ -47,40 +47,40 @@ def plotPower(self, scale='log', ax=None, **kwargs):
         scale = scale.lower()
         if ax is None:
             fig = plt.figure()
-            result['fig'] = fig
+            result["fig"] = fig
             ax = fig.add_subplot(1, 1, 1)
-        result['ax'] = ax
+        result["ax"] = ax
 
         ax.grid()
-        ax.set_title('Power Spectral Density')
-        ax.set_xlabel(r'Freqency ($Hz$)')
+        ax.set_title("Power Spectral Density")
+        ax.set_xlabel(r"Freqency ($Hz$)")
         ax.set_xlim((np.min(self.freqs), np.max(self.freqs)))
-        if scale in ('linear', 'log'):
-            ax.set_ylabel(r'Power Density ($\mu V^2 / Hz$)')
-        elif scale in ('db', 'decibels'):
-            ax.set_ylabel(r'Power Density (dB)')
-        if scale == 'log':
-            ax.set_yscale('log')
-
-        if scale in ('linear', 'log'):
+        if scale in ("linear", "log"):
+            ax.set_ylabel(r"Power Density ($\mu V^2 / Hz$)")
+        elif scale in ("db", "decibels"):
+            ax.set_ylabel(r"Power Density (dB)")
+        if scale == "log":
+            ax.set_yscale("log")
+
+        if scale in ("linear", "log"):
             scaledPowers = self.powers
-        elif scale in ('db', 'decibels'):
+        elif scale in ("db", "decibels"):
             scaledPowers = 10.0*np.log10(self.powers/np.max(self.powers))
         else:
-            raise RuntimeError('Invalid scale %s.' % str(scale))
+            raise RuntimeError("Invalid scale %s." % str(scale))
 
         lines = ax.plot(self.freqs, scaledPowers, **kwargs)
-        result['lines'] = lines
+        result["lines"] = lines
 
         return result
 
 
 class WelchPSD(PSDBase):
-    """PSD smoothed using Welch's method.
+    """PSD smoothed using Welch"s method.
     """
 
     def __init__(self, s, sampRate=1.0, span=3.0, overlap=0.5, windowFunc=windows.hann, pad=False):
-        """Construct a new PSD using Welch's method.
+        """Construct a new PSD using Welch"s method.
 
         Args:
             s:          Numpy array with shape (observations[,dimensions])
@@ -126,10 +126,10 @@ def __init__(self, s, sampRate=1.0, span=3.0, overlap=0.5, windowFunc=windows.ha
 
         # check span parameter
         if wObs > nObs:
-            raise RuntimeError('Span of %.2f exceedes length of input %.2f.' %
+            raise RuntimeError("Span of %.2f exceedes length of input %.2f." %
                 (span, nObs/float(sampRate)))
         if wObs < 7:
-            raise RuntimeError('Span of %.2f is too small.' % span)
+            raise RuntimeError("Span of %.2f is too small." % span)
 
         if pad:
             # find next largest power of two
@@ -161,7 +161,7 @@ def __init__(self, s, sampRate=1.0, span=3.0, overlap=0.5, windowFunc=windows.ha
         dft = dft[:,:int(np.ceil(nPad/2.0)),:]
 
         # scale to power/Hz
-        # numpy fft doesn't support complex64 so can't preserve float32 dtype XXX - idfah
+        # numpy fft doesn"t support complex64 so can"t preserve float32 dtype XXX - idfah
         dftmag = np.abs(dft).astype(s.dtype, copy=False)
         powers = 2.0*(dftmag**2)/scaleDenom
 
@@ -362,16 +362,16 @@ def __init__(self, s, sampRate=1.0, order=20, freqs=None, **kwargs):
 
 # wrapper around class constructors
 # pylint: disable=invalid-name
-def PowerSpectralDensity(s, method='welch', **kwargs):
+def PowerSpectralDensity(s, method="welch", **kwargs):
     method = method.lower()
-    if method == 'welch':
+    if method == "welch":
         return WelchPSD(s, **kwargs)
-    elif method in ('raw', 'fft'):
+    elif method in ("raw", "fft"):
         return RawPSD(s, **kwargs)
-    elif method in ('ar', 'autoreg'):
+    elif method in ("ar", "autoreg"):
         return AutoRegPSD(s, **kwargs)
     else:
-        raise RuntimeError('Unknown PSD estimation method: ' + str(method))
+        raise RuntimeError("Unknown PSD estimation method: " + str(method))
 
 def PSD(*args, **kwargs):
     return PowerSpectralDensity(*args, **kwargs)
@@ -389,26 +389,26 @@ def demoPSD():
     noise2 = np.random.normal(loc=0.0, scale=0.2, size=s.shape)
 
     y = np.vstack((np.sin(2*f1*np.pi*s)+noise1, 10.0*np.sin(2*f2*np.pi*s)+noise2)).T
-    print('True max power: ', np.mean(y**2, axis=0))
+    print("True max power: ", np.mean(y**2, axis=0))
 
-    scale = 'log'
+    scale = "log"
 
     raw = RawPSD(y, sampRate)
-    ax = raw.plotPower(scale=scale, label='raw')['ax']
-    print('Raw max power: ', np.max(raw.getPowers()*sampRate, axis=0))
+    ax = raw.plotPower(scale=scale, label="raw")["ax"]
+    print("Raw max power: ", np.max(raw.getPowers()*sampRate, axis=0))
 
     welch = WelchPSD(y, sampRate, span=4)
-    welch.plotPower(scale=scale, ax=ax, label='welch')
-    print('Welch max power: ', np.max(welch.getPowers()*sampRate, axis=0))
+    welch.plotPower(scale=scale, ax=ax, label="welch")
+    print("Welch max power: ", np.max(welch.getPowers()*sampRate, axis=0))
 
     autoreg = AutoRegPSD(y, sampRate, order=10)
-    autoreg.plotPower(scale=scale, ax=ax, label='autoreg')
-    print('AR max power: ', np.max(autoreg.getPowers()*sampRate, axis=0))
+    autoreg.plotPower(scale=scale, ax=ax, label="autoreg")
+    print("AR max power: ", np.max(autoreg.getPowers()*sampRate, axis=0))
 
     ax.legend()
 
     ax.autoscale(tight=True)
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     demoPSD()
     plt.show()

cebl/sig/psd.py

@@ -47,7 +47,7 @@ def upsample(s, factor):
 
     s = util.colmat(s)
 
-    sup = s.repeat(factor).reshape((-1, s.shape[1]), order='F')
+    sup = s.repeat(factor).reshape((-1, s.shape[1]), order="F")
 
     if flattenOut:
         sup = sup.ravel()
@@ -65,7 +65,7 @@ def decimate(s, factor, lowpassFrac=0.625, **kwargs):
 
     return downsample(sFiltered, factor)
 
-def interpolate(s, factor, order=8, filtType='lanczos'):
+def interpolate(s, factor, order=8, filtType="lanczos"):
     """Interpolate (upsample) a discrete signal by a given factor using a
     Finite Impulse Response (FIR) filter.
 
@@ -107,8 +107,8 @@ def interpolate(s, factor, order=8, filtType='lanczos'):
         New observations (length 4*2=8):   |**|**|**|**
     """
     if order % 2 != 0:
-        raise RuntimeError('Invalid order: ' + str(order) +
-            ' Must be an even integer.')
+        raise RuntimeError("Invalid order: " + str(order) +
+            " Must be an even integer.")
 
     # ensure we have a numpy array
     s = np.asarray(s)
@@ -136,19 +136,19 @@ def interpolate(s, factor, order=8, filtType='lanczos'):
     taps = np.linspace(-radius, radius, newOrder+1).astype(s.dtype, copy=False)
 
     # generate FIR filter
-    if filtType == 'lanczos':
+    if filtType == "lanczos":
         impulseResponse = np.sinc(taps) * windows.lanczos(newOrder+1).astype(s.dtype, copy=False)
-    elif filtType == 'sinc-blackman':
+    elif filtType == "sinc-blackman":
         impulseResponse = np.sinc(taps) * windows.blackman(newOrder+1).astype(s.dtype, copy=False)
     else:
-        raise RuntimeError('Invalid filtType: ' + str(filtType))
+        raise RuntimeError("Invalid filtType: " + str(filtType))
 
     # convolve with FIR filter to smooth across zero padding
     # NOTE:  there is potential for performance improvement here since
     #        zeros could be excluded from the computation XXX - idfah
     # spsig.fftconvolve might also be faster for long signals XXX - idfah
     return np.apply_along_axis(lambda v:
-               np.convolve(v, impulseResponse, mode='same'),
+               np.convolve(v, impulseResponse, mode="same"),
                axis=0, arr=sl)
 
 def resample(s, factorDown, factorUp=1, interpKwargs=None, **decimKwargs):
@@ -207,11 +207,11 @@ def demoInterpolate():
     sLanczos8 = interpolate(s, factor, order=8)
     sLanczos16 = interpolate(s, factor, order=16)
 
-    plt.plot(t, s, marker='o', color='lightgrey', linewidth=3, label='Original')
-    plt.plot(tInterp, sLanczos4, color='blue', label='Lanczos4')
-    plt.plot(tInterp, sLanczos8, color='red', label='Lanczos8')
-    plt.plot(tInterp, sLanczos16, color='green', label='Lanczos16')
-    plt.title('Interpolation of a Random Walk')
+    plt.plot(t, s, marker="o", color="lightgrey", linewidth=3, label="Original")
+    plt.plot(tInterp, sLanczos4, color="blue", label="Lanczos4")
+    plt.plot(tInterp, sLanczos8, color="red", label="Lanczos8")
+    plt.plot(tInterp, sLanczos16, color="green", label="Lanczos16")
+    plt.title("Interpolation of a Random Walk")
     plt.legend()
     plt.tight_layout()
 
@@ -229,69 +229,69 @@ def demoResample():
     fig = plt.figure()
 
     ##axChirp = fig.add_subplot(4, 1, 1)
-    ##axChirp.plot(f, chirp, color='black')
-    ##axChirp.set_title('Chirp')
-    ##axChirp.set_xlabel('Frequency (Hz)')
-    ##axChirp.set_ylabel('Signal')
+    ##axChirp.plot(f, chirp, color="black")
+    ##axChirp.set_title("Chirp")
+    ##axChirp.set_xlabel("Frequency (Hz)")
+    ##axChirp.set_ylabel("Signal")
     ##axChirp.autoscale(tight=True)
 
     #axChirpTwiny = axChirp.twiny()
     #axChirpTwiny.plot(t, chirp, alpha=0.0)
-    #axChirpTwiny.set_xlabel('Time (s)')
+    #axChirpTwiny.set_xlabel("Time (s)")
 
     fDown = downsample(f, factor)
     chirpDown = downsample(chirp, factor)
 
     axDown = fig.add_subplot(2, 2, 1)
-    axDown.plot(f, chirp, color='lightgrey', linewidth=2)
-    axDown.plot(fDown, chirpDown, color='red')
+    axDown.plot(f, chirp, color="lightgrey", linewidth=2)
+    axDown.plot(fDown, chirpDown, color="red")
     axDown.vlines(nyquist/factor, -1.0, 1.0, linewidth=2,
-        linestyle='--', color='green', label='New Nyquist')
-    axDown.set_title('Downsample factor %d' % factor)
-    axDown.set_xlabel('Frequency (Hz)')
-    axDown.set_ylabel('Signal')
+        linestyle="--", color="green", label="New Nyquist")
+    axDown.set_title("Downsample factor %d" % factor)
+    axDown.set_xlabel("Frequency (Hz)")
+    axDown.set_ylabel("Signal")
     axDown.autoscale(tight=True)
 
     chirpDeci = decimate(chirp, factor)
     axDeci = fig.add_subplot(2, 2, 3)
-    axDeci.plot(f, chirp, color='lightgrey', linewidth=2)
-    axDeci.plot(fDown, chirpDeci, color='red')
+    axDeci.plot(f, chirp, color="lightgrey", linewidth=2)
+    axDeci.plot(fDown, chirpDeci, color="red")
     axDeci.vlines(nyquist/factor, -1.0, 1.0, linewidth=2,
-        linestyle='--', color='green', label='New Nyquist')
-    axDeci.set_title('Decimation factor %d' % factor)
-    axDeci.set_xlabel('Frequency (Hz)')
-    axDeci.set_ylabel('Signal')
+        linestyle="--", color="green", label="New Nyquist")
+    axDeci.set_title("Decimation factor %d" % factor)
+    axDeci.set_xlabel("Frequency (Hz)")
+    axDeci.set_ylabel("Signal")
     axDeci.autoscale(tight=True)
 
     fInterp = np.linspace(0.0, nyquist, 2.0*sampRate*factor, endpoint=False)
     chirpInterp = interpolate(chirp, factor)
 
     axInterp = fig.add_subplot(2, 2, 2)
-    axInterp.plot(f, chirp, color='lightgrey', linewidth=2)
-    axInterp.plot(fInterp, chirpInterp, color='red')
+    axInterp.plot(f, chirp, color="lightgrey", linewidth=2)
+    axInterp.plot(fInterp, chirpInterp, color="red")
     #axInterp.vlines(nyquist*factor, -1.0, 1.0, linewidth=2,
-    #  linestyle='--', color='green', label='New Nyquist')
-    axInterp.set_title('Interpolation factor %d' % factor)
-    axInterp.set_xlabel('Frequency (Hz)')
-    axInterp.set_ylabel('Signal')
+    #  linestyle="--", color="green", label="New Nyquist")
+    axInterp.set_title("Interpolation factor %d" % factor)
+    axInterp.set_xlabel("Frequency (Hz)")
+    axInterp.set_ylabel("Signal")
     axInterp.autoscale(tight=True)
 
     fResamp = np.linspace(0.0, nyquist, 2.0*sampRate*(2.0/factor), endpoint=False)
     chirpResamp = resample(chirp, factorUp=2, factorDown=factor)
 
     axResamp = fig.add_subplot(2, 2, 4)
-    axResamp.plot(f, chirp, color='lightgrey', linewidth=2)
-    axResamp.plot(fResamp, chirpResamp, color='red')
+    axResamp.plot(f, chirp, color="lightgrey", linewidth=2)
+    axResamp.plot(fResamp, chirpResamp, color="red")
     axResamp.vlines((2.0/factor)*nyquist, -1.0, 1.0, linewidth=2,
-      linestyle='--', color='green', label='New Nyquist')
-    axResamp.set_title('Resample factor 2/%d' % factor)
-    axResamp.set_xlabel('Frequency (Hz)')
-    axResamp.set_ylabel('Signal')
+      linestyle="--", color="green", label="New Nyquist")
+    axResamp.set_title("Resample factor 2/%d" % factor)
+    axResamp.set_xlabel("Frequency (Hz)")
+    axResamp.set_ylabel("Signal")
     axResamp.autoscale(tight=True)
 
     fig.tight_layout()
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     demoInterpolate()
     demoResample()
     plt.show()

cebl/sig/resamp.py

@@ -37,7 +37,7 @@ def movingAverage(s, width=2, kernelFunc=windows.boxcar, **kwargs):
 
     return np.apply_along_axis(
         np.convolve, axis=0, arr=s,
-        v=kernel, mode='same')
+        v=kernel, mode="same")
 
 def savitzkyGolay(s, *args, **kwargs):
     """Savitzky Golay filter.
@@ -113,33 +113,33 @@ def demoSmooth():
     fig = plt.figure()
 
     axMA = fig.add_subplot(2, 2, 1)
-    axMA.plot(x, y+sep, color='grey', linewidth=3)
+    axMA.plot(x, y+sep, color="grey", linewidth=3)
     axMA.plot(x, yMA+sep)
-    axMA.set_title('Moving Average %d' % maWidth)
+    axMA.set_title("Moving Average %d" % maWidth)
     axMA.autoscale(tight=True)
 
     axGA = fig.add_subplot(2, 2, 2)
-    axGA.plot(x, y+sep, color='grey', linewidth=3)
+    axGA.plot(x, y+sep, color="grey", linewidth=3)
     axGA.plot(x, yGA+sep)
-    axGA.set_title('Gaussian Moving Average %d' % gaWidth)
+    axGA.set_title("Gaussian Moving Average %d" % gaWidth)
     axGA.autoscale(tight=True)
 
     axSG = fig.add_subplot(2, 2, 3)
-    axSG.plot(x, y+sep, color='grey', linewidth=3)
+    axSG.plot(x, y+sep, color="grey", linewidth=3)
     axSG.plot(x, ySG+sep)
-    axSG.set_title('Savitzky-Golay %d %d' % (sgWidth, sgOrder))
+    axSG.set_title("Savitzky-Golay %d %d" % (sgWidth, sgOrder))
     axSG.autoscale(tight=True)
 
     axWN = fig.add_subplot(2, 2, 4)
-    axWN.plot(x, y+sep, color='grey', linewidth=3)
+    axWN.plot(x, y+sep, color="grey", linewidth=3)
     axWN.plot(x, yWN+sep)
-    axWN.set_title('Wiener %d %3.2f' % (wnSize, wnNoise))
-    #axWN.set_title('Wiener')
+    axWN.set_title("Wiener %d %3.2f" % (wnSize, wnNoise))
+    #axWN.set_title("Wiener")
     axWN.autoscale(tight=True)
 
     fig.tight_layout()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     demoSmooth()
     plt.show()