def get_supported_dtypes(self):
"""Return dtypes supported by the node as a list of :numpy:`dtype`
objects.
Note that subclasses should overwrite `self._get_supported_dtypes`
when needed."""
return [numx.dtype(t) for t in self._get_supported_dtypes()]
def __init__(self, n, d, real_dtype="d", integer_dtype="l"):
"""
Input arguments:
n -- Number of maxima and minima to remember
d -- Minimum gap between two hits
real_dtype -- dtype of sequence items
integer_dtype -- dtype of sequence indices
Note: be careful with dtypes!
"""
self.n = int(n)
self.d = int(d)
self.iM = numx.zeros((n, ), dtype=integer_dtype)
self.im = numx.zeros((n, ), dtype=integer_dtype)
real_dtype = numx.dtype(real_dtype)
if real_dtype in mdp.utils.get_dtypes('AllInteger'):
max_num = numx.iinfo(real_dtype).max
min_num = numx.iinfo(real_dtype).min
else:
max_num = numx.finfo(real_dtype).max
min_num = numx.finfo(real_dtype).min
self.M = numx.array([min_num]*n, dtype=real_dtype)
self.m = numx.array([max_num]*n, dtype=real_dtype)
self.lM = 0
self.lm = 0
def __init__(self, n, d, real_dtype="d", integer_dtype="l"):
"""
Input arguments:
n -- Number of maxima and minima to remember
d -- Minimum gap between two hits
real_dtype -- dtype of sequence items
integer_dtype -- dtype of sequence indices
Note: be careful with dtypes!
"""
self.n = int(n)
self.d = int(d)
self.iM = numx.zeros((n, ), dtype=integer_dtype)
self.im = numx.zeros((n, ), dtype=integer_dtype)
real_dtype = numx.dtype(real_dtype)
if real_dtype in mdp.utils.get_dtypes('AllInteger'):
max_num = numx.iinfo(real_dtype).max
min_num = numx.iinfo(real_dtype).min
else:
max_num = numx.finfo(real_dtype).max
min_num = numx.finfo(real_dtype).min
self.M = numx.array([min_num]*n, dtype=real_dtype)
self.m = numx.array([max_num]*n, dtype=real_dtype)
self.lM = 0
self.lm = 0
def __init__(self, n, d, real_dtype="d", integer_dtype="l"):
"""Initializes an object of type 'OneDimensionalHitParade'.
:param n: Number of maxima and minima to remember.
:type n: int
:param d: Minimum gap between two hits.
:type d: int
:param real_dtype: Datatype of sequence items
:type real_dtype: numpy.dtype or str
:param integer_dtype: Datatype of sequence indices
:type integer_dtype: numpy.dtype or str
"""
self.n = int(n)
self.d = int(d)
self.iM = numx.zeros((n, ), dtype=integer_dtype)
self.im = numx.zeros((n, ), dtype=integer_dtype)
real_dtype = numx.dtype(real_dtype)
if real_dtype in mdp.utils.get_dtypes('AllInteger'):
max_num = numx.iinfo(real_dtype).max
min_num = numx.iinfo(real_dtype).min
else:
max_num = numx.finfo(real_dtype).max
min_num = numx.finfo(real_dtype).min
self.M = numx.array([min_num]*n, dtype=real_dtype)
self.m = numx.array([max_num]*n, dtype=real_dtype)
self.lM = 0
self.lm = 0
def __init__(self, n, d, real_dtype="d", integer_dtype="l"):
"""Initializes an object of type 'OneDimensionalHitParade'.
:param n: Number of maxima and minima to remember.
:type n: int
:param d: Minimum gap between two hits.
:type d: int
:param real_dtype: Datatype of sequence items
:type real_dtype: numpy.dtype or str
:param integer_dtype: Datatype of sequence indices
:type integer_dtype: numpy.dtype or str
"""
self.n = int(n)
self.d = int(d)
self.iM = numx.zeros((n, ), dtype=integer_dtype)
self.im = numx.zeros((n, ), dtype=integer_dtype)
real_dtype = numx.dtype(real_dtype)
if real_dtype in mdp.utils.get_dtypes('AllInteger'):
max_num = numx.iinfo(real_dtype).max
min_num = numx.iinfo(real_dtype).min
else:
max_num = numx.finfo(real_dtype).max
min_num = numx.finfo(real_dtype).min
self.M = numx.array([min_num] * n, dtype=real_dtype)
self.m = numx.array([max_num] * n, dtype=real_dtype)
self.lM = 0
self.lm = 0
def _symeig_fake(A, B = None, eigenvectors = True, turbo = "on", range = None,
type = 1, overwrite = False):
"""Solve standard and generalized eigenvalue problem for symmetric
(hermitian) definite positive matrices.
This function is a wrapper of LinearAlgebra.eigenvectors or
numarray.linear_algebra.eigenvectors with an interface compatible with symeig.
Syntax:
w,Z = symeig(A)
w = symeig(A,eigenvectors=0)
w,Z = symeig(A,range=(lo,hi))
w,Z = symeig(A,B,range=(lo,hi))
Inputs:
A -- An N x N matrix.
B -- An N x N matrix.
eigenvectors -- if set return eigenvalues and eigenvectors, otherwise
only eigenvalues
turbo -- not implemented
range -- the tuple (lo,hi) represent the indexes of the smallest and
largest (in ascending order) eigenvalues to be returned.
1 <= lo < hi <= N
if range = None, returns all eigenvalues and eigenvectors.
type -- not implemented, always solve A*x = (lambda)*B*x
overwrite -- not implemented
Outputs:
w -- (selected) eigenvalues in ascending order.
Z -- if range = None, Z contains the matrix of eigenvectors,
normalized as follows:
Z^H * A * Z = lambda and Z^H * B * Z = I
where ^H means conjugate transpose.
if range, an N x M matrix containing the orthonormal
eigenvectors of the matrix A corresponding to the selected
eigenvalues, with the i-th column of Z holding the eigenvector
associated with w[i]. The eigenvectors are normalized as above.
"""
dtype = numx.dtype(_greatest_common_dtype([A, B]))
try:
if B is None:
w, Z = numx_linalg.eigh(A)
else:
# make B the identity matrix
wB, ZB = numx_linalg.eigh(B)
_assert_eigenvalues_real_and_positive(wB, dtype)
ZB = ZB.real / numx.sqrt(wB.real)
# transform A in the new basis: A = ZB^T * A * ZB
A = mdp.utils.mult(mdp.utils.mult(ZB.T, A), ZB)
# diagonalize A
w, ZA = numx_linalg.eigh(A)
Z = mdp.utils.mult(ZB, ZA)
except numx_linalg.LinAlgError, exception:
raise SymeigException(str(exception))
def set_dtype(self, t):
"""Set internal structures' dtype.
Perform sanity checks and then calls ``self._set_dtype(n)``, which
is responsible for setting the internal attribute ``self._dtype``.
Note that subclasses should overwrite `self._set_dtype`
when needed.
"""
if t is None:
return
t = numx.dtype(t)
if (self._dtype is not None) and (self._dtype != t):
errstr = ("dtype is already set to '%s' "
"('%s' given)!" % (t, self.dtype.name))
raise NodeException(errstr)
elif t not in self.get_supported_dtypes():
errstr = ("\ndtype '%s' is not supported.\n"
"Supported dtypes: %s" % (t.name,
[numx.dtype(t).name for t in
self.get_supported_dtypes()]))
raise NodeException(errstr)
else:
self._set_dtype(t)
def _check_props(self, dtype):
"""Check the compatibility of the properties of the internal nodes.
Return the found dtype and check the dimensions.
dtype -- The specified layer dtype.
"""
dtype_list = [] # the dtypes for all the nodes
for i, node in enumerate(self.nodes):
# input_dim for each node must be set
if node.input_dim is None:
err = ("input_dim must be set for every node. " +
"Node #%d (%s) does not comply." % (i, node))
raise mdp.NodeException(err)
if node.dtype is not None:
dtype_list.append(node.dtype)
# check that the dtype is None or the same for every node
nodes_dtype = None
nodes_dtypes = set(dtype_list)
nodes_dtypes.discard(None)
if len(nodes_dtypes) > 1:
err = ("All nodes must have the same dtype (found: %s)." %
nodes_dtypes)
raise mdp.NodeException(err)
elif len(nodes_dtypes) == 1:
nodes_dtype = list(nodes_dtypes)[0]
# check that the nodes dtype matches the specified dtype
if nodes_dtype and dtype:
if not numx.dtype(nodes_dtype) == numx.dtype(dtype):
err = (
"Cannot set dtype to %s: " % numx.dtype(nodes_dtype).name +
"an internal node requires %s" % numx.dtype(dtype).name)
raise mdp.NodeException(err)
elif nodes_dtype and not dtype:
dtype = nodes_dtype
return dtype
def _check_props(self, dtype):
"""Check the compatibility of the properties of the internal nodes.
Return the found dtype and check the dimensions.
dtype -- The specified layer dtype.
"""
dtype_list = [] # the dtypes for all the nodes
for i, node in enumerate(self.nodes):
# input_dim for each node must be set
if node.input_dim is None:
err = ("input_dim must be set for every node. " +
"Node #%d (%s) does not comply." % (i, node))
raise mdp.NodeException(err)
if node.dtype is not None:
dtype_list.append(node.dtype)
# check that the dtype is None or the same for every node
nodes_dtype = None
nodes_dtypes = set(dtype_list)
nodes_dtypes.discard(None)
if len(nodes_dtypes) > 1:
err = ("All nodes must have the same dtype (found: %s)." %
nodes_dtypes)
raise mdp.NodeException(err)
elif len(nodes_dtypes) == 1:
nodes_dtype = list(nodes_dtypes)[0]
# check that the nodes dtype matches the specified dtype
if nodes_dtype and dtype:
if not numx.dtype(nodes_dtype) == numx.dtype(dtype):
err = ("Cannot set dtype to %s: " %
numx.dtype(nodes_dtype).name +
"an internal node requires %s" % numx.dtype(dtype).name)
raise mdp.NodeException(err)
elif nodes_dtype and not dtype:
dtype = nodes_dtype
return dtype
def _symeig_fake(A,
B=None,
eigenvectors=True,
turbo="on",
range=None,
type=1,
overwrite=False):
"""Solve standard and generalized eigenvalue problem for symmetric
(hermitian) definite positive matrices.
This function is a wrapper of LinearAlgebra.eigenvectors or
numarray.linear_algebra.eigenvectors with an interface compatible with symeig.
Syntax:
w,Z = symeig(A)
w = symeig(A,eigenvectors=0)
w,Z = symeig(A,range=(lo,hi))
w,Z = symeig(A,B,range=(lo,hi))
Inputs:
A -- An N x N matrix.
B -- An N x N matrix.
eigenvectors -- if set return eigenvalues and eigenvectors, otherwise
only eigenvalues
turbo -- not implemented
range -- the tuple (lo,hi) represent the indexes of the smallest and
largest (in ascending order) eigenvalues to be returned.
1 <= lo < hi <= N
if range = None, returns all eigenvalues and eigenvectors.
type -- not implemented, always solve A*x = (lambda)*B*x
overwrite -- not implemented
Outputs:
w -- (selected) eigenvalues in ascending order.
Z -- if range = None, Z contains the matrix of eigenvectors,
normalized as follows:
Z^H * A * Z = lambda and Z^H * B * Z = I
where ^H means conjugate transpose.
if range, an N x M matrix containing the orthonormal
eigenvectors of the matrix A corresponding to the selected
eigenvalues, with the i-th column of Z holding the eigenvector
associated with w[i]. The eigenvectors are normalized as above.
"""
dtype = numx.dtype(_greatest_common_dtype([A, B]))
try:
if B is None:
w, Z = numx_linalg.eigh(A)
else:
# make B the identity matrix
wB, ZB = numx_linalg.eigh(B)
_assert_eigenvalues_real_and_positive(wB, dtype)
ZB = ZB.real / numx.sqrt(wB.real)
# transform A in the new basis: A = ZB^T * A * ZB
A = mdp.utils.mult(mdp.utils.mult(ZB.T, A), ZB)
# diagonalize A
w, ZA = numx_linalg.eigh(A)
Z = mdp.utils.mult(ZB, ZA)
except numx_linalg.LinAlgError, exception:
raise SymeigException(str(exception))
def _set_dtype(self, t):
t = numx.dtype(t)
if t not in self.get_supported_dtypes():
raise NodeException('dtype %s not among supported dtypes (%s)'
% (str(t), self.get_supported_dtypes()))
self._dtype = t
def _symeig_fake(A, B = None, eigenvectors = True, turbo = "on", range = None,
type = 1, overwrite = False):
"""Solve standard and generalized eigenvalue problem for symmetric
(hermitian) definite positive matrices.
This function is a wrapper of LinearAlgebra.eigenvectors or
numarray.linear_algebra.eigenvectors with an interface compatible with symeig.
Syntax:
w,Z = symeig(A)
w = symeig(A,eigenvectors=0)
w,Z = symeig(A,range=(lo,hi))
w,Z = symeig(A,B,range=(lo,hi))
Inputs:
A -- An N x N matrix.
B -- An N x N matrix.
eigenvectors -- if set return eigenvalues and eigenvectors, otherwise
only eigenvalues
turbo -- not implemented
range -- the tuple (lo,hi) represent the indexes of the smallest and
largest (in ascending order) eigenvalues to be returned.
1 <= lo < hi <= N
if range = None, returns all eigenvalues and eigenvectors.
type -- not implemented, always solve A*x = (lambda)*B*x
overwrite -- not implemented
Outputs:
w -- (selected) eigenvalues in ascending order.
Z -- if range = None, Z contains the matrix of eigenvectors,
normalized as follows:
Z^H * A * Z = lambda and Z^H * B * Z = I
where ^H means conjugate transpose.
if range, an N x M matrix containing the orthonormal
eigenvectors of the matrix A corresponding to the selected
eigenvalues, with the i-th column of Z holding the eigenvector
associated with w[i]. The eigenvectors are normalized as above.
"""
dtype = numx.dtype(_greatest_common_dtype([A, B]))
try:
if B is None:
w, Z = numx_linalg.eigh(A)
else:
# make B the identity matrix
wB, ZB = numx_linalg.eigh(B)
_assert_eigenvalues_real(wB, dtype)
if wB.real.min() < 0:
# If we proceeded with negative values here, this would let some
# NumPy or SciPy versions cause nan values in the results.
# Such nan values would go through silently (or only with a warning,
# i.e. RuntimeWarning: invalid value encountered in sqrt)
# and cause hard to find issues later in user code outside mdp.
err = "Got negative eigenvalues: %s" % str(wB)
raise SymeigException(err)
ZB = old_div(ZB.real, numx.sqrt(wB.real))
# transform A in the new basis: A = ZB^T * A * ZB
A = mdp.utils.mult(mdp.utils.mult(ZB.T, A), ZB)
# diagonalize A
w, ZA = numx_linalg.eigh(A)
Z = mdp.utils.mult(ZB, ZA)
except numx_linalg.LinAlgError as exception:
raise SymeigException(str(exception))
_assert_eigenvalues_real(w, dtype)
# Negative eigenvalues at this stage will be checked and handled by the caller.
w = w.real
Z = Z.real
idx = w.argsort()
w = w.take(idx)
Z = Z.take(idx, axis=1)
# sanitize range:
n = A.shape[0]
if range is not None:
lo, hi = range
if lo < 1:
lo = 1
if lo > n:
lo = n
if hi > n:
hi = n
if lo > hi:
lo, hi = hi, lo
Z = Z[:, lo-1:hi]
w = w[lo-1:hi]
# the final call to refcast is necessary because of a bug in the casting
# behavior of Numeric and numarray: eigenvector does not wrap the LAPACK
# single precision routines
if eigenvectors:
return mdp.utils.refcast(w, dtype), mdp.utils.refcast(Z, dtype)
else:
return mdp.utils.refcast(w, dtype)
def _symeig_fake(A,
B=None,
eigenvectors=True,
turbo="on",
range=None,
type=1,
overwrite=False):
"""Solve standard and generalized eigenvalue problem for symmetric
(hermitian) definite positive matrices.
This function is a wrapper of LinearAlgebra.eigenvectors or
numarray.linear_algebra.eigenvectors with an interface compatible with symeig.
Syntax:
w,Z = symeig(A)
w = symeig(A,eigenvectors=0)
w,Z = symeig(A,range=(lo,hi))
w,Z = symeig(A,B,range=(lo,hi))
Inputs:
A -- An N x N matrix.
B -- An N x N matrix.
eigenvectors -- if set return eigenvalues and eigenvectors, otherwise
only eigenvalues
turbo -- not implemented
range -- the tuple (lo,hi) represent the indexes of the smallest and
largest (in ascending order) eigenvalues to be returned.
1 <= lo < hi <= N
if range = None, returns all eigenvalues and eigenvectors.
type -- not implemented, always solve A*x = (lambda)*B*x
overwrite -- not implemented
Outputs:
w -- (selected) eigenvalues in ascending order.
Z -- if range = None, Z contains the matrix of eigenvectors,
normalized as follows:
Z^H * A * Z = lambda and Z^H * B * Z = I
where ^H means conjugate transpose.
if range, an N x M matrix containing the orthonormal
eigenvectors of the matrix A corresponding to the selected
eigenvalues, with the i-th column of Z holding the eigenvector
associated with w[i]. The eigenvectors are normalized as above.
"""
dtype = numx.dtype(_greatest_common_dtype([A, B]))
try:
if B is None:
w, Z = numx_linalg.eigh(A)
else:
# make B the identity matrix
wB, ZB = numx_linalg.eigh(B)
_assert_eigenvalues_real_and_positive(wB, dtype)
ZB = old_div(ZB.real, numx.sqrt(wB.real))
# transform A in the new basis: A = ZB^T * A * ZB
A = mdp.utils.mult(mdp.utils.mult(ZB.T, A), ZB)
# diagonalize A
w, ZA = numx_linalg.eigh(A)
Z = mdp.utils.mult(ZB, ZA)
except numx_linalg.LinAlgError as exception:
raise SymeigException(str(exception))
_assert_eigenvalues_real_and_positive(w, dtype)
w = w.real
Z = Z.real
idx = w.argsort()
w = w.take(idx)
Z = Z.take(idx, axis=1)
# sanitize range:
n = A.shape[0]
if range is not None:
lo, hi = range
if lo < 1:
lo = 1
if lo > n:
lo = n
if hi > n:
hi = n
if lo > hi:
lo, hi = hi, lo
Z = Z[:, lo - 1:hi]
w = w[lo - 1:hi]
# the final call to refcast is necessary because of a bug in the casting
# behavior of Numeric and numarray: eigenvector does not wrap the LAPACK
# single precision routines
if eigenvectors:
return mdp.utils.refcast(w, dtype), mdp.utils.refcast(Z, dtype)
else:
return mdp.utils.refcast(w, dtype)
def assert_type_equal(act, des):
assert act == numx.dtype(des), \
'dtype mismatch: "%s" (should be "%s") '%(act,des)
import time
import itertools
from functools import wraps
import py.test
import mdp
from mdp import numx, numx_rand, numx_fft, utils
from numpy.testing import (assert_array_equal, assert_array_almost_equal,
assert_equal, assert_almost_equal)
mean = numx.mean
std = numx.std
normal = mdp.numx_rand.normal
uniform = mdp.numx_rand.random
testtypes = [numx.dtype('d'), numx.dtype('f')]
testtypeschar = [t.char for t in testtypes]
testdecimals = {testtypes[0]: 12, testtypes[1]: 6}
decimal = 7
mult = mdp.utils.mult
#### test tools
def assert_array_almost_equal_diff(x,y,digits,err_msg=''):
x,y = numx.asarray(x), numx.asarray(y)
msg = '\nArrays are not almost equal'
assert 0 in [len(numx.shape(x)),len(numx.shape(y))] \
or (len(numx.shape(x))==len(numx.shape(y)) and \
numx.alltrue(numx.equal(numx.shape(x),numx.shape(y)))),\
msg + ' (shapes %s, %s mismatch):\n\t' \
% (numx.shape(x),numx.shape(y)) + err_msg
maxdiff = max(numx.ravel(abs(x-y)))/\
def assert_type_equal(act, des):
assert act == numx.dtype(des), \
'dtype mismatch: "%s" (should be "%s") '%(act,des)
import time
import itertools
from functools import wraps
import py.test
import mdp
from mdp import numx, numx_rand, numx_fft, numx_linalg, utils
from numpy.testing import (assert_array_equal, assert_array_almost_equal,
assert_equal, assert_almost_equal)
mean = numx.mean
std = numx.std
normal = mdp.numx_rand.normal
uniform = mdp.numx_rand.random
testtypes = [numx.dtype('d'), numx.dtype('f')]
testtypeschar = [t.char for t in testtypes]
testdecimals = {testtypes[0]: 12, testtypes[1]: 6}
decimal = 7
mult = mdp.utils.mult
#### test tools
def assert_array_almost_equal_diff(x, y, digits, err_msg=''):
x, y = numx.asarray(x), numx.asarray(y)
msg = '\nArrays are not almost equal'
assert 0 in [len(numx.shape(x)),len(numx.shape(y))] \
or (len(numx.shape(x))==len(numx.shape(y)) and \
numx.alltrue(numx.equal(numx.shape(x),numx.shape(y)))),\
msg + ' (shapes %s, %s mismatch):\n\t' \
% (numx.shape(x),numx.shape(y)) + err_msg
