def test_basinhopping():
"""Test basinhopping in lmfit versus scipy."""
# SciPy
def func(x):
return np.cos(14.5 * x - 0.3) + (x + 0.2) * x
minimizer_kwargs = {'method': 'L-BFGS-B'}
x0 = [1.]
# FIXME - remove after requirement for scipy >= 0.19
major, minor, micro = scipy_version.split('.', 2)
if int(major) < 1 and int(minor) < 19:
ret = basinhopping(func, x0, minimizer_kwargs=minimizer_kwargs)
else:
ret = basinhopping(func, x0, minimizer_kwargs=minimizer_kwargs, seed=7)
# lmfit
def residual(params):
x = params['x'].value
return np.cos(14.5 * x - 0.3) + (x + 0.2) * x
pars = lmfit.Parameters()
pars.add_many(('x', 1.))
kws = {'minimizer_kwargs': {'method': 'L-BFGS-B'}, 'seed': 7}
mini = lmfit.Minimizer(residual, pars)
out = mini.minimize(method='basinhopping', **kws)
assert_allclose(out.residual, ret.fun)
assert_allclose(out.params['x'].value, ret.x)
def test_basinhopping_2d():
"""Test basinhopping in lmfit versus scipy."""
# SciPy
def func2d(x):
return np.cos(14.5*x[0] - 0.3) + (x[1]+0.2) * x[1] + (x[0]+0.2) * x[0]
minimizer_kwargs = {'method': 'L-BFGS-B'}
x0 = [1.0, 1.0]
# FIXME - remove after requirement for scipy >= 0.19
major, minor, micro = scipy_version.split('.', 2)
if int(major) < 1 and int(minor) < 19:
ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs)
else:
ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,
seed=7)
# lmfit
def residual_2d(params):
x0 = params['x0'].value
x1 = params['x1'].value
return np.cos(14.5*x0 - 0.3) + (x1+0.2) * x1 + (x0+0.2) * x0
pars = lmfit.Parameters()
pars.add_many(('x0', 1.), ('x1', 1.))
mini = lmfit.Minimizer(residual_2d, pars)
kws = {'minimizer_kwargs': {'method': 'L-BFGS-B'}, 'seed': 7}
out = mini.minimize(method='basinhopping', **kws)
assert_allclose(out.residual, ret.fun)
assert_allclose(out.params['x0'].value, ret.x[0])
assert_allclose(out.params['x1'].value, ret.x[1], rtol=1e-5)
def test_basinhopping_Alpine02():
"""Test basinhopping on Alpine02 function."""
global_optimum = [7.91705268, 4.81584232]
fglob = -6.12950
# SciPy
def Alpine02(x):
x0 = x[0]
x1 = x[1]
return np.prod(np.sqrt(x0) * np.sin(x0)) * np.prod(np.sqrt(x1) *
np.sin(x1))
def basinhopping_accept(f_new, f_old, x_new, x_old):
"""Does the new candidate vector lie inbetween the bounds?
Returns
-------
accept_test : bool
The candidate vector lies inbetween the bounds
"""
if np.any(x_new < np.array([0.0, 0.0])):
return False
if np.any(x_new > np.array([10.0, 10.0])):
return False
return True
minimizer_kwargs = {'method': 'L-BFGS-B', 'bounds': [(0.0, 10.0),
(0.0, 10.0)]}
x0 = [1.0, 1.0]
# FIXME - remove after requirement for scipy >= 0.19
major, minor, micro = scipy_version.split('.', 2)
if int(major) < 1 and int(minor) < 19:
ret = basinhopping(Alpine02, x0, minimizer_kwargs=minimizer_kwargs,
accept_test=basinhopping_accept)
else:
ret = basinhopping(Alpine02, x0, minimizer_kwargs=minimizer_kwargs,
accept_test=basinhopping_accept, seed=7)
# lmfit
def residual_Alpine02(params):
x0 = params['x0'].value
x1 = params['x1'].value
return np.prod(np.sqrt(x0) * np.sin(x0)) * np.prod(np.sqrt(x1) *
np.sin(x1))
pars = lmfit.Parameters()
pars.add_many(('x0', 1., True, 0.0, 10.0),
('x1', 1., True, 0.0, 10.0))
mini = lmfit.Minimizer(residual_Alpine02, pars)
kws = {'minimizer_kwargs': {'method': 'L-BFGS-B'}, 'seed': 7}
out = mini.minimize(method='basinhopping', **kws)
out_x = np.array([out.params['x0'].value, out.params['x1'].value])
assert_allclose(out.residual, fglob, rtol=1e-5)
assert_allclose(min(out_x), min(global_optimum))
assert_allclose(max(out_x), max(global_optimum))
def testNetcdfSupport(self):
from scipy.version import version as SciPyVersion
if tuple(int(x) for x in SciPyVersion.split('.')) < (0, 9, 0):
import Scientific.IO.NetCDF
else:
import scipy.io.netcdf
return
def testNetcdfSupport(self):
from scipy.version import version as SciPyVersion
if tuple(int(x) for x in SciPyVersion.split('.')) < (0, 9, 0):
import Scientific.IO.NetCDF
else:
import scipy.io.netcdf
return
def test_nan_policy(self):
# check that an error is raised if there are nan in
# the data returned by userfcn
self.data[0] = np.nan
major, minor, _micro = scipy_version.split('.', 2)
for method in SCALAR_METHODS:
if (method == 'differential_evolution' and int(major) > 0 and
int(minor) >= 2):
pytest.raises(RuntimeError, self.mini.scalar_minimize,
SCALAR_METHODS[method])
else:
pytest.raises(ValueError, self.mini.scalar_minimize,
SCALAR_METHODS[method])
pytest.raises(ValueError, self.mini.minimize)
# now check that the fit proceeds if nan_policy is 'omit'
self.mini.nan_policy = 'omit'
res = self.mini.minimize()
assert_equal(res.ndata, np.size(self.data, 0) - 1)
for para, true_para in zip(res.params.values(), self.p_true.values()):
check_wo_stderr(para, true_para.value, sig=0.15)
#!/usr/bin/env python
from scipy.version import version as SciPyVersion
if tuple(int(x) for x in SciPyVersion.split('.')) < (0, 9, 0):
from Scientific.IO.NetCDF import NetCDFFile as netcdf_file
else:
from scipy.io.netcdf import netcdf_file
from numpy import arange, zeros
def create(missingdata=False,
missingdimension=False,
missingvariable=False,
incorrectdimension=False,
incorrectvariable=False):
if (missingdata):
filename = 'missingdata.nc'
description = ', with missing data.'
elif (missingdimension):
filename = 'missingdimension.nc'
description = ', with a missing dimension.'
elif (missingvariable):
filename = 'missingvariable.nc'
description = ', with a missing variable.'
elif (incorrectdimension):
filename = 'incorrectdimension.nc'
description = ', with an incorrect dimension label.'
elif (incorrectvariable):
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
"""
ERA data set handling routines
"""
import datetime
import math
import os
import unittest
import fluidity.diagnostics.debug as debug
from scipy.version import version as SciPyVersion
if tuple(int(x) for x in SciPyVersion.split('.')) < (0, 9, 0):
try:
import Scientific.IO.NetCDF as netcdf
except:
debug.deprint("Warning: Your SciPy version is too old (<0.9.0) and \nthe Scientific.IO.NetCDF module failed to import")
else:
try:
import scipy.io.netcdf as netcdf
except:
debug.deprint("Warning: Failed to import scipy.io.netcdf module")
import fluidity.diagnostics.calc as calc
import fluidity.diagnostics.filehandling as filehandling