def mpmath_check(min_ver):
if mpmath is None:
return dec.skipif(True, "mpmath library is not present")
def try_int(v):
try: return int(v)
except ValueError: return v
def get_version(v):
return map(try_int, re.split('[^0-9]', v))
return dec.skipif(get_version(min_ver) > get_version(mpmath.__version__),
"mpmath %s required" % min_ver)
class TestScalarPEP3118(object):
skip_if_no_buffer_interface = dec.skipif(sys.version_info.major < 3,
"scalars do not implement buffer interface in Python 2")
@skip_if_no_buffer_interface
def test_scalar_match_array(self):
for scalar, _ in scalars_and_codes:
x = scalar()
a = np.array([], dtype=np.dtype(scalar))
mv_x = memoryview(x)
mv_a = memoryview(a)
assert_equal(mv_x.format, mv_a.format)
@skip_if_no_buffer_interface
def test_scalar_dim(self):
for scalar, _ in scalars_and_codes:
x = scalar()
mv_x = memoryview(x)
assert_equal(mv_x.itemsize, np.dtype(scalar).itemsize)
assert_equal(mv_x.ndim, 0)
assert_equal(mv_x.shape, ())
assert_equal(mv_x.strides, ())
assert_equal(mv_x.suboffsets, ())
@skip_if_no_buffer_interface
def test_scalar_known_code(self):
for scalar, code in scalars_and_codes:
x = scalar()
mv_x = memoryview(x)
assert_equal(mv_x.format, code)
@skip_if_no_buffer_interface
def test_void_scalar_structured_data(self):
dt = np.dtype([('name', np.unicode_, 16), ('grades', np.float64, (2,))])
x = np.array(('ndarray_scalar', (1.2, 3.0)), dtype=dt)[()]
assert_(isinstance(x, np.void))
mv_x = memoryview(x)
expected_size = 16 * np.dtype((np.unicode_, 1)).itemsize
expected_size += 2 * np.dtype((np.float64, 1)).itemsize
assert_equal(mv_x.itemsize, expected_size)
assert_equal(mv_x.ndim, 0)
assert_equal(mv_x.shape, ())
assert_equal(mv_x.strides, ())
assert_equal(mv_x.suboffsets, ())
# check scalar format string against ndarray format string
a = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt)
assert_(isinstance(a, np.ndarray))
mv_a = memoryview(a)
assert_equal(mv_x.itemsize, mv_a.itemsize)
assert_equal(mv_x.format, mv_a.format)
def nonfunctional_tooslow(func):
return dec.skipif(True, " Test not yet functional (too slow), needs more work.")(func)
import sys
import os
import stat
import tempfile
from distutils.dir_util import remove_tree
from numpy.testing import TestCase, assert_, dec
from numpy.testing.noseclasses import KnownFailureTest
from scipy.weave import catalog
from weave_test_utils import clear_temp_catalog, restore_temp_catalog, \
empty_temp_dir, cleanup_temp_dir
skip_on_windows = dec.skipif(sys.platform == 'win32',
"Test works only on posix")
def samefile(a, b):
try:
return os.path.samefile(a, b)
except AttributeError:
return os.path.realpath(a) == os.path.realpath(b)
class TestIntermediateDir(TestCase):
"""
Tests for intermediate dir (store of .cpp and .o during builds).
These tests test whether intermediate dir is safe. If it's not,
new one should be created.
"""
dire.bench()
If you have doctests enabled by default in nose (with a noserc file or
environment variable), and you have a numpy version <= 1.6.1, this will also run
the doctests, let's hope they pass.
"""
import numpy as np
from numpy.random import randn
from ..vec_val_sum import vec_val_vect
from numpy.testing import measure, dec
try:
np.einsum
except AttributeError:
with_einsum = dec.skipif(True, "Need einsum for benchmark")
else:
with_einsum = lambda f : f
@with_einsum
def bench_vec_val_vect():
# nosetests -s --match '(?:^|[\\b_\\.//-])[Bb]ench'
repeat = 100
shape = (100, 100)
evecs, evals = randn(*(shape + (3, 3))), randn(*(shape + (3,)))
etime = measure("np.einsum('...ij,...j,...kj->...ik', evecs, evals, evecs)",
repeat)
vtime = measure("vec_val_vect(evecs, evals)", repeat)
print("einsum %4.2f; vec_val_vect %4.2f" % (etime, vtime))
import numpy as np
from scipy.special import genlaguerre, gamma
from ...data import get_gtab_taiwan_dsi
from ..shore import ShoreModel
from ...sims.voxel import MultiTensor
from numpy.testing import (assert_almost_equal, assert_equal, run_module_suite,
dec)
from ...utils.optpkg import optional_package
cvxopt, have_cvxopt, _ = optional_package("cvxopt")
needs_cvxopt = dec.skipif(not have_cvxopt)
# Object to hold module global data
class _C(object):
pass
data = _C()
def setup():
data.gtab = get_gtab_taiwan_dsi()
data.mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003,
0.0003]))
data.angl = [(0, 0), (60, 0)]
import numpy as np
import itertools
from ..externals.six import BytesIO
from numpy.testing import assert_array_equal, assert_array_almost_equal, dec
# Decorator to skip tests requiring save / load if scipy not available for mat
# files
try:
import scipy
except ImportError:
have_scipy = False
else:
have_scipy = True
scipy_skip = dec.skipif(not have_scipy, 'scipy not available')
from ..spm99analyze import (Spm99AnalyzeHeader, Spm99AnalyzeImage,
HeaderTypeError)
from ..casting import type_info, shared_range
from ..volumeutils import apply_read_scaling, _dt_min_max
from ..spatialimages import supported_np_types, HeaderDataError
from nose.tools import assert_true, assert_false, assert_equal, assert_raises
from ..testing import assert_allclose_safely
from . import test_analyze
from .test_helpers import (bytesio_round_trip, bytesio_filemap, bz2_mio_error)
FLOAT_TYPES = np.sctypes['float']
def nonfunctional_tooslow(func):
return dec.skipif(
True, " Test not yet functional (too slow), needs more work.")(func)
def if_datasource(ds, msg):
try:
ds.get_filename()
except DataError:
return dec.skipif(True, msg)
return lambda f: f
def skip_func(func):
return dec.skipif(True, msg)(func)
from scipy.sparse import csc_matrix, spdiags, SparseEfficiencyWarning
from scipy.sparse.linalg import linsolve
warnings.simplefilter('ignore',SparseEfficiencyWarning)
import numpy as np
try:
import scipy.sparse.linalg.dsolve.umfpack as um
except (ImportError, AttributeError):
_have_umfpack = False
else:
_have_umfpack = um.umfpack._um is not None
# Allow disabling of nose tests if umfpack not present
# See end of file for application
_umfpack_skip = dec.skipif(not _have_umfpack,
'UMFPACK appears not to be compiled')
class TestSolvers(TestCase):
"""Tests inverting a sparse linear system"""
def test_solve_complex_without_umfpack(self):
"""Solve: single precision complex"""
linsolve.use_solver( useUmfpack = False )
a = self.a.astype('F')
b = self.b
x = linsolve.spsolve(a, b)
#print x
#print "Error: ", a*x-b
assert_array_almost_equal(a*x, b, decimal=4)
pass
import numpy as np
from numpy.testing import assert_, assert_raises, dec
import scipy.io
from scipy._lib._tmpdirs import tempdir
import scipy.sparse
# Bit of a hack to keep the test runner from exploding in Python 2.7.
# FileNotFoundError was added in Python 3.3.
if sys.version_info < (3, 3):
FileNotFoundError = IOError
skip_dec = dec.skipif(
sys.version_info < (3, 6),
'Passing path-like objects to IO functions requires Python >= 3.6')
class TestPaths(object):
data = np.arange(5)
@skip_dec
def test_savemat(self):
with tempdir() as temp_dir:
path = Path(temp_dir) / 'data.mat'
scipy.io.savemat(path, {'data': self.data})
assert_(path.is_file())
@skip_dec
def test_loadmat(self):
""" Testing doctest markup tests """ import sys from ..py3builder import doctest_markup, byter from numpy.testing import (assert_array_almost_equal, assert_array_equal, dec) from nose.tools import assert_true, assert_equal, assert_raises is_2 = sys.version_info[0] < 3 skip42 = dec.skipif(is_2) # Tell 23dt processing to pass the rest of this file unchanged. We don't want # the processor to mess up the example string #23dt skip rest IN_TXT = """ Anonymous lines, also blanks As all that is empty, use entropy, and endure # Comment, unchanged #23dt comment not processed without doctest marker >>> #23dthere: no whitespace; comment not recognized even as error >>>#23dt nor without preceding whitespace >>> #23dt not correct syntax creates error >>> #23dt novar: 'undefined variable creates error' >>> #23dt here: 'OK'
from __future__ import division, print_function, absolute_import
from numpy.testing import dec
try:
eval('a @ b')
has_matmul = True
except:
has_matmul = False
if has_matmul:
from jsonctmctree.tests.check_bad_syntax import *
from jsonctmctree.tests.check_good_syntax import *
dec.skipif(True, 'matmul is unavailable')
def test_matmul_stub():
pass
""" Testing doctest markup tests """ import sys from ..py3builder import doctest_markup, byter from numpy.testing import (assert_array_almost_equal, assert_array_equal, dec) from nose.tools import assert_true, assert_equal, assert_raises is_2 = sys.version_info[0] < 3 skip42 = dec.skipif(is_2) # Tell 23dt processing to pass the rest of this file unchanged. We don't want # the processor to mess up the example string #23dt skip rest IN_TXT = """ Anonymous lines, also blanks As all that is empty, use entropy, and endure # Comment, unchanged #23dt comment not processed without doctest marker >>> #23dthere: no whitespace; comment not recognized even as error >>>#23dt nor without preceding whitespace >>> #23dt not correct syntax creates error >>> #23dt novar: 'undefined variable creates error' >>> #23dt here: 'OK'
def check_version(module, min_ver):
if type(module) == MissingModule:
return dec.skipif(True, "{} is not installed".format(module.name))
return dec.skipif(LooseVersion(module.__version__) < LooseVersion(min_ver),
"{} version >= {} required".format(module.__name__, min_ver))
import numpy as np
from numpy.testing import assert_, assert_equal, \
dec, decorate_methods, TestCase, run_module_suite
from scipy import misc
try:
import PIL.Image
except ImportError:
_have_PIL = False
else:
_have_PIL = True
# Function / method decorator for skipping PIL tests on import failure
_pilskip = dec.skipif(not _have_PIL, 'Need to import PIL for this test')
datapath = os.path.dirname(__file__)
class TestPILUtil(TestCase):
def test_imresize(self):
im = np.random.random((10, 20))
for T in np.sctypes['float'] + [float]:
# 1.1 rounds to below 1.1 for float16, 1.101 works
im1 = misc.imresize(im, T(1.101))
assert_equal(im1.shape, (11, 22))
def test_imresize2(self):
im = np.random.random((20, 30))
im2 = misc.imresize(im, (30, 40), interp='bicubic')
import dipy.reconst as dire
dire.bench()
If you have doctests enabled by default in nose (with a noserc file or
environment variable), and you have a numpy version <= 1.6.1, this will also
run the doctests, let's hope they pass.
"""
import numpy as np
from numpy.random import randn
from dipy.reconst.vec_val_sum import vec_val_vect
from numpy.testing import measure, dec
try:
np.einsum
except AttributeError:
with_einsum = dec.skipif(True, "Need einsum for benchmark")
else:
def with_einsum(f): return f
@with_einsum
def bench_vec_val_vect():
# nosetests -s --match '(?:^|[\\b_\\.//-])[Bb]ench'
repeat = 100
etime = measure("np.einsum('...ij,...j,...kj->...ik', evecs, evals, evecs)",
repeat)
vtime = measure("vec_val_vect(evecs, evals)", repeat)
print("einsum %4.2f; vec_val_vect %4.2f" % (etime, vtime))
from __future__ import division, print_function, absolute_import
import sys
import numpy as np
from numpy.testing import assert_, assert_allclose, dec
import scipy.special.orthogonal as orth
from scipy.lib._version import NumpyVersion
from scipy.special._testutils import FuncData
# Early Numpy versions have bugs in ufunc keyword argument parsing
numpy_version_requirement = dec.skipif(
NumpyVersion(np.__version__) < '1.6.0' and sys.version_info[0] >= 3,
"Bug in Numpy < 1.6 on Python 3")
def test_eval_chebyt():
n = np.arange(0, 10000, 7)
x = 2*np.random.rand() - 1
v1 = np.cos(n*np.arccos(x))
v2 = orth.eval_chebyt(n, x)
assert_(np.allclose(v1, v2, rtol=1e-15))
def test_eval_genlaguerre_restriction():
# check it returns nan for alpha <= -1
assert_(np.isnan(orth.eval_genlaguerre(0, -1, 0)))
assert_(np.isnan(orth.eval_genlaguerre(0.1, -1, 0)))
from statsmodels.compat.python import PY3
import os
from statsmodels.datasets import get_rdataset, webuse, check_internet
from numpy.testing import assert_, assert_array_equal, dec
cur_dir = os.path.dirname(os.path.abspath(__file__))
dec.skipif(PY3, 'Not testable on Python 3.x')
def test_get_rdataset():
# smoke test
if not PY3:
#NOTE: there's no way to test both since the cached files were
#created with Python 2.x, they're strings, but Python 3 expects
#bytes and the index file path is hard-coded so both can't live
#side by side
duncan = get_rdataset("Duncan", "car", cache=cur_dir)
assert_(duncan.from_cache)
#internet_available = check_internet()
#@dec.skipif(not internet_available)
def t_est_webuse():
# test copied and adjusted from iolib/tests/test_foreign
from statsmodels.iolib.tests.results.macrodata import macrodata_result as res2
#base_gh = "http://github.com/statsmodels/statsmodels/raw/master/statsmodels/datasets/macrodata/"
base_gh = "http://www.statsmodels.org/devel/_static/"
res1 = webuse('macrodata', baseurl=base_gh, as_df=False)
assert_array_equal(res1 == res2, True)
#@dec.skipif(not internet_available)
def t_est_webuse_pandas():
# test copied and adjusted from iolib/tests/test_foreign
DATA_SDIR = 'fsaverage'
have_freesurfer = False
if 'SUBJECTS_DIR' in os.environ:
# May have Freesurfer installed with data
data_path = pjoin(os.environ["SUBJECTS_DIR"], DATA_SDIR)
have_freesurfer = isdir(data_path)
else:
# May have nibabel test data submodule checked out
nib_data = get_nibabel_data()
if nib_data != '':
data_path = pjoin(nib_data, 'nitest-freesurfer', DATA_SDIR)
have_freesurfer = isdir(data_path)
freesurfer_test = dec.skipif(
not have_freesurfer,
'cannot find freesurfer {0} directory'.format(DATA_SDIR))
def _hash_file_content(fname):
hasher = hashlib.md5()
with open(fname, 'rb') as afile:
buf = afile.read()
hasher.update(buf)
return hasher.hexdigest()
@freesurfer_test
def test_geometry():
"""Test IO of .surf"""
surf_path = pjoin(data_path, "surf", "%s.%s" % ("lh", "inflated"))
from statsmodels.compat.python import PY3
import os
from statsmodels.datasets import get_rdataset, webuse, check_internet
from numpy.testing import assert_, assert_array_equal, dec
cur_dir = os.path.dirname(os.path.abspath(__file__))
dec.skipif(PY3, 'Not testable on Python 3.x')
def test_get_rdataset():
# smoke test
if not PY3:
#NOTE: there's no way to test both since the cached files were
#created with Python 2.x, they're strings, but Python 3 expects
#bytes and the index file path is hard-coded so both can't live
#side by side
duncan = get_rdataset("Duncan", "car", cache=cur_dir)
assert_(duncan.from_cache)
#internet_available = check_internet()
#@dec.skipif(not internet_available)
def t_est_webuse():
# test copied and adjusted from iolib/tests/test_foreign
from statsmodels.iolib.tests.results.macrodata import macrodata_result as res2
#base_gh = "http://github.com/statsmodels/statsmodels/raw/master/statsmodels/datasets/macrodata/"
base_gh = "http://www.statsmodels.org/devel/_static/"
res1 = webuse('macrodata', baseurl=base_gh, as_df=False)
assert_array_equal(res1 == res2, True)
#@dec.skipif(not internet_available)
def t_est_webuse_pandas():
# test copied and adjusted from iolib/tests/test_foreign
DATA_SDIR = 'fsaverage'
have_freesurfer = False
if 'SUBJECTS_DIR' in os.environ:
# May have Freesurfer installed with data
data_path = pjoin(os.environ["SUBJECTS_DIR"], DATA_SDIR)
have_freesurfer = isdir(data_path)
else:
# May have nibabel test data submodule checked out
nib_data = get_nibabel_data()
if nib_data != '':
data_path = pjoin(nib_data, 'nitest-freesurfer', DATA_SDIR)
have_freesurfer = isdir(data_path)
freesurfer_test = dec.skipif(
not have_freesurfer,
'cannot find freesurfer {0} directory'.format(DATA_SDIR))
def _hash_file_content(fname):
hasher = hashlib.md5()
with open(fname, 'rb') as afile:
buf = afile.read()
hasher.update(buf)
return hasher.hexdigest()
@freesurfer_test
def test_geometry():
"""Test IO of .surf"""
surf_path = pjoin(data_path, "surf", "%s.%s" % ("lh", "inflated"))
import re
import glob
import string
import stat
import tempfile
from distutils.dir_util import remove_tree
from numpy.testing import TestCase, assert_, dec, run_module_suite
from numpy.testing.noseclasses import KnownFailureTest
from weave import catalog
from weave_test_utils import clear_temp_catalog, restore_temp_catalog, empty_temp_dir, cleanup_temp_dir
skip_on_windows = dec.skipif(sys.platform == "win32", "Test works only on posix")
def samefile(a, b):
try:
return os.path.samefile(a, b)
except AttributeError:
return os.path.realpath(a) == os.path.realpath(b)
class TestIntermediateDir(TestCase):
"""
Tests for intermediate dir (store of .cpp and .o during builds).
These tests test whether intermediate dir is safe. If it's not,
new one should be created.
"""
def mpmath_check(min_ver):
if mpmath is None:
return dec.skipif(True, "mpmath is not installed")
return dec.skipif(
LooseVersion(mpmath.__version__) < LooseVersion(min_ver),
"mpmath version >= %s required" % min_ver)
from scipy.special import genlaguerre, gamma
from dipy.data import get_gtab_taiwan_dsi
from dipy.reconst.shore import ShoreModel
from dipy.sims.voxel import MultiTensor
from numpy.testing import (assert_almost_equal,
assert_equal,
run_module_suite,
dec)
from dipy.utils.optpkg import optional_package
cvxpy, have_cvxpy, _ = optional_package("cvxpy")
needs_cvxpy = dec.skipif(not have_cvxpy)
# Object to hold module global data
class _C(object):
pass
data = _C()
def setup():
data.gtab = get_gtab_taiwan_dsi()
data.mevals = np.array(([0.0015, 0.0003, 0.0003],
[0.0015, 0.0003, 0.0003]))
data.angl = [(0, 0), (60, 0)]
data.S, sticks = MultiTensor(
data.gtab, data.mevals, S0=100.0, angles=data.angl,
from __future__ import division, print_function, absolute_import
from distutils.version import LooseVersion
import sys
import numpy as np
from numpy.testing import assert_, assert_allclose, dec
import scipy.special.orthogonal as orth
from scipy.special._testutils import FuncData
# Early Numpy versions have bugs in ufunc keyword argument parsing
numpy_version_requirement = dec.skipif(
LooseVersion(np.version.version) < LooseVersion('1.6')
and sys.version_info[0] >= 3,
"Bug in Numpy < 1.6 on Python 3")
def test_eval_chebyt():
n = np.arange(0, 10000, 7)
x = 2*np.random.rand() - 1
v1 = np.cos(n*np.arccos(x))
v2 = orth.eval_chebyt(n, x)
assert_(np.allclose(v1, v2, rtol=1e-15))
def test_warnings():
# ticket 1334
olderr = np.seterr(all='raise')
try:
# these should raise no fp warnings
orth.eval_legendre(1, 0)
from scipy.sparse import csc_matrix, spdiags, SparseEfficiencyWarning
from scipy.sparse.linalg import linsolve
warnings.simplefilter('ignore',SparseEfficiencyWarning)
import numpy as np
try:
import scipy.sparse.linalg.dsolve.umfpack as um
except (ImportError, AttributeError):
_have_umfpack = False
else:
_have_umfpack = um.umfpack._um is not None
# Allow disabling of nose tests if umfpack not present
# See end of file for application
_umfpack_skip = dec.skipif(not _have_umfpack,
'UMFPACK appears not to be compiled')
class _DeprecationAccept:
def setUp(self):
self.mgr = WarningManager()
self.mgr.__enter__()
warnings.simplefilter("ignore", DeprecationWarning)
def tearDown(self):
self.mgr.__exit__()
class TestSolvers(_DeprecationAccept):
"""Tests inverting a sparse linear system"""
def mpmath_check(min_ver):
if mpmath is None:
return dec.skipif(True, "mpmath is not installed")
return dec.skipif(LooseVersion(mpmath.__version__) < LooseVersion(min_ver),
"mpmath version >= %s required" % min_ver)
from __future__ import division, print_function, absolute_import
from numpy.testing import dec
try:
eval('a @ b')
has_matmul = True
except:
has_matmul = False
if has_matmul:
from jsonctmctree.tests.check_bad_syntax import *
from jsonctmctree.tests.check_good_syntax import *
dec.skipif(True, 'matmul is unavailable')
def test_matmul_stub():
pass
def platform_skip(func):
return dec.skipif(skip_complex_tests,
"Numpy is using complex functions (e.g. sqrt) provided by your"
"platform's C library. However, they do not seem to behave according"
"to C99 -- so C99 tests are skipped.")(func)
def skip_func(func):
return dec.skipif(True, msg)(func)
import os.path
import numpy as np
from numpy.testing import assert_, assert_equal, \
dec, decorate_methods, TestCase, run_module_suite
try:
import PIL.Image
except ImportError:
_have_PIL = False
else:
_have_PIL = True
import scipy.misc.pilutil as pilutil
# Function / method decorator for skipping PIL tests on import failure
_pilskip = dec.skipif(not _have_PIL, 'Need to import PIL for this test')
datapath = os.path.dirname(__file__)
class TestPILUtil(TestCase):
def test_imresize(self):
im = np.random.random((10,20))
for T in np.sctypes['float'] + [float]:
im1 = pilutil.imresize(im,T(1.1))
assert_equal(im1.shape,(11,22))
def test_imresize2(self):
im = np.random.random((20,30))
im2 = pilutil.imresize(im, (30,40), interp='bicubic')
assert_equal(im2.shape, (30,40))
def if_datasource(ds, msg):
try:
ds.get_filename()
except DataError:
return dec.skipif(True, msg)
return lambda f: f
def platform_skip(func):
return dec.skipif(skip_complex_tests,
"Numpy is using complex functions (e.g. sqrt) provided by your"
"platform's C library. However, they do not seem to behave according"
"to C99 -- so C99 tests are skipped.")(func)
"""
import warnings
import numpy as np
from numpy.testing import (assert_array_equal, assert_array_almost_equal,
assert_raises, assert_array_less, run_module_suite,
assert_, assert_equal, dec)
from dipy.testing import assert_greater_equal
from dipy.reconst.ivim import ivim_prediction, IvimModel
from dipy.core.gradients import gradient_table, generate_bvecs
from dipy.sims.voxel import multi_tensor
from dipy.utils.optpkg import optional_package
cvxpy, have_cvxpy, _ = optional_package("cvxpy")
needs_cvxpy = dec.skipif(not have_cvxpy)
def setup_module():
global gtab, ivim_fit_single, ivim_model_LM, data_single, params_LM, \
data_multi, ivim_params_LM, D_star, D, f, S0, gtab_with_multiple_b0, \
noisy_single, mevals, gtab_no_b0, ivim_fit_multi, ivim_model_VP, \
f_VP, D_star_VP, D_VP, params_VP
# Let us generate some data for testing.
bvals = np.array([0., 10., 20., 30., 40., 60., 80., 100.,
120., 140., 160., 180., 200., 300., 400.,
500., 600., 700., 800., 900., 1000.])
N = len(bvals)
bvecs = generate_bvecs(N)
gtab = gradient_table(bvals, bvecs.T, b0_threshold=0)
import numpy as np
from ..py3k import BytesIO
from numpy.testing import assert_array_equal, assert_array_almost_equal, dec
# Decorator to skip tests requiring save / load if scipy not available for mat
# files
try:
import scipy
except ImportError:
have_scipy = False
else:
have_scipy = True
scipy_skip = dec.skipif(not have_scipy, 'scipy not available')
from ..spm99analyze import (Spm99AnalyzeHeader, Spm99AnalyzeImage,
HeaderTypeError)
from ..testing import (assert_equal, assert_true, assert_false, assert_raises)
from . import test_analyze
from .test_analyze import _log_chk
class TestSpm99AnalyzeHeader(test_analyze.TestAnalyzeHeader):
header_class = Spm99AnalyzeHeader
def test_empty(self):
super(TestSpm99AnalyzeHeader, self).test_empty()
from scipy.special import genlaguerre, gamma
from ...data import get_gtab_taiwan_dsi
from ..shore import ShoreModel
from ...sims.voxel import MultiTensor
from numpy.testing import (assert_almost_equal,
assert_equal,
run_module_suite,
dec)
from ...utils.optpkg import optional_package
cvxopt, have_cvxopt, _ = optional_package("cvxopt")
needs_cvxopt = dec.skipif(not have_cvxopt)
# Object to hold module global data
class _C(object):
pass
data = _C()
def setup():
data.gtab = get_gtab_taiwan_dsi()
data.mevals = np.array(([0.0015, 0.0003, 0.0003],
[0.0015, 0.0003, 0.0003]))
data.angl = [(0, 0), (60, 0)]
data.S, sticks = MultiTensor(
data.gtab, data.mevals, S0=100.0, angles=data.angl,
