scripts init

scripts/commpy/utilities.py

@@ -0,0 +1,144 @@
+
+# Authors: Veeresh Taranalli <veeresht@gmail.com>
+# License: BSD 3-Clause
+
+"""
+============================================
+Utilities (:mod:`commpy.utilities`)
+============================================
+
+.. autosummary::
+   :toctree: generated/
+
+   dec2bitarray         -- Integer to binary (bit array).
+   bitarray2dec         -- Binary (bit array) to integer.
+   hamming_dist         -- Hamming distance.
+   euclid_dist          -- Squared Euclidean distance.
+   upsample             -- Upsample by an integral factor (zero insertion).
+
+"""
+import numpy as np
+
+__all__ = ['dec2bitarray', 'bitarray2dec', 'hamming_dist', 'euclid_dist', 'upsample']
+
+def dec2bitarray(in_number, bit_width):
+    """
+    Converts a positive integer to NumPy array of the specified size containing
+    bits (0 and 1).
+
+    Parameters
+    ----------
+    in_number : int
+        Positive integer to be converted to a bit array.
+
+    bit_width : int
+        Size of the output bit array.
+
+    Returns
+    -------
+    bitarray : 1D ndarray of ints
+        Array containing the binary representation of the input decimal.
+
+    """
+
+    binary_string = bin(in_number)
+    length = len(binary_string)
+    bitarray = np.zeros(bit_width, 'int')
+    for i in range(length-2):
+        bitarray[bit_width-i-1] = int(binary_string[length-i-1])
+
+    return bitarray
+
+def bitarray2dec(in_bitarray):
+    """
+    Converts an input NumPy array of bits (0 and 1) to a decimal integer.
+
+    Parameters
+    ----------
+    in_bitarray : 1D ndarray of ints
+        Input NumPy array of bits.
+
+    Returns
+    -------
+    number : int
+        Integer representation of input bit array.
+    """
+
+    number = 0
+
+    for i in range(len(in_bitarray)):
+        number = number + in_bitarray[i]*pow(2, len(in_bitarray)-1-i)
+
+    return number
+
+def hamming_dist(in_bitarray_1, in_bitarray_2):
+    """
+    Computes the Hamming distance between two NumPy arrays of bits (0 and 1).
+
+    Parameters
+    ----------
+    in_bit_array_1 : 1D ndarray of ints
+        NumPy array of bits.
+
+    in_bit_array_2 : 1D ndarray of ints
+        NumPy array of bits.
+
+    Returns
+    -------
+    distance : int
+        Hamming distance between input bit arrays.
+    """
+    distance = 0
+    for i, j in zip(in_bitarray_1, in_bitarray_2):
+        # Jinghao: 2016-10-19: handle "don't care" bits
+        if i in [0, 1] and j in [0, 1] and i != j:
+            distance += 1
+    return distance
+
+def euclid_dist(in_array1, in_array2):
+    """
+    Computes the squared euclidean distance between two NumPy arrays
+
+    Parameters
+    ----------
+    in_array1 : 1D ndarray of floats
+        NumPy array of real values.
+
+    in_array2 : 1D ndarray of floats
+        NumPy array of real values.
+
+    Returns
+    -------
+    distance : float
+        Squared Euclidean distance between two input arrays.
+    """
+    distance = ((in_array1 - in_array2)*(in_array1 - in_array2)).sum()
+
+    return distance
+
+def upsample(x, n):
+    """
+    Upsample the input array by a factor of n
+
+    Adds n-1 zeros between consecutive samples of x
+
+    Parameters
+    ----------
+    x : 1D ndarray
+        Input array.
+
+    n : int
+        Upsampling factor
+
+    Returns
+    -------
+    y : 1D ndarray
+        Output upsampled array.
+    """
+    y = np.empty(len(x)*n, dtype=complex)
+    y[0::n] = x
+    zero_array = np.zeros(len(x), dtype=complex)
+    for i in range(1, n):
+        y[i::n] = zero_array
+
+    return y