def test_sanitised_name(self):
fitting_problem = FittingProblem()
expected = "test_1"
fitting_problem.name = "test 1"
self.assertEqual(fitting_problem.sanitised_name, expected)
fitting_problem.name = "test,1"
self.assertEqual(fitting_problem.sanitised_name, expected)
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(OPTIONS)
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.starting_values = expectation_dict['starting_values']
expectation.value_ranges = expectation_dict['value_ranges']
return expectation
def parse(self):
"""
Parse the NIST problem file into a Fitting Problem.
:return: The fully parsed fitting problem
:rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem
"""
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.function = \
nist_func_definition(function=fitting_problem.equation,
param_names=starting_values[0].keys())
return fitting_problem
def setup_nist_expected_problem(self):
prob = FittingProblem()
prob.name = 'Misra1a'
prob.equation = 'b1*(1-exp(-b2*x))'
prob.starting_values = [['b1', [500.0, 250.0]],
['b2', [0.0001, 0.0005]]]
data_pattern = self.setup_misra1a_expected_data_points()
prob.data_x = data_pattern[:, 1]
prob.data_y = data_pattern[:, 0]
prob.ref_residual_sum_sq = 1.2455138894e-01
return prob
def parse(self):
"""
Get data into a Fitting Problem via cutest.
:return: The fully parsed fitting problem
:rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem
"""
self.mastsif_dir = TemporaryDirectory()
# set the MASTSIF environment variable so that pycutest
# can find the sif files
os.environ["MASTSIF"] = self.mastsif_dir.name
self._num_params = None
# get just the short filename (minus the .SIF)
fp = FittingProblem(self.options)
# Collect x and create new file with blank y
fname, fp.data_x, fp.data_y, fp.data_e = self._setup_data()
self._p = _import_problem(fname)
fp.name = self._p.name
fp.function = self._function # self._p.objcons
fp.jacobian = self._jacobian # self._p.lagjac
fp.equation = None
fp.starting_values = self._get_starting_values()
fp.start_x = None
fp.end_x = None
fp.format = "cutest"
# Create a list of x and f (function evaluation) and x and g (Jacobian
# evaluation).
# If a new x is given we will create and parse a new file
self._cache_f = [(fp.data_x, self._p.objcons)]
self._cache_g = [(fp.data_x, self._p.lagjac)]
return fp
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):
"""
Parse the NIST problem file into a Fitting Problem.
:return: The fully parsed fitting problem
:rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem
"""
fitting_problem = FittingProblem(self.options)
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.function = \
nist_func_definition(function=fitting_problem.equation,
param_names=starting_values[0].keys())
fitting_problem.format = "nist"
try:
jacobian = self._parse_jacobian(name)
fitting_problem.jacobian = \
nist_jacobian_definition(jacobian=jacobian,
param_names=starting_values[0].keys())
except NoJacobianError:
LOGGER.warn("WARNING: Could not find analytic Jacobian "
"information for {} problem".format(name))
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 parse(self):
"""
Parse the Fitbenchmark problem file into a Fitting Problem.
:return: The fully parsed fitting problem
:rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem
"""
# pylint: disable=attribute-defined-outside-init
fitting_problem = FittingProblem(self.options)
self._entries = self._get_data_problem_entries()
software = self._entries['software'].lower()
if not (software in import_success and import_success[software][0]):
error = import_success[software][1]
raise MissingSoftwareError('Requirements are missing for {} parser'
': {}'.format(software, error))
self._parsed_func = self._parse_function()
if software == 'mantid' and self._entries['input_file'][0] == '[':
fitting_problem.multifit = True
# NAME
fitting_problem.name = self._entries['name']
# DATA
data_points = [_get_data_points(p) for p in self._get_data_file()]
# FUNCTION
if software == 'mantid':
fitting_problem.function = self._create_mantid_function()
fitting_problem.format = 'mantid'
elif software == 'sasview':
fitting_problem.function = self._create_sasview_function()
fitting_problem.format = 'sasview'
# EQUATION
equation_count = len(self._parsed_func)
if equation_count == 1:
fitting_problem.equation = self._parsed_func[0]['name']
else:
fitting_problem.equation = '{} Functions'.format(equation_count)
# STARTING VALUES
fitting_problem.starting_values = self._get_starting_values()
# PARAMETER RANGES
vr = _parse_range(self._entries.get('parameter_ranges', ''))
fitting_problem.value_ranges = vr if vr != {} else None
# FIT RANGES
fit_ranges_str = self._entries.get('fit_ranges', '')
# this creates a list of strs like '{key: val, ...}' and parses each
fit_ranges = [
_parse_range('{' + r.split('}')[0] + '}')
for r in fit_ranges_str.split('{')[1:]
]
if fitting_problem.multifit:
num_files = len(data_points)
fitting_problem.data_x = [d[:, 0] for d in data_points]
fitting_problem.data_y = [d[:, 1] for d in data_points]
fitting_problem.data_e = [
d[:, 2] if d.shape[1] > 2 else None for d in data_points
]
if not fit_ranges:
fit_ranges = [{} for _ in range(num_files)]
fitting_problem.start_x = [
f['x'][0] if 'x' in f else None for f in fit_ranges
]
fitting_problem.end_x = [
f['x'][1] if 'x' in f else None for f in fit_ranges
]
else:
fitting_problem.data_x = data_points[0][:, 0]
fitting_problem.data_y = data_points[0][:, 1]
if data_points[0].shape[1] > 2:
fitting_problem.data_e = data_points[0][:, 2]
if fit_ranges and 'x' in fit_ranges[0]:
fitting_problem.start_x = fit_ranges[0]['x'][0]
fitting_problem.end_x = fit_ranges[0]['x'][1]
if software == 'mantid':
# String containing the function name(s) and the starting parameter
# values for each function.
fitting_problem.additional_info['mantid_equation'] \
= self._entries['function']
if fitting_problem.multifit:
fitting_problem.additional_info['mantid_ties'] \
= self._parse_ties()
return fitting_problem
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_data_problem_entries()
software = self._entries['software'].lower()
if not (software in import_success and import_success[software][0]):
e = import_success[software][1]
raise MissingSoftwareError('Requirements are missing for {} parser'
': {}'.format(software, e))
self._parsed_func = self._parse_function()
# NAME
fitting_problem.name = self._entries['name']
# DATA
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]
# FUNCTION
if software == 'mantid':
fitting_problem.function = self._create_mantid_function()
elif software == 'sasview':
fitting_problem.function = self._create_sasview_function()
# EQUATION
equation_count = len(self._parsed_func)
if equation_count == 1:
fitting_problem.equation = self._parsed_func[0]['name']
else:
fitting_problem.equation = '{} Functions'.format(equation_count)
if software == 'mantid':
# String containing the function name(s) and the starting parameter
# values for each function
fitting_problem._mantid_equation = self._entries['function']
# STARTING VALUES
fitting_problem.starting_values = self._get_starting_values()
# PARAMETER RANGES
vr = self._parse_range('parameter_ranges')
fitting_problem.value_ranges = vr if vr != {} else None
# FIT RANGES
fit_ranges = self._parse_range('fit_ranges')
try:
fitting_problem.start_x = fit_ranges['x'][0]
fitting_problem.end_x = fit_ranges['x'][1]
except KeyError:
pass
return fitting_problem