def getPairsIndicesList(self, i, allPermutations=False):
"""
Returns a list of tuples of numeric indices from a combined type of
indices.
"""
permutate = permutations if allPermutations else combinations
if i is None:
return permutate([*range(0, self.channelNumber)], 2)
if isinstance(i, slice):
return self.getPairsIndicesList(self.getIndicesList(None)[i])
if isinstance(i, tuple) and len(i) == 2:
return [tuple(self.getIndicesList(list(i)))]
if isinstance(i, list):
if listType(i) is tuple:
return [self.getPairsIndicesList(c)[0] for c in i]
return permutate(self.getIndicesList(i), 2)
raise ValueError("This method only accepts int, str, list or " +
"slice types and not %s" % type(i))
def test_listType_sameTypes(self):
v = aux.listType([*range(10)])
self.assertEqual(v, int)
v = aux.listType(["a", 'b', "1", '2', """"long text"""])
self.assertEqual(v, str)
def test_listType_diffTypes(self):
v = aux.listType([1, "2", 3.0])
self.assertEqual(v, None)
v = aux.listType([*range(10), "10", *range(11, 21)])
self.assertEqual(v, None)
def test_listType_noLength(self):
testList = []
v = aux.listType(testList)
self.assertEqual(v, None)
def test_listType_noList(self):
noList = "asd"
with self.assertRaises(ValueError):
aux.listType(noList)
def getPairOfChannels(self, channels=None, allPermutations=False):
"""
Applies a function that uses two signals by selecting the channels to
use. It will apply the function to different channels depending on the
parameters. Note: a single channel can be selected by using an int or
a string if a name for the channel was specified.
Parameters
----------
channels: Variable type, optional
* tuple of lenght 2 containing channel indexes: applies the
function to the two channels specified by the tuple.
* list of tuples(same restrictions than the above): applies the
function to every tuple in the list.
* list of index: creates combinations of channels specifies in the
list depending of the allPermutations parameter.
* None: Are channels are used in the same way than in the list
above. This is the default value.
allPermutations: bool, optional
Only used when channels is a list of index or None. If True all
permutations of the channels in every order are used; if False only
combinations of different channels are used. Example: with the list
[0, 2, 4] and allPermutations = True, the channels used will be
(0,2), (0,4), (2,0), (2,4), (4,0), (4,2); meanwhile, with
allPermutations = False, the channels used will be: (0,2), (0,4),
(2,4). Default: False.
Returns
-------
If a tuple is passed the it returns the result of applying the function
to the channels specified in the tuple. If another valid value is
passed, the method returns a dictionary, being the key the two channels
used and the value the result of applying the function to those
channels.
"""
permutate = permutations if allPermutations else combinations
if channels is None:
channels = [*range(self.channelNumber)]
elif isinstance(channels, slice):
channels = [*range(self.channelNumber)[channels]]
if isinstance(channels, tuple):
if len(channels) != 2:
raise ValueError("If you specify a tuple, it must have " +
"exactly two(2) elements")
return (self.getChannel(channels[0]), self.getChannel(channels[1]))
if isinstance(channels, list):
t = listType(channels)
if t is tuple:
acs = np.array(channels)
if len(acs.shape) == 2 and acs.shape[1] == 2:
return [(self.getChannel(c[0]), self.getChannel(c[1]))
for c in channels]
raise ValueError("The tuples of the list must have " +
"exactly two(2) elements")
try:
return permutate(self.getChannel(channels), 2)
except ValueError as err:
raise ValueError("The list must contain either tuples " +
"or integers and strings, but no " +
"combinations of them.") from err
raise ValueError("This method only accepts list (either of int " +
"and str or tuples) or tuple types and not %s" %
type(channels))