def test_SetBoundsErrorCases(self): # Array sizes don't match some_bounds = libUnfitPython.Bounds(3) lower = libUnfitPython.std_vector_double() upper = libUnfitPython.std_vector_double() lower[:] = [0.0, 0.0] upper[:] = [1.0, 1.0, 1.0] self.assertFalse(some_bounds.SetBounds(lower, upper)) # Negative infinite bound lower.append(-float('inf')) self.assertFalse(some_bounds.SetBounds(lower, upper)) # Positive infinite bound lower[2] = 0.0 upper[1] = float('inf') self.assertFalse(some_bounds.SetBounds(lower, upper)) # Lower bound > upper bound upper[1] = -1.0 self.assertFalse(some_bounds.SetBounds(lower, upper)) # Now check that the original bounds are intact some_bounds.GetBounds(lower, upper) for bnd in lower: self.assertAlmostEqual(max_negative_num, bnd, test_tol) for bnd in upper: self.assertAlmostEqual(max_positive_num, bnd, test_tol)
class QuadraticCostFunction(libUnfitPython.GenericCostFunction): t = libUnfitPython.std_vector_double() y = libUnfitPython.std_vector_double() def __init__(self, t_data=None, y_data=None): libUnfitPython.GenericCostFunction.__init__(self) if t_data != None and y_data != None: self.t[:] = t_data self.y[:] = y_data else: self.t[:] = [] self.y[:] = [] def FileInit(self, filename): i = 0 with open(filename) as f: for line in f: if (i == 0): self.t[:] = [float(x) for x in line.split()] i = 1 else: self.y[:] = [float(x) for x in line.split()] def __call__(self, x): r = libUnfitPython.std_vector_double() r[:] = self.y[:] for i, ti in enumerate(self.t): model = x[0] + x[1] * ti + x[2] * ti * ti r[i] -= model return r
def test_ClampPointWithinBounds(self): some_bounds = libUnfitPython.Bounds() lower = libUnfitPython.std_vector_double() upper = libUnfitPython.std_vector_double() lower[:] = [0.0, 0.0, 0.0] upper[:] = [1.0, 1.0, 1.0] some_bounds.SetBounds(lower, upper) # Already within bounds, should do nothing point = libUnfitPython.std_vector_double() point[:] = [0.5, 0.5, 0.5] some_bounds.ClampWithinBounds(point) self.assertAlmostEqual(0.5, point[0], test_tol) self.assertAlmostEqual(0.5, point[1], test_tol) self.assertAlmostEqual(0.5, point[2], test_tol) # Clamp to lower bound point[1] = -1.0 some_bounds.ClampWithinBounds(point) self.assertAlmostEqual(0.5, point[0], test_tol) self.assertAlmostEqual(0.0, point[1], test_tol) self.assertAlmostEqual(0.5, point[2], test_tol) # Clamp to upper bound point[1] = 2.0 some_bounds.ClampWithinBounds(point) self.assertAlmostEqual(0.5, point[0], test_tol) self.assertAlmostEqual(1.0, point[1], test_tol) self.assertAlmostEqual(0.5, point[2], test_tol)
def test_SetOneBoundErrorCases(self): # Array sizes don't match some_bounds = libUnfitPython.Bounds(3) # Negative inifinite bound self.assertFalse(some_bounds.SetBounds(2, -float('inf'), 1.0)) # Positive inifnite bounds self.assertFalse(some_bounds.SetBounds(2, 0.0, float('inf'))) # Lower bound > upper bound self.assertFalse(some_bounds.SetBounds(2, 1.0, 0.0)) # Check adding an index greater than the vector size (should scale) self.assertTrue( some_bounds.SetBounds(5, max_negative_num, max_positive_num)) self.assertEqual(6, some_bounds.GetNumberOfBounds()) # Now check that the original and extended bounds are intact lower = libUnfitPython.std_vector_double() upper = libUnfitPython.std_vector_double() some_bounds.GetBounds(lower, upper) for bnd in lower: self.assertAlmostEqual(max_negative_num, bnd, test_tol) for bnd in upper: self.assertAlmostEqual(max_positive_num, bnd, test_tol)
def setUp(self): ''' Processes done at the start of every test in this class. ''' lower = libUnfitPython.std_vector_double() lower[:] = [-10, -10, -10] upper = libUnfitPython.std_vector_double() upper[:] = [10, 10, 10] self.de = libUnfitPython.DifferentialEvolution() self.de.bounds.SetBounds(lower, upper)
def setUp(self): ''' Processes done at the start of every test in this class. ''' lower = libUnfitPython.std_vector_double() lower[:] = [-10, -10, -10] upper = libUnfitPython.std_vector_double() upper[:] = [10, 10, 10] self.sa = libUnfitPython.SimulatedAnnealing() self.sa.bounds.SetBounds(lower, upper)
def setUp(self): ''' Processes done at the start of every test in this class. ''' lower = libUnfitPython.std_vector_double() lower[:] = [-10, -10, -10] upper = libUnfitPython.std_vector_double() upper[:] = [10, 10, 10] self.lm = libUnfitPython.LevenbergMarquardt() self.lm.bounds.SetBounds(lower, upper)
def setUp(self): ''' Processes done at the start of every test in this class. ''' lower = libUnfitPython.std_vector_double() lower[:] = [-10, -10, -10] upper = libUnfitPython.std_vector_double() upper[:] = [10, 10, 10] self.nm = libUnfitPython.NelderMead() self.nm.bounds.SetBounds(lower, upper)
def setUp(self): ''' Processes done at the start of every test in this class. ''' lower = libUnfitPython.std_vector_double() lower[:] = [-10, -10, -10] upper = libUnfitPython.std_vector_double() upper[:] = [10, 10, 10] self.ga = libUnfitPython.GeneticAlgorithm() self.ga.bounds.SetBounds(lower, upper)
def test_OnePointWithinBounds(self): some_bounds = libUnfitPython.Bounds() lower = libUnfitPython.std_vector_double() upper = libUnfitPython.std_vector_double() lower[:] = [0.0, 0.0, 0.0] upper[:] = [1.0, 1.0, 1.0] some_bounds.SetBounds(lower, upper) self.assertTrue(some_bounds.IsWithinBounds(1, 0.5)) self.assertFalse(some_bounds.IsWithinBounds(1, -1.0)) self.assertFalse(some_bounds.IsWithinBounds(1, 2.0)) self.assertFalse(some_bounds.IsWithinBounds(5, 0.5))
def test_SetUpperAndLower(self): some_bounds = libUnfitPython.Bounds(5) self.assertEqual(5, some_bounds.GetNumberOfBounds()) # Set bounds and check they are set some_bounds.SetLowerBound(2, 0.0) some_bounds.SetUpperBound(3, 1.0) lower = libUnfitPython.std_vector_double() upper = libUnfitPython.std_vector_double() some_bounds.GetBounds(lower, upper) self.assertAlmostEqual(0.0, lower[2], test_tol) self.assertAlmostEqual(max_positive_num, upper[2], test_tol) self.assertAlmostEqual(max_negative_num, lower[3], test_tol) self.assertAlmostEqual(1.0, upper[3], test_tol)
def test_AppendExtend(self): vector1 = libUnfitPython.std_vector_double() vector1[:] = [1, 2, 3, 4, 5] vector2 = libUnfitPython.std_vector_double() vector2[:] = [1, 2, 3] vector2.append(4) test = [1, 2, 3, 4] for i, vi in enumerate(vector2): self.assertEqual(vi, test[i]) vector2.extend(vector1[3:5]) test = [1, 2, 3, 4, 4, 5] for i, vi in enumerate(vector2): self.assertEqual(vi, test[i])
def test_PointsWithinBounds(self): some_bounds = libUnfitPython.Bounds() lower = libUnfitPython.std_vector_double() upper = libUnfitPython.std_vector_double() lower[:] = [0.0, 0.0, 0.0] upper[:] = [1.0, 1.0, 1.0] some_bounds.SetBounds(lower, upper) point = libUnfitPython.std_vector_double() point[:] = [0.5, 0.5, 0.5] self.assertTrue(some_bounds.IsWithinBounds(point)) point[1] = -1.0 self.assertFalse(some_bounds.IsWithinBounds(point)) point[1] = 2.0 self.assertFalse(some_bounds.IsWithinBounds(point))
def __call__(self, x): r = libUnfitPython.std_vector_double() r[:] = self.y[:] for i, ti in enumerate(self.t): model = x[0] + x[1] * ti + x[2] * ti * ti r[i] -= model return r
def test_PointsWithinBoundsEdgeCases(self): some_bounds = libUnfitPython.Bounds(3) point = libUnfitPython.std_vector_double() point[:] = [max_positive_num, max_negative_num, max_positive_num] self.assertTrue(some_bounds.IsWithinBounds(point)) point[0] = point[0] * 10.0 self.assertFalse(some_bounds.IsWithinBounds(point)) point[0] = max_positive_num point[1] = point[1] * 10 self.assertFalse(some_bounds.IsWithinBounds(point))
def test_SetAndReset(self): some_bounds = libUnfitPython.Bounds(5) self.assertEqual(5, some_bounds.GetNumberOfBounds()) # Set bounds and check they are set some_bounds.SetBounds(2, 0.0, 1.0) lower = libUnfitPython.std_vector_double() upper = libUnfitPython.std_vector_double() some_bounds.GetBounds(lower, upper) self.assertAlmostEqual(0.0, lower[2], test_tol) self.assertAlmostEqual(1.0, upper[2], test_tol) # Reset bounds and check they have been reset some_bounds.ResetBounds() some_bounds.GetBounds(lower, upper) for bnd in lower: self.assertAlmostEqual(max_negative_num, bnd, test_tol) for bnd in upper: self.assertAlmostEqual(max_positive_num, bnd, test_tol)
def __call__(self, x): ''' Method called by FindMin function. Modify the model if needed. ''' r = libUnfitPython.std_vector_double() r[:] = self.y[:] for i, ti in enumerate(self.t): model = x[0] * math.exp(-x[1] * ti) r[i] -= model return r
def test_Indexing(self): vector = libUnfitPython.std_vector_double() vector[:] = [1, 2, 3] #tests normal indexing self.assertEqual(1, vector[0]) self.assertEqual(2, vector[1]) self.assertEqual(3, vector[2]) #tests python negative indexing self.assertEqual(3, vector[-1]) self.assertEqual(2, vector[-2]) self.assertEqual(1, vector[-3])
def test_BoundsConstructors(self): # Start with no bounds no_bounds = libUnfitPython.Bounds() self.assertEqual(0, no_bounds.GetNumberOfBounds()) # Now set the number of bounds no_bounds.SetNumberOfBounds(5) lower = libUnfitPython.std_vector_double() upper = libUnfitPython.std_vector_double() no_bounds.GetBounds(lower, upper) for bnd in lower: self.assertAlmostEqual(max_negative_num, bnd, test_tol) for bnd in upper: self.assertAlmostEqual(max_positive_num, bnd, test_tol) # Start with some bounds some_bounds = libUnfitPython.Bounds(5) self.assertEqual(5, some_bounds.GetNumberOfBounds()) some_bounds.GetBounds(lower, upper) for bnd in lower: self.assertAlmostEqual(max_negative_num, bnd, test_tol) for bnd in upper: self.assertAlmostEqual(max_positive_num, bnd, test_tol)
def test_Slicing(self): vector1 = libUnfitPython.std_vector_double() vector1[:] = [1, 2, 3, 4, 5] vector2 = libUnfitPython.std_vector_double() vector2[:] = vector1[:3] test = [1, 2, 3] for i, vi in enumerate(vector2): self.assertEqual(vi, test[i]) vector2[:] = [1, 2, 3, 4, 5, 6] vector2[1:5] = [3, 4, 5, 6] test = [1, 3, 4, 5, 6, 6] for i, vi in enumerate(vector2): self.assertEqual(vi, test[i]) vector2[1:3] = [7, 8, 9, 10] test = [1, 7, 8, 9, 10, 5, 6, 6] for i, vi in enumerate(vector2): self.assertEqual(vi, test[i]) vector2[2:6] = [11, 11] test = [1, 7, 11, 11, 6, 6] for i, vi in enumerate(vector2): self.assertEqual(vi, test[i])
class MyCostFunction(libUnfitPython.GenericCostFunction): t = libUnfitPython.std_vector_double() y = libUnfitPython.std_vector_double() def __init__(self, t_data=None, y_data=None): libUnfitPython.GenericCostFunction.__init__(self) if t_data != None and y_data != None: self.t[:] = t_data self.y[:] = y_data else: self.t[:] = [] self.y[:] = [] def __call__(self, x): ''' Method called by FindMin function. Modify the model if needed. ''' r = libUnfitPython.std_vector_double() r[:] = self.y[:] for i, ti in enumerate(self.t): model = x[0] * math.exp(-x[1] * ti) r[i] -= model return r
def test_ExponentialFileInput(self): cf = Exponential.ExponentialCostFunction() cf.FileInit('Values/TestExponential.txt') guess = libUnfitPython.std_vector_double() guess[:] = [0, 0] cost = 0 for r in cf(guess): cost = cost + r * r self.assertAlmostEqual(cost, 1.58190784, cost_tol) self.lm.FindMin(cf, guess) self.assertAlmostEqual(guess[0], 0.99999682538, guess_tol) self.assertAlmostEqual(guess[1], 0.500017605642, guess_tol)
def test_ExponentialDirectInput(self): cf = Exponential.ExponentialCostFunction([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1.0, 0.6065, 0.3679, 0.2231, 0.1353, 0.0821, 0.0498, 0.0302, 0.0183, 0.0111, 0.0067]) guess = libUnfitPython.std_vector_double() guess[:] = [0, 0] cost = 0 for r in cf(guess): cost = cost + r * r self.assertAlmostEqual(cost, 1.58190784, cost_tol) self.ga.FindMin(cf, guess) self.assertAlmostEqual(guess[0], 1.02684400144, guess_tol) self.assertAlmostEqual(guess[1], 0.517748487134, guess_tol)
def test_ExponentialFileInput(self): cf = Exponential.ExponentialCostFunction() cf.FileInit('Values/TestExponential.txt') guess = libUnfitPython.std_vector_double() guess[:] = [0, 0] cost = 0 for r in cf(guess): cost = cost + r * r self.assertAlmostEqual(cost, 1.58190784, cost_tol) self.ga.FindMin(cf, guess) self.assertAlmostEqual(guess[0], 1.02684400144, guess_tol) self.assertAlmostEqual(guess[1], 0.517748487134, guess_tol)
def test_LinearFileInput(self): cf = Linear.LinearCostFunction() cf.FileInit('Values/TestLinear.txt') guess = libUnfitPython.std_vector_double() guess[:] = [0, 0] cost = 0 for r in cf(guess): cost = cost + r * r self.assertAlmostEqual(cost, 5365, cost_tol) self.lm.FindMin(cf, guess) self.assertAlmostEqual(guess[0], 4.99999998785, guess_tol) self.assertAlmostEqual(guess[1], 3.00000000175, guess_tol)
def test_LinearDirectInput(self): cf = Linear.LinearCostFunction([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [8, 11, 14, 17, 20, 23, 26, 29, 32, 35]) guess = libUnfitPython.std_vector_double() guess[:] = [0, 0] cost = 0 for r in cf(guess): cost = cost + r * r self.assertAlmostEqual(cost, 5365, cost_tol) self.lm.FindMin(cf, guess) self.assertAlmostEqual(guess[0], 4.99999998785, guess_tol) self.assertAlmostEqual(guess[1], 3.00000000175, guess_tol)
def test_QuadraticFileInput(self): cf = Quadratic.QuadraticCostFunction() cf.FileInit('Values/TestQuadratic.txt') guess = libUnfitPython.std_vector_double() guess[:] = [0, 0, 0] cost = 0 for r in cf(guess): cost = cost + r * r self.assertAlmostEqual(cost, 5188, cost_tol) self.ga.FindMin(cf, guess) self.assertAlmostEqual(guess[0], -4.06385903347, guess_tol) self.assertAlmostEqual(guess[1], -2.17175521045, guess_tol) self.assertAlmostEqual(guess[2], 0.754356468106, guess_tol)
def test_QuadraticFileInput(self): cf = Quadratic.QuadraticCostFunction() cf.FileInit('Values/TestQuadratic.txt') guess = libUnfitPython.std_vector_double() guess[:] = [0, 0, 0] cost = 0 for r in cf(guess): cost = cost + r * r self.assertAlmostEqual(cost, 5188, cost_tol) self.nm.FindMin(cf, guess) self.assertAlmostEqual(guess[0], 2.00000093872, guess_tol) self.assertAlmostEqual(guess[1], -5.00000040316, guess_tol) self.assertAlmostEqual(guess[2], 1.00000003577, guess_tol)
def test_QuadraticFileInput(self): cf = Quadratic.QuadraticCostFunction() cf.FileInit('Values/TestQuadratic.txt') guess = libUnfitPython.std_vector_double() guess[:] = [0, 0, 0] cost = 0 for r in cf(guess): cost = cost + r * r self.assertAlmostEqual(cost, 5188, cost_tol) self.lm.FindMin(cf, guess) self.assertAlmostEqual(guess[0], 1.99999958222, guess_tol) self.assertAlmostEqual(guess[1], -4.99999983709, guess_tol) self.assertAlmostEqual(guess[2], 0.999999986896, guess_tol)
def test_QuadraticDirectInput(self): cf = Quadratic.QuadraticCostFunction([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [-2, -4, -4, -2, 2, 8, 16, 26, 38, 52]) guess = libUnfitPython.std_vector_double() guess[:] = [0, 0, 0] cost = 0 for r in cf(guess): cost = cost + r * r self.assertAlmostEqual(cost, 5188, cost_tol) self.ga.FindMin(cf, guess) self.assertAlmostEqual(guess[0], -4.06385903347, guess_tol) self.assertAlmostEqual(guess[1], -2.17175521045, guess_tol) self.assertAlmostEqual(guess[2], 0.754356468106, guess_tol)