def load_expectation(filename): """ Load an expected fitting problem from a json file. :param filename: The path to the expectation file :type filename: string :return: A fitting problem to test against :rtype: fitbenchmarking.parsing.FittingProblem """ with open(filename, 'r') as f: expectation_dict = load(f) expectation = FittingProblem() expectation.name = expectation_dict['name'] expectation.start_x = expectation_dict['start_x'] expectation.end_x = expectation_dict['end_x'] expectation.data_x = np.array(expectation_dict['data_x']) expectation.data_y = np.array(expectation_dict['data_y']) expectation.data_e = expectation_dict['data_e'] if expectation.data_e is not None: expectation.data_e = np.array(expectation.data_e) expectation.functions = expectation_dict['functions'] expectation.starting_values = expectation_dict['starting_values'] expectation.value_ranges = expectation_dict['value_ranges'] return expectation
def test_verify_problem(self): """ Test that verify only passes if all required values are set. """ fitting_problem = FittingProblem() with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes when no values are set.') fitting_problem.starting_values = [['p1', [1]], ['p2', [2]]] with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes starting values are set.') fitting_problem.data_x = np.array([1, 2, 3, 4, 5]) with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes when data_x is set.') fitting_problem.data_y = np.array([1, 2, 3, 4, 5]) with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes when data_y is set.') fitting_problem.functions = [[lambda x, p1, p2: p1 + p2, [1, 2]]] try: fitting_problem.verify() except TypeError: self.fail('verify() fails when all required values set.') fitting_problem.data_x = [1, 2, 3] with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes for x values not numpy.')
def test_eval_starting_params(self): """ Test that eval_starting_params returns the correct result """ fitting_problem = FittingProblem() self.assertRaises(AttributeError, fitting_problem.eval_starting_params, function_id=0) fitting_problem.functions = [[lambda x, p1: x + p1, [3]], [lambda x, p1: x + p1 + 10, [7]]] fitting_problem.data_x = np.array([1]) eval_result = fitting_problem.eval_starting_params(0) self.assertTrue(all(eval_result == np.array([4]))) eval_result = fitting_problem.eval_starting_params(1) self.assertTrue(all(eval_result == np.array([18])))
def parse(self): """ Parse the Fitbenchmark problem file into a Fitting Problem. :return: The fully parsed fitting problem :rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem """ fitting_problem = FittingProblem() self._entries = self._get_fitbenchmark_data_problem_entries() self._parsed_func = self._parse_function() fitting_problem.name = self._entries['name'] data_points = self._get_data_points() fitting_problem.data_x = data_points[:, 0] fitting_problem.data_y = data_points[:, 1] if data_points.shape[1] > 2: fitting_problem.data_e = data_points[:, 2] # String containing the function name(s) and the starting parameter # values for each function self._mantid_equation = self._entries['function'] fitting_problem.functions = self._fitbenchmark_func_definitions() # Print number of equations until better way of doing this is looked at equation_count = len(self._parsed_func) fitting_problem.equation = '{} Functions'.format(equation_count) fitting_problem.starting_values = self._get_starting_values() # start and end values in x range if 'fit_parameters' in self._entries: start_x, end_x = self._get_x_range() fitting_problem.start_x = start_x fitting_problem.end_x = end_x return fitting_problem
def parse(self): fitting_problem = FittingProblem() equation, data, starting_values, name = self._parse_line_by_line() data = self._parse_data(data) fitting_problem.data_x = data[:, 1] fitting_problem.data_y = data[:, 0] if len(data[0, :]) > 2: fitting_problem.data_e = data[:, 2] fitting_problem.name = name # String containing a mathematical expression fitting_problem.equation = self._parse_equation(equation) fitting_problem.starting_values = starting_values fitting_problem.functions = \ nist_func_definitions(function=fitting_problem.equation, startvals=fitting_problem.starting_values) return fitting_problem
def test_eval_f(self): """ Test that eval_f is running the correct function """ fitting_problem = FittingProblem() self.assertRaises(AttributeError, fitting_problem.eval_f, x=2, params=[1, 2, 3], function_id=0) fitting_problem.functions = [[lambda x, p1: x + p1, [3]], [lambda x, p1: x + p1 + 10, [7]]] x_val = np.array([1]) eval_result = fitting_problem.eval_f(x=x_val, params=[5], function_id=0) self.assertTrue(all(eval_result == np.array([6]))) eval_result = fitting_problem.eval_f(x=x_val, params=[5], function_id=1) self.assertTrue(all(eval_result == np.array([16]))) fitting_problem.data_x = np.array([20, 21, 22]) eval_result = fitting_problem.eval_f(params=[5], function_id=0) self.assertTrue(all(eval_result == np.array([25, 26, 27])))