mirror of
https://github.com/jhshi/openofdm.git
synced 2024-12-26 08:51:15 +00:00
145 lines
3.3 KiB
Python
145 lines
3.3 KiB
Python
|
|
# 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
|