tessl/pypi-lmfit
Non-linear least-squares minimization and curve-fitting with enhanced parameter management and confidence interval estimation
—
Pending
parameters.mddocs/
Parameters and Constraints
LMFIT replaces plain float values with Parameter objects that can be varied, fixed, bounded, or constrained by mathematical expressions. The Parameters class provides a dictionary-like container for managing collections of Parameter objects with constraint evaluation.
Capabilities
Parameter Class
Individual parameter objects that form the foundation of all fitting operations in LMFIT.
class Parameter:
"""Individual parameter that can be varied in fits"""
def __init__(self, name=None, value=None, vary=True, min=-inf, max=inf,
expr=None, brute_step=None, user_data=None):
"""
Create a Parameter.
Args:
name (str): Parameter name
value (float): Parameter value
vary (bool): Whether parameter should be varied in fit
min (float): Lower bound for parameter value
max (float): Upper bound for parameter value
expr (str): Mathematical expression to constrain parameter
brute_step (float): Step size for brute force method
user_data: User-defined data associated with parameter
"""
def set(self, value=None, vary=None, min=None, max=None, expr=None,
brute_step=None):
"""
Set parameter attributes.
Args:
value (float): Parameter value
vary (bool): Whether to vary in fit
min (float): Lower bound
max (float): Upper bound
expr (str): Constraint expression
brute_step (float): Brute force step size
"""Key Attributes (set after fitting):
stderr: Standard error in parameter valuecorrel: Dictionary of correlation coefficients with other parameters
Parameters Class
Dictionary-like container for Parameter objects with constraint evaluation capabilities.
class Parameters(dict):
"""Dictionary of Parameter objects with constraint evaluation"""
def __init__(self, usersyms=None):
"""
Create Parameters container.
Args:
usersyms (dict): Additional symbols for expression evaluation
"""
def add(self, name, value=None, vary=None, min=-inf, max=inf,
expr=None, brute_step=None):
"""
Add a parameter.
Args:
name (str): Parameter name (must be valid Python identifier)
value (float): Initial value
vary (bool): Whether to vary in fit (default is True)
min (float): Lower bound
max (float): Upper bound
expr (str): Constraint expression using other parameter names
brute_step (float): Step size for brute force optimization
"""
def add_many(self, *parlist):
"""
Add multiple parameters from tuples.
Args:
*parlist: Tuples of (name, value, vary, min, max, expr, brute_step)
"""
def valuesdict(self):
"""
Get parameter values as dictionary.
Returns:
dict: Parameter names and their current values
"""
def pretty_print(self, oneline=False, colwidth=8, precision=4, fmt='g',
columns=['value', 'min', 'max', 'stderr', 'vary', 'expr', 'brute_step']):
"""
Print formatted parameter table.
Args:
oneline (bool): Print in single line format
colwidth (int): Column width for display
precision (int): Number precision for display
fmt (str): Number format string
columns (list): Columns to display
"""
def dumps(self, sort_keys=True, **kws):
"""
Serialize parameters to JSON string.
Args:
sort_keys (bool): Sort parameter names
**kws: Additional arguments for json.dumps
Returns:
str: JSON string representation
"""
def loads(self, s, **kws):
"""
Load parameters from JSON string.
Args:
s (str): JSON string
**kws: Additional arguments for json.loads
"""
def dump(self, fp, **kws):
"""
Serialize parameters to file.
Args:
fp: File-like object to write to
**kws: Additional arguments for json.dump
"""
def load(self, fp, **kws):
"""
Load parameters from file.
Args:
fp: File-like object to read from
**kws: Additional arguments for json.load
"""
def update_constraints(self):
"""Update all parameter constraint expressions"""
def create_uvars(self):
"""
Create uncertainties variables for error propagation.
Returns:
dict: Parameter names mapped to uncertainties.ufloat objects
"""Helper Functions
def create_params(**kws):
"""
Create Parameters instance with initial values.
Args:
**kws: Parameter names and initial values
Returns:
Parameters: Container with initialized parameters
Example:
params = create_params(x=1.0, y=2.0, z=3.0)
"""Usage Examples
Basic Parameter Creation
from lmfit import Parameters, Parameter
# Create individual parameters
param1 = Parameter('amplitude', value=10, min=0, max=100)
param2 = Parameter('center', value=5, vary=False) # fixed parameter
# Create Parameters container
params = Parameters()
params.add('amp', value=10, min=0)
params.add('cen', value=5)
params.add('wid', value=1, min=0.01, max=10)Parameter Constraints
# Constrained parameters using expressions
params = Parameters()
params.add('a', value=10, min=0)
params.add('b', value=5, min=0)
params.add('c', expr='2*a + sqrt(b)') # c depends on a and b
params.add('d', expr='a - b', min=0) # constrained difference
# Update constraint expressions
params.update_constraints()Bulk Parameter Addition
# Add multiple parameters at once
params = Parameters()
params.add_many(
('amp1', 10, True, 0, 50), # name, value, vary, min, max
('cen1', 5, True, 0, 10),
('wid1', 1, True, 0.01, 5),
('amp2', 8, True, 0, 50),
('cen2', 7, True, 0, 10),
('wid2', 1.5, True, 0.01, 5)
)Serialization
# Save parameters to JSON
json_str = params.dumps()
# Load parameters from JSON
new_params = Parameters()
new_params.loads(json_str)
# Save/load to/from file
with open('params.json', 'w') as f:
params.dump(f)
with open('params.json', 'r') as f:
params.load(f)Install with Tessl CLI
npx tessl i tessl/pypi-lmfit