Imported Upstream version 0.9.5+dfsg

1 files changed, 66 insertions, 37 deletions

diff --git a/tests/test_nose.py b/tests/test_nose.py
index b5ad44a..9e4f4dd 100644
--- a/tests/test_nose.py
+++ b/tests/test_nose.py
@@ -2,12 +2,12 @@
 from __future__ import print_function
 from lmfit import minimize, Parameters, Parameter, report_fit, Minimizer
 from lmfit.minimizer import (SCALAR_METHODS, HAS_EMCEE,
-                             MinimizerResult, _lnpost)
+                             MinimizerResult, _lnpost, _nan_policy)
 from lmfit.lineshapes import gaussian
 import numpy as np
 from numpy import pi
 from numpy.testing import (assert_, decorators, assert_raises,
-                           assert_almost_equal)
+                           assert_almost_equal, assert_equal)
 import unittest
 import nose
 from nose import SkipTest
@@ -37,10 +37,10 @@ def test_simple():
     # define objective function: returns the array to be minimized
     def fcn2min(params, x, data):
         """ model decaying sine wave, subtract data"""
-        amp = params['amp'].value
-        shift = params['shift'].value
-        omega = params['omega'].value
-        decay = params['decay'].value
+        amp = params['amp']
+        shift = params['shift']
+        omega = params['omega']
+        decay = params['decay']
 
         model = amp * np.sin(x * omega + shift) * np.exp(-x*x*decay)
         return model - data
@@ -77,10 +77,10 @@ def test_lbfgsb():
     p_true.add('decay', value=0.010)
 
     def residual(pars, x, data=None):
-        amp = pars['amp'].value
-        per = pars['period'].value
-        shift = pars['shift'].value
-        decay = pars['decay'].value
+        amp = pars['amp']
+        per = pars['period']
+        shift = pars['shift']
+        decay = pars['decay']
 
         if abs(shift) > pi/2:
             shift = shift - np.sign(shift) * pi
@@ -117,21 +117,14 @@ def test_lbfgsb():
 
 def test_derive():
     def func(pars, x, data=None):
-        a = pars['a'].value
-        b = pars['b'].value
-        c = pars['c'].value
-
-        model=a * np.exp(-b * x)+c
+        model= pars['a'] * np.exp(-pars['b'] * x) + pars['c']
         if data is None:
             return model
         return model - data
 
     def dfunc(pars, x, data=None):
-        a = pars['a'].value
-        b = pars['b'].value
-        c = pars['c'].value
-        v = np.exp(-b*x)
-        return np.array([v, -a*x*v, np.ones(len(x))])
+        v = np.exp(-pars['b']*x)
+        return np.array([v, -pars['a']*x*v, np.ones(len(x))])
 
     def f(var, x):
         return var[0]* np.exp(-var[1] * x)+var[2]
@@ -187,8 +180,8 @@ def test_derive():
 
 def test_peakfit():
     def residual(pars, x, data=None):
-        g1 = gaussian(x, pars['a1'].value, pars['c1'].value, pars['w1'].value)
-        g2 = gaussian(x, pars['a2'].value, pars['c2'].value, pars['w2'].value)
+        g1 = gaussian(x, pars['a1'], pars['c1'], pars['w1'])
+        g2 = gaussian(x, pars['a2'], pars['c2'], pars['w2'])
         model = g1 + g2
         if data is None:
             return model
@@ -256,10 +249,10 @@ def test_scalar_minimize_has_no_uncertainties():
     # define objective function: returns the array to be minimized
     def fcn2min(params, x, data):
         """ model decaying sine wave, subtract data"""
-        amp = params['amp'].value
-        shift = params['shift'].value
-        omega = params['omega'].value
-        decay = params['decay'].value
+        amp = params['amp']
+        shift = params['shift']
+        omega = params['omega']
+        decay = params['decay']
 
         model = amp * np.sin(x * omega + shift) * np.exp(-x*x*decay)
         return model - data
@@ -301,9 +294,7 @@ def test_multidimensional_fit_GH205():
 
     def fcn2min(params, xv, yv, data):
         """ model decaying sine wave, subtract data"""
-        lambda1 = params['lambda1'].value
-        lambda2 = params['lambda2'].value
-        model = f(xv, yv, lambda1, lambda2)
+        model = f(xv, yv, params['lambda1'], params['lambda2'])
         return model - data
 
     # create a set of Parameters
@@ -345,10 +336,10 @@ class CommonMinimizerTest(unittest.TestCase):
         self.mini = Minimizer(self.residual, fit_params, [self.x, self.data])
 
     def residual(self, pars, x, data=None):
-        amp = pars['amp'].value
-        per = pars['period'].value
-        shift = pars['shift'].value
-        decay = pars['decay'].value
+        amp = pars['amp']
+        per = pars['period']
+        shift = pars['shift']
+        decay = pars['decay']
 
         if abs(shift) > pi/2:
             shift = shift - np.sign(shift) * pi
@@ -361,9 +352,14 @@ class CommonMinimizerTest(unittest.TestCase):
         # You need finite (min, max) for each parameter if you're using
         # differential_evolution.
         self.fit_params['decay'].min = -np.inf
+        self.fit_params['decay'].vary = True
         self.minimizer = 'differential_evolution'
         np.testing.assert_raises(ValueError, self.scalar_minimizer)
 
+        # but only if a parameter is not fixed
+        self.fit_params['decay'].vary = False
+        self.mini.scalar_minimize(method='differential_evolution', maxiter=1)
+
     def test_scalar_minimizers(self):
         # test all the scalar minimizers
         for method in SCALAR_METHODS:
@@ -395,6 +391,39 @@ class CommonMinimizerTest(unittest.TestCase):
                                    self.p_true.values()):
             check_wo_stderr(para, true_para.value, sig=sig)
 
+    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
+
+        for method in SCALAR_METHODS:
+            assert_raises(ValueError,
+                          self.mini.scalar_minimize,
+                          SCALAR_METHODS[method])
+
+        assert_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)
+
+    def test_nan_policy_function(self):
+        a = np.array([0, 1, 2, 3, np.nan])
+        assert_raises(ValueError, _nan_policy, a)
+        assert_(np.isnan(_nan_policy(a, nan_policy='propagate')[-1]))
+        assert_equal(_nan_policy(a, nan_policy='omit'), [0, 1, 2, 3])
+
+        a[-1] = np.inf
+        assert_raises(ValueError, _nan_policy, a)
+        assert_(np.isposinf(_nan_policy(a, nan_policy='propagate')[-1]))
+        assert_equal(_nan_policy(a, nan_policy='omit'), [0, 1, 2, 3])
+        assert_equal(_nan_policy(a, handle_inf=False), a)
+
     @decorators.slow
     def test_emcee(self):
         # test emcee
@@ -591,10 +620,10 @@ class CommonMinimizerTest(unittest.TestCase):
 def residual_for_multiprocessing(pars, x, data=None):
     # a residual function defined in the top level is needed for
     # multiprocessing. bound methods don't work.
-    amp = pars['amp'].value
-    per = pars['period'].value
-    shift = pars['shift'].value
-    decay = pars['decay'].value
+    amp = pars['amp']
+    per = pars['period']
+    shift = pars['shift']
+    decay = pars['decay']
 
     if abs(shift) > pi/2:
         shift = shift - np.sign(shift) * pi