From 9671845f6ffb7c2570f132987a6ee0149f336069 Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Tue, 28 Apr 2026 13:00:33 -0700
Subject: [PATCH 01/15] Reduce function building overhead in wrappedCircuit

In models/circuits/fittings.py, buildCircuit no longer substitutes parameters; rather it returns a string that can be used to construct  a lambda function. Subsequently wrapCircuit returns a lambda function that only needs to be generated once. This offers ~80% improvement.
---
 impedance/models/circuits/fitting.py     |  33 +-
 impedance/models/circuits/fitting_org.py | 445 +++++++++++++++++++++++
 impedance/tests/compare_newfitting.py    |  44 +++
 impedance/tests/test_fitting.py          |  47 ++-
 4 files changed, 537 insertions(+), 32 deletions(-)
 create mode 100644 impedance/models/circuits/fitting_org.py
 create mode 100644 impedance/tests/compare_newfitting.py

diff --git a/impedance/models/circuits/fitting.py b/impedance/models/circuits/fitting.py
index 5fe1c300..06d7f9d9 100644
--- a/impedance/models/circuits/fitting.py
+++ b/impedance/models/circuits/fitting.py
@@ -218,6 +218,10 @@ def __call__(self, **kwargs):
 
 def wrapCircuit(circuit, constants):
     """ wraps function so we can pass the circuit string """
+    buildCircuit_text=buildCircuit(circuit, constants=constants, 
+                        eval_string='', index=0)[0]
+    builtCircuit = eval('lambda frequencies,parameters : ' +  buildCircuit_text, circuit_elements)
+
     def wrappedCircuit(frequencies, *parameters):
         """ returns a stacked array of real and imaginary impedance
         components
@@ -235,19 +239,14 @@ def wrappedCircuit(frequencies, *parameters):
 
         """
 
-        x = eval(buildCircuit(circuit, frequencies, *parameters,
-                              constants=constants, eval_string='',
-                              index=0)[0],
-                 circuit_elements)
+        x = builtCircuit(frequencies,parameters)
         y_real = np.real(x)
         y_imag = np.imag(x)
 
         return np.hstack([y_real, y_imag])
     return wrappedCircuit
 
-
-def buildCircuit(circuit, frequencies, *parameters,
-                 constants=None, eval_string='', index=0):
+def buildCircuit(circuit, constants=None, eval_string='', index=0):
     """ recursive function that transforms a circuit, parameters, and
     frequencies into a string that can be evaluated
 
@@ -262,12 +261,15 @@ def buildCircuit(circuit, frequencies, *parameters,
     -------
     eval_string: str
         Python expression for calculating the resulting fit
+        This would a string that can be used to construct a lamda function. 
+        For example if circuit=R1,CPE1 with CPE1_1 = const1, eval_string = 
+        "p(R(frequencies,[parameters[0]), CPE(frequencies,[p[1],const1]))"; 
+        We can then construct lambda frequencies,parameters : <eval_string>
+
     index: int
         Tracks parameter index through recursive calling of the function
     """
 
-    parameters = np.array(parameters).tolist()
-    frequencies = np.array(frequencies).tolist()
     circuit = circuit.replace(' ', '')
 
     def parse_circuit(circuit, parallel=False, series=False):
@@ -327,12 +329,11 @@ def count_parens(string):
 
     for i, elem in enumerate(split):
         if ',' in elem or '-' in elem:
-            eval_string, index = buildCircuit(elem, frequencies,
-                                              *parameters,
-                                              constants=constants,
+            eval_string, index = buildCircuit(elem, constants=constants,
                                               eval_string=eval_string,
                                               index=index)
         else:
+            #Return a string that can be used to construct a lamda function lambda f,p : R(f,[p[0],const1,p[1]...])
             param_string = ""
             raw_elem = get_element_from_name(elem)
             elem_number = check_and_eval(raw_elem).num_params
@@ -344,13 +345,13 @@ def count_parens(string):
                     current_elem = elem
 
                 if current_elem in constants.keys():
-                    param_list.append(constants[current_elem])
+                    param_list.append(str(constants[current_elem]))
                 else:
-                    param_list.append(parameters[index])
+                    param_list.append(f'parameters[{index}]')
                     index += 1
 
-            param_string += str(param_list)
-            new = raw_elem + '(' + param_string + ',' + str(frequencies) + ')'
+            param_string = "[" + ','.join(param_list) + "]"
+            new = raw_elem + '(' + param_string + ', frequencies)'
             eval_string += new
 
         if i == len(split) - 1:
diff --git a/impedance/models/circuits/fitting_org.py b/impedance/models/circuits/fitting_org.py
new file mode 100644
index 00000000..5fe1c300
--- /dev/null
+++ b/impedance/models/circuits/fitting_org.py
@@ -0,0 +1,445 @@
+import warnings
+
+import numpy as np
+from scipy.linalg import inv
+from scipy.optimize import curve_fit, basinhopping
+
+from .elements import circuit_elements, get_element_from_name
+
+ints = '0123456789'
+
+
+def rmse(a, b):
+    """
+    A function which calculates the root mean squared error
+    between two vectors.
+
+    Notes
+    ---------
+    .. math::
+
+        RMSE = \\sqrt{\\frac{1}{n}(a-b)^2}
+    """
+
+    n = len(a)
+    return np.linalg.norm(a - b) / np.sqrt(n)
+
+
+def set_default_bounds(circuit, constants={}):
+    """ This function sets default bounds for optimization.
+
+    set_default_bounds sets bounds of 0 and np.inf for all parameters,
+    except the CPE and La alphas which have an upper bound of 1.
+
+    Parameters
+    -----------------
+    circuit : string
+        String defining the equivalent circuit to be fit
+
+    constants : dictionary, optional
+        Parameters and their values to hold constant during fitting
+        (e.g. {"RO": 0.1}). Defaults to {}
+
+    Returns
+    ------------
+    bounds : 2-tuple of array_like
+        Lower and upper bounds on parameters.
+    """
+
+    # extract the elements from the circuit
+    extracted_elements = extract_circuit_elements(circuit)
+
+    # loop through bounds
+    lower_bounds, upper_bounds = [], []
+    for elem in extracted_elements:
+        raw_element = get_element_from_name(elem)
+        for i in range(check_and_eval(raw_element).num_params):
+            if elem in constants or elem + f'_{i}' in constants:
+                continue
+            if raw_element in ['CPE', 'La'] and i == 1:
+                upper_bounds.append(1)
+            else:
+                upper_bounds.append(np.inf)
+            lower_bounds.append(0)
+
+    bounds = ((lower_bounds), (upper_bounds))
+    return bounds
+
+
+def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
+                bounds=None, weight_by_modulus=False, global_opt=False,
+                **kwargs):
+
+    """ Main function for fitting an equivalent circuit to data.
+
+    By default, this function uses `scipy.optimize.curve_fit
+    <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html>`_
+    to fit the equivalent circuit. This function generally works well for
+    simple circuits. However, the final results may be sensitive to
+    the initial conditions for more complex circuits. In these cases,
+    the `scipy.optimize.basinhopping
+    <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.basinhopping.html>`_
+    global optimization algorithm can be used to attempt a better fit.
+
+    Parameters
+    -----------------
+    frequencies : numpy array
+        Frequencies
+
+    impedances : numpy array of dtype 'complex128'
+        Impedances
+
+    circuit : string
+        String defining the equivalent circuit to be fit
+
+    initial_guess : list of floats
+        Initial guesses for the fit parameters
+
+    constants : dictionary, optional
+        Parameters and their values to hold constant during fitting
+        (e.g. {"RO": 0.1}). Defaults to {}
+
+    bounds : 2-tuple of array_like, optional
+        Lower and upper bounds on parameters. Defaults to bounds on all
+        parameters of 0 and np.inf, except the CPE alpha
+        which has an upper bound of 1
+
+    weight_by_modulus : bool, optional
+        Uses the modulus of each data (|Z|) as the weighting factor.
+        Standard weighting scheme when experimental variances are unavailable.
+        Only applicable when global_opt = False
+
+    global_opt : bool, optional
+        If global optimization should be used (uses the basinhopping
+        algorithm). Defaults to False
+
+    kwargs :
+        Keyword arguments passed to scipy.optimize.curve_fit or
+        scipy.optimize.basinhopping
+
+    Returns
+    ------------
+    p_values : list of floats
+        best fit parameters for specified equivalent circuit
+
+    p_errors : list of floats
+        one standard deviation error estimates for fit parameters
+
+    Notes
+    ---------
+    Need to do a better job of handling errors in fitting.
+    Currently, an error of -1 is returned.
+
+    """
+    f = np.array(frequencies, dtype=float)
+    Z = np.array(impedances, dtype=complex)
+
+    # set upper and lower bounds on a per-element basis
+    if bounds is None:
+        bounds = set_default_bounds(circuit, constants=constants)
+
+    if not global_opt:
+        if 'maxfev' not in kwargs:
+            kwargs['maxfev'] = 1e5
+        if 'ftol' not in kwargs:
+            kwargs['ftol'] = 1e-13
+
+        # weighting scheme for fitting
+        if weight_by_modulus:
+            abs_Z = np.abs(Z)
+            kwargs['sigma'] = np.hstack([abs_Z, abs_Z])
+
+        popt, pcov = curve_fit(wrapCircuit(circuit, constants), f,
+                               np.hstack([Z.real, Z.imag]),
+                               p0=initial_guess, bounds=bounds, **kwargs)
+
+        # Calculate one standard deviation error estimates for fit parameters,
+        # defined as the square root of the diagonal of the covariance matrix.
+        # https://stackoverflow.com/a/52275674/5144795
+        perror = np.sqrt(np.diag(pcov))
+
+    else:
+        if 'seed' not in kwargs:
+            kwargs['seed'] = 0
+
+        def opt_function(x):
+            """ Short function for basinhopping to optimize over.
+            We want to minimize the RMSE between the fit and the data.
+
+            Parameters
+            ----------
+            x : args
+                Parameters for optimization.
+
+            Returns
+            -------
+            function
+                Returns a function (RMSE as a function of parameters).
+            """
+            return rmse(wrapCircuit(circuit, constants)(f, *x),
+                        np.hstack([Z.real, Z.imag]))
+
+        class BasinhoppingBounds(object):
+            """ Adapted from the basinhopping documetation
+            https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.basinhopping.html
+            """
+
+            def __init__(self, xmin, xmax):
+                self.xmin = np.array(xmin)
+                self.xmax = np.array(xmax)
+
+            def __call__(self, **kwargs):
+                x = kwargs['x_new']
+                tmax = bool(np.all(x <= self.xmax))
+                tmin = bool(np.all(x >= self.xmin))
+                return tmax and tmin
+
+        basinhopping_bounds = BasinhoppingBounds(xmin=bounds[0],
+                                                 xmax=bounds[1])
+        results = basinhopping(opt_function, x0=initial_guess,
+                               accept_test=basinhopping_bounds, **kwargs)
+        popt = results.x
+
+        # Calculate perror
+        jac = results.lowest_optimization_result['jac'][np.newaxis]
+        try:
+            # jacobian -> covariance
+            # https://stats.stackexchange.com/q/231868
+            pcov = inv(np.dot(jac.T, jac)) * opt_function(popt) ** 2
+            # covariance -> perror (one standard deviation
+            # error estimates for fit parameters)
+            perror = np.sqrt(np.diag(pcov))
+        except (ValueError, np.linalg.LinAlgError):
+            warnings.warn('Failed to compute perror')
+            perror = None
+
+    return popt, perror
+
+
+def wrapCircuit(circuit, constants):
+    """ wraps function so we can pass the circuit string """
+    def wrappedCircuit(frequencies, *parameters):
+        """ returns a stacked array of real and imaginary impedance
+        components
+
+        Parameters
+        ----------
+        circuit : string
+        constants : dict
+        parameters : list of floats
+        frequencies : list of floats
+
+        Returns
+        -------
+        array of floats
+
+        """
+
+        x = eval(buildCircuit(circuit, frequencies, *parameters,
+                              constants=constants, eval_string='',
+                              index=0)[0],
+                 circuit_elements)
+        y_real = np.real(x)
+        y_imag = np.imag(x)
+
+        return np.hstack([y_real, y_imag])
+    return wrappedCircuit
+
+
+def buildCircuit(circuit, frequencies, *parameters,
+                 constants=None, eval_string='', index=0):
+    """ recursive function that transforms a circuit, parameters, and
+    frequencies into a string that can be evaluated
+
+    Parameters
+    ----------
+    circuit: str
+    frequencies: list/tuple/array of floats
+    parameters: list/tuple/array of floats
+    constants: dict
+
+    Returns
+    -------
+    eval_string: str
+        Python expression for calculating the resulting fit
+    index: int
+        Tracks parameter index through recursive calling of the function
+    """
+
+    parameters = np.array(parameters).tolist()
+    frequencies = np.array(frequencies).tolist()
+    circuit = circuit.replace(' ', '')
+
+    def parse_circuit(circuit, parallel=False, series=False):
+        """ Splits a circuit string by either dashes (series) or commas
+            (parallel) outside of any paranthesis. Removes any leading 'p('
+            or trailing ')' when in parallel mode """
+
+        assert parallel != series, \
+            'Exactly one of parallel or series must be True'
+
+        def count_parens(string):
+            return string.count('('), string.count(')')
+
+        if parallel:
+            special = ','
+            if circuit.endswith(')') and circuit.startswith('p('):
+                circuit = circuit[2:-1]
+        if series:
+            special = '-'
+
+        split = circuit.split(special)
+
+        result = []
+        skipped = []
+        for i, sub_str in enumerate(split):
+            if i not in skipped:
+                if '(' not in sub_str and ')' not in sub_str:
+                    result.append(sub_str)
+                else:
+                    open_parens, closed_parens = count_parens(sub_str)
+                    if open_parens == closed_parens:
+                        result.append(sub_str)
+                    else:
+                        uneven = True
+                        while i < len(split) - 1 and uneven:
+                            sub_str += special + split[i+1]
+
+                            open_parens, closed_parens = count_parens(sub_str)
+                            uneven = open_parens != closed_parens
+
+                            i += 1
+                            skipped.append(i)
+                        result.append(sub_str)
+        return result
+
+    parallel = parse_circuit(circuit, parallel=True)
+    series = parse_circuit(circuit, series=True)
+
+    if series is not None and len(series) > 1:
+        eval_string += "s(["
+        split = series
+    elif parallel is not None and len(parallel) > 1:
+        eval_string += "p(["
+        split = parallel
+    elif series == parallel:  # only single element
+        split = series
+
+    for i, elem in enumerate(split):
+        if ',' in elem or '-' in elem:
+            eval_string, index = buildCircuit(elem, frequencies,
+                                              *parameters,
+                                              constants=constants,
+                                              eval_string=eval_string,
+                                              index=index)
+        else:
+            param_string = ""
+            raw_elem = get_element_from_name(elem)
+            elem_number = check_and_eval(raw_elem).num_params
+            param_list = []
+            for j in range(elem_number):
+                if elem_number > 1:
+                    current_elem = elem + '_{}'.format(j)
+                else:
+                    current_elem = elem
+
+                if current_elem in constants.keys():
+                    param_list.append(constants[current_elem])
+                else:
+                    param_list.append(parameters[index])
+                    index += 1
+
+            param_string += str(param_list)
+            new = raw_elem + '(' + param_string + ',' + str(frequencies) + ')'
+            eval_string += new
+
+        if i == len(split) - 1:
+            if len(split) > 1:  # do not add closing brackets if single element
+                eval_string += '])'
+        else:
+            eval_string += ','
+
+    return eval_string, index
+
+
+def extract_circuit_elements(circuit):
+    """ Extracts circuit elements from a circuit string.
+
+    Parameters
+    ----------
+    circuit : str
+        Circuit string.
+
+    Returns
+    -------
+    extracted_elements : list
+        list of extracted elements.
+
+    """
+    p_string = [x for x in circuit if x not in 'p(),-']
+    extracted_elements = []
+    current_element = []
+    length = len(p_string)
+    for i, char in enumerate(p_string):
+        if char not in ints:
+            current_element.append(char)
+        else:
+            # min to prevent looking ahead past end of list
+            if p_string[min(i+1, length-1)] not in ints:
+                current_element.append(char)
+                extracted_elements.append(''.join(current_element))
+                current_element = []
+            else:
+                current_element.append(char)
+    extracted_elements.append(''.join(current_element))
+    return extracted_elements
+
+
+def calculateCircuitLength(circuit):
+    """ Calculates the number of elements in the circuit.
+
+    Parameters
+    ----------
+    circuit : str
+        Circuit string.
+
+    Returns
+    -------
+    length : int
+        Length of circuit.
+
+    """
+    length = 0
+    if circuit:
+        extracted_elements = extract_circuit_elements(circuit)
+        for elem in extracted_elements:
+            raw_element = get_element_from_name(elem)
+            num_params = check_and_eval(raw_element).num_params
+            length += num_params
+    return length
+
+
+def check_and_eval(element):
+    """ Checks if an element is valid, then evaluates it.
+
+    Parameters
+    ----------
+    element : str
+        Circuit element.
+
+    Raises
+    ------
+    ValueError
+        Raised if an element is not in the list of allowed elements.
+
+    Returns
+    -------
+    Evaluated element.
+
+    """
+    allowed_elements = circuit_elements.keys()
+    if element not in allowed_elements:
+        raise ValueError(f'{element} not in ' +
+                         f'allowed elements ({allowed_elements})')
+    else:
+        return eval(element, circuit_elements)
diff --git a/impedance/tests/compare_newfitting.py b/impedance/tests/compare_newfitting.py
new file mode 100644
index 00000000..ba548b22
--- /dev/null
+++ b/impedance/tests/compare_newfitting.py
@@ -0,0 +1,44 @@
+import sys; sys.path.insert(0, ".")
+'''
+Compares new buildCircuit with older buildCircuit
+R0-p(R1-Wo1,CPE1) : 82.97% faster
+R0-p(C1,R1,R2) : 79.30% faster
+R0-p(p(R1, C1)-R2, C2) : 82.17% faster
+p(C1,R1)-p(C2,R2) : 81.10% faster
+R1 : 85.55% faster
+'''
+
+from impedance.models.circuits.fitting import wrapCircuit
+from impedance.models.circuits.fitting_org import wrapCircuit as wrapCircuit_org
+import time
+
+
+def compare_newbuildCircuit():
+    data=[
+        # Test simple Randles circuit with CPE,
+        ('R0-p(R1-Wo1,CPE1)', [.1, .01, 1, 1000, 15, .9], [1000.0, 5.0, 0.01]), 
+        # Test multiple parallel elements, 
+        ('R0-p(C1,R1,R2)', [.1, .01, .2, .3], [1000.0, 5.0, 0.01]),
+        # Test nested parallel groups, 
+        ('R0-p(p(R1, C1)-R2, C2)', [1, 2, 3, 4, 5], [1000.0, 5.0, 0.01]),
+        # Test parallel elements at beginning and end,
+        ('p(C1,R1)-p(C2,R2)', [.1, .01, .2, .3], [1000.0, 5.0, 0.01]),
+        # Test single element circuit, 
+        ('R1', [100], [1000.0, 5.0, 0.01])
+    ]
+    dt_ratio=[]
+    for circuit, params, frequencies in data:
+        cktfn_new=wrapCircuit(circuit, constants={})
+        cktfn_org=wrapCircuit_org(circuit, constants={})
+        start = time.perf_counter()
+        [cktfn_org(frequencies,*params) for i in range(100)]
+        end = time.perf_counter()
+        dt_org = end-start
+        start = time.perf_counter()
+        [cktfn_new(frequencies,*params) for i in range(100)]
+        end = time.perf_counter()
+        dt_new = end-start
+        dt_ratio.append(f'{circuit} : {(1-dt_new/dt_org)*100:.2f} % faster')
+    print('\n'.join(dt_ratio))
+
+compare_newbuildCircuit()
diff --git a/impedance/tests/test_fitting.py b/impedance/tests/test_fitting.py
index 4bf9ca95..b09a551c 100644
--- a/impedance/tests/test_fitting.py
+++ b/impedance/tests/test_fitting.py
@@ -143,6 +143,15 @@ def test_circuit_fit():
                                    global_opt=True, seed=42)[0],
                        results_global, rtol=1e-1)
 
+import re
+def subsitute_values(buildCircuit_text, frequencies, parameters):
+    parameters=[float(p) for p in parameters]
+    frequencies=[float(p) for p in frequencies]
+    new_ckt_txt = buildCircuit_text.replace('frequencies',str(frequencies))
+    param_idx=re.findall(r'parameters\[(\d+)\]', new_ckt_txt)
+    for i in param_idx:
+        new_ckt_txt = new_ckt_txt.replace(f"parameters[{i}]",str(parameters[int(i)]))
+    return new_ckt_txt
 
 def test_buildCircuit():
 
@@ -151,8 +160,8 @@ def test_buildCircuit():
     params = [.1, .01, 1, 1000, 15, .9]
     frequencies = [1000.0, 5.0, 0.01]
 
-    assert buildCircuit(circuit, frequencies, *params,
-                        constants={})[0].replace(' ', '') == \
+    assert subsitute_values(buildCircuit(circuit,constants={})[0], frequencies, 
+                            params).replace(' ', '') == \
         's([R([0.1],[1000.0,5.0,0.01]),' + \
         'p([s([R([0.01],[1000.0,5.0,0.01]),' + \
         'Wo([1.0,1000.0],[1000.0,5.0,0.01])]),' + \
@@ -163,8 +172,8 @@ def test_buildCircuit():
     params = [.1, .01, .2, .3]
     frequencies = [1000.0, 5.0, 0.01]
 
-    assert buildCircuit(circuit, frequencies, *params,
-                        constants={})[0].replace(' ', '') == \
+    assert subsitute_values(buildCircuit(circuit,constants={})[0], frequencies, 
+                            params).replace(' ', '') == \
         's([R([0.1],[1000.0,5.0,0.01]),' + \
         'p([C([0.01],[1000.0,5.0,0.01]),' + \
         'R([0.2],[1000.0,5.0,0.01]),' + \
@@ -175,21 +184,21 @@ def test_buildCircuit():
     params = [1, 2, 3, 4, 5]
     frequencies = [1000.0, 5.0, 0.01]
 
-    assert buildCircuit(circuit, frequencies, *params,
-                        constants={})[0].replace(' ', '') == \
-        's([R([1],[1000.0,5.0,0.01]),' + \
-        'p([s([p([R([2],[1000.0,5.0,0.01]),' + \
-        'C([3],[1000.0,5.0,0.01])]),' + \
-        'R([4],[1000.0,5.0,0.01])]),' + \
-        'C([5],[1000.0,5.0,0.01])])])'
+    assert subsitute_values(buildCircuit(circuit,constants={})[0], frequencies, 
+                            params).replace(' ', '') == \
+        's([R([1.0],[1000.0,5.0,0.01]),' + \
+        'p([s([p([R([2.0],[1000.0,5.0,0.01]),' + \
+        'C([3.0],[1000.0,5.0,0.01])]),' + \
+        'R([4.0],[1000.0,5.0,0.01])]),' + \
+        'C([5.0],[1000.0,5.0,0.01])])])'
 
     # Test parallel elements at beginning and end
     circuit = 'p(C1,R1)-p(C2,R2)'
     params = [.1, .01, .2, .3]
     frequencies = [1000.0, 5.0, 0.01]
 
-    assert buildCircuit(circuit, frequencies, *params,
-                        constants={})[0].replace(' ', '') == \
+    assert subsitute_values(buildCircuit(circuit,constants={})[0], frequencies, 
+                            params).replace(' ', '') == \
         's([p([C([0.1],[1000.0,5.0,0.01]),' + \
         'R([0.01],[1000.0,5.0,0.01])]),' + \
         'p([C([0.2],[1000.0,5.0,0.01]),' + \
@@ -200,9 +209,9 @@ def test_buildCircuit():
     params = [100]
     frequencies = [1000.0, 5.0, 0.01]
 
-    assert buildCircuit(circuit, frequencies, *params,
-                        constants={})[0].replace(' ', '') == \
-        'R([100],[1000.0,5.0,0.01])'
+    assert subsitute_values(buildCircuit(circuit,constants={})[0], frequencies, 
+                            params).replace(' ', '') == \
+        'R([100.0],[1000.0,5.0,0.01])'
 
 
 def test_RMSE():
@@ -220,3 +229,9 @@ def test_element_extraction():
     circuit = 'R0-p(RR0,C1)-p(R1,C2032478)-W1'
     extracted_elements = extract_circuit_elements(circuit)
     assert extracted_elements == ['R0', 'RR0', 'C1', 'R1', 'C2032478', 'W1']
+
+# test_circuit_fit()
+# test_newbuildCircuit()
+# test_buildCircuit()
+# print("Passed")
+compare_newbuildCircuit()
\ No newline at end of file

From 0d5058997c404d55aeb26b4854727767931b6afb Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Tue, 28 Apr 2026 13:03:10 -0700
Subject: [PATCH 02/15] Removed benchmarking files

---
 impedance/models/circuits/fitting_org.py | 445 -----------------------
 impedance/tests/compare_newfitting.py    |  44 ---
 2 files changed, 489 deletions(-)
 delete mode 100644 impedance/models/circuits/fitting_org.py
 delete mode 100644 impedance/tests/compare_newfitting.py

diff --git a/impedance/models/circuits/fitting_org.py b/impedance/models/circuits/fitting_org.py
deleted file mode 100644
index 5fe1c300..00000000
--- a/impedance/models/circuits/fitting_org.py
+++ /dev/null
@@ -1,445 +0,0 @@
-import warnings
-
-import numpy as np
-from scipy.linalg import inv
-from scipy.optimize import curve_fit, basinhopping
-
-from .elements import circuit_elements, get_element_from_name
-
-ints = '0123456789'
-
-
-def rmse(a, b):
-    """
-    A function which calculates the root mean squared error
-    between two vectors.
-
-    Notes
-    ---------
-    .. math::
-
-        RMSE = \\sqrt{\\frac{1}{n}(a-b)^2}
-    """
-
-    n = len(a)
-    return np.linalg.norm(a - b) / np.sqrt(n)
-
-
-def set_default_bounds(circuit, constants={}):
-    """ This function sets default bounds for optimization.
-
-    set_default_bounds sets bounds of 0 and np.inf for all parameters,
-    except the CPE and La alphas which have an upper bound of 1.
-
-    Parameters
-    -----------------
-    circuit : string
-        String defining the equivalent circuit to be fit
-
-    constants : dictionary, optional
-        Parameters and their values to hold constant during fitting
-        (e.g. {"RO": 0.1}). Defaults to {}
-
-    Returns
-    ------------
-    bounds : 2-tuple of array_like
-        Lower and upper bounds on parameters.
-    """
-
-    # extract the elements from the circuit
-    extracted_elements = extract_circuit_elements(circuit)
-
-    # loop through bounds
-    lower_bounds, upper_bounds = [], []
-    for elem in extracted_elements:
-        raw_element = get_element_from_name(elem)
-        for i in range(check_and_eval(raw_element).num_params):
-            if elem in constants or elem + f'_{i}' in constants:
-                continue
-            if raw_element in ['CPE', 'La'] and i == 1:
-                upper_bounds.append(1)
-            else:
-                upper_bounds.append(np.inf)
-            lower_bounds.append(0)
-
-    bounds = ((lower_bounds), (upper_bounds))
-    return bounds
-
-
-def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
-                bounds=None, weight_by_modulus=False, global_opt=False,
-                **kwargs):
-
-    """ Main function for fitting an equivalent circuit to data.
-
-    By default, this function uses `scipy.optimize.curve_fit
-    <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html>`_
-    to fit the equivalent circuit. This function generally works well for
-    simple circuits. However, the final results may be sensitive to
-    the initial conditions for more complex circuits. In these cases,
-    the `scipy.optimize.basinhopping
-    <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.basinhopping.html>`_
-    global optimization algorithm can be used to attempt a better fit.
-
-    Parameters
-    -----------------
-    frequencies : numpy array
-        Frequencies
-
-    impedances : numpy array of dtype 'complex128'
-        Impedances
-
-    circuit : string
-        String defining the equivalent circuit to be fit
-
-    initial_guess : list of floats
-        Initial guesses for the fit parameters
-
-    constants : dictionary, optional
-        Parameters and their values to hold constant during fitting
-        (e.g. {"RO": 0.1}). Defaults to {}
-
-    bounds : 2-tuple of array_like, optional
-        Lower and upper bounds on parameters. Defaults to bounds on all
-        parameters of 0 and np.inf, except the CPE alpha
-        which has an upper bound of 1
-
-    weight_by_modulus : bool, optional
-        Uses the modulus of each data (|Z|) as the weighting factor.
-        Standard weighting scheme when experimental variances are unavailable.
-        Only applicable when global_opt = False
-
-    global_opt : bool, optional
-        If global optimization should be used (uses the basinhopping
-        algorithm). Defaults to False
-
-    kwargs :
-        Keyword arguments passed to scipy.optimize.curve_fit or
-        scipy.optimize.basinhopping
-
-    Returns
-    ------------
-    p_values : list of floats
-        best fit parameters for specified equivalent circuit
-
-    p_errors : list of floats
-        one standard deviation error estimates for fit parameters
-
-    Notes
-    ---------
-    Need to do a better job of handling errors in fitting.
-    Currently, an error of -1 is returned.
-
-    """
-    f = np.array(frequencies, dtype=float)
-    Z = np.array(impedances, dtype=complex)
-
-    # set upper and lower bounds on a per-element basis
-    if bounds is None:
-        bounds = set_default_bounds(circuit, constants=constants)
-
-    if not global_opt:
-        if 'maxfev' not in kwargs:
-            kwargs['maxfev'] = 1e5
-        if 'ftol' not in kwargs:
-            kwargs['ftol'] = 1e-13
-
-        # weighting scheme for fitting
-        if weight_by_modulus:
-            abs_Z = np.abs(Z)
-            kwargs['sigma'] = np.hstack([abs_Z, abs_Z])
-
-        popt, pcov = curve_fit(wrapCircuit(circuit, constants), f,
-                               np.hstack([Z.real, Z.imag]),
-                               p0=initial_guess, bounds=bounds, **kwargs)
-
-        # Calculate one standard deviation error estimates for fit parameters,
-        # defined as the square root of the diagonal of the covariance matrix.
-        # https://stackoverflow.com/a/52275674/5144795
-        perror = np.sqrt(np.diag(pcov))
-
-    else:
-        if 'seed' not in kwargs:
-            kwargs['seed'] = 0
-
-        def opt_function(x):
-            """ Short function for basinhopping to optimize over.
-            We want to minimize the RMSE between the fit and the data.
-
-            Parameters
-            ----------
-            x : args
-                Parameters for optimization.
-
-            Returns
-            -------
-            function
-                Returns a function (RMSE as a function of parameters).
-            """
-            return rmse(wrapCircuit(circuit, constants)(f, *x),
-                        np.hstack([Z.real, Z.imag]))
-
-        class BasinhoppingBounds(object):
-            """ Adapted from the basinhopping documetation
-            https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.basinhopping.html
-            """
-
-            def __init__(self, xmin, xmax):
-                self.xmin = np.array(xmin)
-                self.xmax = np.array(xmax)
-
-            def __call__(self, **kwargs):
-                x = kwargs['x_new']
-                tmax = bool(np.all(x <= self.xmax))
-                tmin = bool(np.all(x >= self.xmin))
-                return tmax and tmin
-
-        basinhopping_bounds = BasinhoppingBounds(xmin=bounds[0],
-                                                 xmax=bounds[1])
-        results = basinhopping(opt_function, x0=initial_guess,
-                               accept_test=basinhopping_bounds, **kwargs)
-        popt = results.x
-
-        # Calculate perror
-        jac = results.lowest_optimization_result['jac'][np.newaxis]
-        try:
-            # jacobian -> covariance
-            # https://stats.stackexchange.com/q/231868
-            pcov = inv(np.dot(jac.T, jac)) * opt_function(popt) ** 2
-            # covariance -> perror (one standard deviation
-            # error estimates for fit parameters)
-            perror = np.sqrt(np.diag(pcov))
-        except (ValueError, np.linalg.LinAlgError):
-            warnings.warn('Failed to compute perror')
-            perror = None
-
-    return popt, perror
-
-
-def wrapCircuit(circuit, constants):
-    """ wraps function so we can pass the circuit string """
-    def wrappedCircuit(frequencies, *parameters):
-        """ returns a stacked array of real and imaginary impedance
-        components
-
-        Parameters
-        ----------
-        circuit : string
-        constants : dict
-        parameters : list of floats
-        frequencies : list of floats
-
-        Returns
-        -------
-        array of floats
-
-        """
-
-        x = eval(buildCircuit(circuit, frequencies, *parameters,
-                              constants=constants, eval_string='',
-                              index=0)[0],
-                 circuit_elements)
-        y_real = np.real(x)
-        y_imag = np.imag(x)
-
-        return np.hstack([y_real, y_imag])
-    return wrappedCircuit
-
-
-def buildCircuit(circuit, frequencies, *parameters,
-                 constants=None, eval_string='', index=0):
-    """ recursive function that transforms a circuit, parameters, and
-    frequencies into a string that can be evaluated
-
-    Parameters
-    ----------
-    circuit: str
-    frequencies: list/tuple/array of floats
-    parameters: list/tuple/array of floats
-    constants: dict
-
-    Returns
-    -------
-    eval_string: str
-        Python expression for calculating the resulting fit
-    index: int
-        Tracks parameter index through recursive calling of the function
-    """
-
-    parameters = np.array(parameters).tolist()
-    frequencies = np.array(frequencies).tolist()
-    circuit = circuit.replace(' ', '')
-
-    def parse_circuit(circuit, parallel=False, series=False):
-        """ Splits a circuit string by either dashes (series) or commas
-            (parallel) outside of any paranthesis. Removes any leading 'p('
-            or trailing ')' when in parallel mode """
-
-        assert parallel != series, \
-            'Exactly one of parallel or series must be True'
-
-        def count_parens(string):
-            return string.count('('), string.count(')')
-
-        if parallel:
-            special = ','
-            if circuit.endswith(')') and circuit.startswith('p('):
-                circuit = circuit[2:-1]
-        if series:
-            special = '-'
-
-        split = circuit.split(special)
-
-        result = []
-        skipped = []
-        for i, sub_str in enumerate(split):
-            if i not in skipped:
-                if '(' not in sub_str and ')' not in sub_str:
-                    result.append(sub_str)
-                else:
-                    open_parens, closed_parens = count_parens(sub_str)
-                    if open_parens == closed_parens:
-                        result.append(sub_str)
-                    else:
-                        uneven = True
-                        while i < len(split) - 1 and uneven:
-                            sub_str += special + split[i+1]
-
-                            open_parens, closed_parens = count_parens(sub_str)
-                            uneven = open_parens != closed_parens
-
-                            i += 1
-                            skipped.append(i)
-                        result.append(sub_str)
-        return result
-
-    parallel = parse_circuit(circuit, parallel=True)
-    series = parse_circuit(circuit, series=True)
-
-    if series is not None and len(series) > 1:
-        eval_string += "s(["
-        split = series
-    elif parallel is not None and len(parallel) > 1:
-        eval_string += "p(["
-        split = parallel
-    elif series == parallel:  # only single element
-        split = series
-
-    for i, elem in enumerate(split):
-        if ',' in elem or '-' in elem:
-            eval_string, index = buildCircuit(elem, frequencies,
-                                              *parameters,
-                                              constants=constants,
-                                              eval_string=eval_string,
-                                              index=index)
-        else:
-            param_string = ""
-            raw_elem = get_element_from_name(elem)
-            elem_number = check_and_eval(raw_elem).num_params
-            param_list = []
-            for j in range(elem_number):
-                if elem_number > 1:
-                    current_elem = elem + '_{}'.format(j)
-                else:
-                    current_elem = elem
-
-                if current_elem in constants.keys():
-                    param_list.append(constants[current_elem])
-                else:
-                    param_list.append(parameters[index])
-                    index += 1
-
-            param_string += str(param_list)
-            new = raw_elem + '(' + param_string + ',' + str(frequencies) + ')'
-            eval_string += new
-
-        if i == len(split) - 1:
-            if len(split) > 1:  # do not add closing brackets if single element
-                eval_string += '])'
-        else:
-            eval_string += ','
-
-    return eval_string, index
-
-
-def extract_circuit_elements(circuit):
-    """ Extracts circuit elements from a circuit string.
-
-    Parameters
-    ----------
-    circuit : str
-        Circuit string.
-
-    Returns
-    -------
-    extracted_elements : list
-        list of extracted elements.
-
-    """
-    p_string = [x for x in circuit if x not in 'p(),-']
-    extracted_elements = []
-    current_element = []
-    length = len(p_string)
-    for i, char in enumerate(p_string):
-        if char not in ints:
-            current_element.append(char)
-        else:
-            # min to prevent looking ahead past end of list
-            if p_string[min(i+1, length-1)] not in ints:
-                current_element.append(char)
-                extracted_elements.append(''.join(current_element))
-                current_element = []
-            else:
-                current_element.append(char)
-    extracted_elements.append(''.join(current_element))
-    return extracted_elements
-
-
-def calculateCircuitLength(circuit):
-    """ Calculates the number of elements in the circuit.
-
-    Parameters
-    ----------
-    circuit : str
-        Circuit string.
-
-    Returns
-    -------
-    length : int
-        Length of circuit.
-
-    """
-    length = 0
-    if circuit:
-        extracted_elements = extract_circuit_elements(circuit)
-        for elem in extracted_elements:
-            raw_element = get_element_from_name(elem)
-            num_params = check_and_eval(raw_element).num_params
-            length += num_params
-    return length
-
-
-def check_and_eval(element):
-    """ Checks if an element is valid, then evaluates it.
-
-    Parameters
-    ----------
-    element : str
-        Circuit element.
-
-    Raises
-    ------
-    ValueError
-        Raised if an element is not in the list of allowed elements.
-
-    Returns
-    -------
-    Evaluated element.
-
-    """
-    allowed_elements = circuit_elements.keys()
-    if element not in allowed_elements:
-        raise ValueError(f'{element} not in ' +
-                         f'allowed elements ({allowed_elements})')
-    else:
-        return eval(element, circuit_elements)
diff --git a/impedance/tests/compare_newfitting.py b/impedance/tests/compare_newfitting.py
deleted file mode 100644
index ba548b22..00000000
--- a/impedance/tests/compare_newfitting.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import sys; sys.path.insert(0, ".")
-'''
-Compares new buildCircuit with older buildCircuit
-R0-p(R1-Wo1,CPE1) : 82.97% faster
-R0-p(C1,R1,R2) : 79.30% faster
-R0-p(p(R1, C1)-R2, C2) : 82.17% faster
-p(C1,R1)-p(C2,R2) : 81.10% faster
-R1 : 85.55% faster
-'''
-
-from impedance.models.circuits.fitting import wrapCircuit
-from impedance.models.circuits.fitting_org import wrapCircuit as wrapCircuit_org
-import time
-
-
-def compare_newbuildCircuit():
-    data=[
-        # Test simple Randles circuit with CPE,
-        ('R0-p(R1-Wo1,CPE1)', [.1, .01, 1, 1000, 15, .9], [1000.0, 5.0, 0.01]), 
-        # Test multiple parallel elements, 
-        ('R0-p(C1,R1,R2)', [.1, .01, .2, .3], [1000.0, 5.0, 0.01]),
-        # Test nested parallel groups, 
-        ('R0-p(p(R1, C1)-R2, C2)', [1, 2, 3, 4, 5], [1000.0, 5.0, 0.01]),
-        # Test parallel elements at beginning and end,
-        ('p(C1,R1)-p(C2,R2)', [.1, .01, .2, .3], [1000.0, 5.0, 0.01]),
-        # Test single element circuit, 
-        ('R1', [100], [1000.0, 5.0, 0.01])
-    ]
-    dt_ratio=[]
-    for circuit, params, frequencies in data:
-        cktfn_new=wrapCircuit(circuit, constants={})
-        cktfn_org=wrapCircuit_org(circuit, constants={})
-        start = time.perf_counter()
-        [cktfn_org(frequencies,*params) for i in range(100)]
-        end = time.perf_counter()
-        dt_org = end-start
-        start = time.perf_counter()
-        [cktfn_new(frequencies,*params) for i in range(100)]
-        end = time.perf_counter()
-        dt_new = end-start
-        dt_ratio.append(f'{circuit} : {(1-dt_new/dt_org)*100:.2f} % faster')
-    print('\n'.join(dt_ratio))
-
-compare_newbuildCircuit()

From 3332456f36eeb88b18361a324c7bc19fc697b9ea Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Tue, 28 Apr 2026 15:19:20 -0700
Subject: [PATCH 03/15] Clean-up of extraneous code

---
 impedance/tests/test_fitting.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/impedance/tests/test_fitting.py b/impedance/tests/test_fitting.py
index b09a551c..c7fb9504 100644
--- a/impedance/tests/test_fitting.py
+++ b/impedance/tests/test_fitting.py
@@ -230,8 +230,3 @@ def test_element_extraction():
     extracted_elements = extract_circuit_elements(circuit)
     assert extracted_elements == ['R0', 'RR0', 'C1', 'R1', 'C2032478', 'W1']
 
-# test_circuit_fit()
-# test_newbuildCircuit()
-# test_buildCircuit()
-# print("Passed")
-compare_newbuildCircuit()
\ No newline at end of file

From 851ef7756fb884ffabf86a708266652480551b8f Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Tue, 28 Apr 2026 16:15:51 -0700
Subject: [PATCH 04/15] Minor cleanup to call wrapCircuit separately

---
 impedance/models/circuits/fitting.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/impedance/models/circuits/fitting.py b/impedance/models/circuits/fitting.py
index 06d7f9d9..d3670a9d 100644
--- a/impedance/models/circuits/fitting.py
+++ b/impedance/models/circuits/fitting.py
@@ -137,7 +137,7 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
     # set upper and lower bounds on a per-element basis
     if bounds is None:
         bounds = set_default_bounds(circuit, constants=constants)
-
+    wrapedCircuit=wrapCircuit(circuit, constants)
     if not global_opt:
         if 'maxfev' not in kwargs:
             kwargs['maxfev'] = 1e5
@@ -149,7 +149,7 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
             abs_Z = np.abs(Z)
             kwargs['sigma'] = np.hstack([abs_Z, abs_Z])
 
-        popt, pcov = curve_fit(wrapCircuit(circuit, constants), f,
+        popt, pcov = curve_fit(wrapedCircuit, f,
                                np.hstack([Z.real, Z.imag]),
                                p0=initial_guess, bounds=bounds, **kwargs)
 
@@ -176,7 +176,7 @@ def opt_function(x):
             function
                 Returns a function (RMSE as a function of parameters).
             """
-            return rmse(wrapCircuit(circuit, constants)(f, *x),
+            return rmse(wrapedCircuit(f, *x),
                         np.hstack([Z.real, Z.imag]))
 
         class BasinhoppingBounds(object):

From 57641e2dac866d405f69ce21c7c1e014f45d7bbe Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Sun, 3 May 2026 11:10:48 -0700
Subject: [PATCH 05/15] Fixed BaseCircuit::predict for updated buildCircuit

---
 impedance/models/circuits/circuits.py | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/impedance/models/circuits/circuits.py b/impedance/models/circuits/circuits.py
index b670d198..69de51e8 100644
--- a/impedance/models/circuits/circuits.py
+++ b/impedance/models/circuits/circuits.py
@@ -134,20 +134,14 @@ def predict(self, frequencies, use_initial=False):
             Predicted impedance at each frequency
         """
         frequencies = np.array(frequencies, dtype=float)
-
+        buildCircuit_text=buildCircuit(self.circuit, constants=self.constants, 
+                            eval_string='', index=0)[0]
+        builtCircuit = eval('lambda frequencies,parameters : ' +  buildCircuit_text, circuit_elements)
         if self._is_fit() and not use_initial:
-            return eval(buildCircuit(self.circuit, frequencies,
-                                     *self.parameters_,
-                                     constants=self.constants, eval_string='',
-                                     index=0)[0],
-                        circuit_elements)
+            return builtCircuit(frequencies,self.parameters_)
         else:
             warnings.warn("Simulating circuit based on initial parameters")
-            return eval(buildCircuit(self.circuit, frequencies,
-                                     *self.initial_guess,
-                                     constants=self.constants, eval_string='',
-                                     index=0)[0],
-                        circuit_elements)
+            return builtCircuit(frequencies,self.initial_guess)
 
     def get_param_names(self):
         """ Converts circuit string to names and units """

From c33151401d76a8c12b0af7765229a43b27c94d3d Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Tue, 5 May 2026 07:33:37 -0700
Subject: [PATCH 06/15] Added option for multiple optimization algorithms

We can pass optimizations={"algorithm":algo,...} to circuit_fit.
Here  algo can be 'pygad' or 'scipy_minimize' or a callable. We can also pass optimizations=[optimizations1,optimizations2], where optimizations1={"algorithm":algo,...} ... to perform sequential optimization.
To improve scaling, we can pass scale=[..] with the expected relative magnitude of the different parameters.
---
 impedance/models/circuits/fitting.py | 228 ++++++++++++++++++++++++++-
 impedance/tests/test_circuits.py     |  27 ++++
 impedance/tests/test_fitting.py      | 146 +++++++++++++++++
 3 files changed, 396 insertions(+), 5 deletions(-)

diff --git a/impedance/models/circuits/fitting.py b/impedance/models/circuits/fitting.py
index d3670a9d..e84036f9 100644
--- a/impedance/models/circuits/fitting.py
+++ b/impedance/models/circuits/fitting.py
@@ -8,6 +8,7 @@
 
 ints = '0123456789'
 
+from warnings import warn
 
 def rmse(a, b):
     """
@@ -66,9 +67,30 @@ def set_default_bounds(circuit, constants={}):
     return bounds
 
 
+def scale_bounds(bounds,n_guess,scale):
+    b0 = np.atleast_1d(bounds[0])
+    b1 = np.atleast_1d(bounds[1])
+    if len(b0) == 1:
+        b0 = np.repeat(b0[0], n_guess)
+    if len(b1) == 1:
+        b1 = np.repeat(b1[0], n_guess)
+    bounds = (b0, b1)
+    if scale is None:
+        scale = np.ones(n_guess)
+    else:
+        scale = np.array(scale, dtype=float)
+    scaled_low = np.array(bounds[0], dtype=float) / scale
+    scaled_high = np.array(bounds[1], dtype=float) / scale
+    return scaled_low,scaled_high
+
+def is_scalarval(var,val):
+    if isinstance(var,(list,np.ndarray)): return False
+    if var != val: return False
+    return True
+
 def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
                 bounds=None, weight_by_modulus=False, global_opt=False,
-                **kwargs):
+                optimizations=[], scale=None, **kwargs):
 
     """ Main function for fitting an equivalent circuit to data.
 
@@ -113,9 +135,24 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
         If global optimization should be used (uses the basinhopping
         algorithm). Defaults to False
 
+    optimizations : dict or list of dicts, optional
+        If global_opt is True, gets set to "basinhopping"
+        Else 
+            If optimizations is not passed, curve_fit is used.
+            If dict(s), it must algorithm + algorithm options
+                "algorithm" is mandatory. eg : {"algorithm" : 'scipy_minimize', 'method' : ...} or {"algorithm" : 'pygad', 'gene_space' : ...} 
+            List could be a list of dics (in the above format). This is used for sequential optimizations, particularly useful for GA.
+
+    scale : list, optional
+        Used to denote "scale" of prameters to improve convergence.
+        Consider a p(R,C) or R-C circuit. Suppose C-s is in μF while, 
+        R-s might be in ~0.1 ohms; we can pass [0.1,1e-6].
+        Internally the parameters are divided by scale during optimization.
+
     kwargs :
         Keyword arguments passed to scipy.optimize.curve_fit or
         scipy.optimize.basinhopping
+        One can also pass a callable soft_constraint that adds a penalty for arbitary constraints. 
 
     Returns
     ------------
@@ -131,6 +168,7 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
     Currently, an error of -1 is returned.
 
     """
+    kwargs_org = kwargs
     f = np.array(frequencies, dtype=float)
     Z = np.array(impedances, dtype=complex)
 
@@ -138,7 +176,55 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
     if bounds is None:
         bounds = set_default_bounds(circuit, constants=constants)
     wrapedCircuit=wrapCircuit(circuit, constants)
-    if not global_opt:
+
+    if global_opt:
+        warn('global_opt has been deprecated. Use optimizations={"algorithm" : "basinhopping"}' \
+        ' OR optimizations="basinhopping"', DeprecationWarning, 2)
+        opt={"algorithm" : 'basinhopping'}
+        optimizations=[]
+    elif optimizations == []:
+        opt={"algorithm" : 'curve_fit'}
+    elif isinstance(optimizations,(list)) :
+        opt=optimizations.pop(0) 
+    else :
+        opt=optimizations
+        optimizations=[]
+        
+    if not isinstance(opt,dict) : opt={"algorithm" : opt}
+
+    target_Z = np.hstack([Z.real, Z.imag])
+    sigma = kwargs.pop('sigma', 1)
+
+    soft_constraint = kwargs.pop('soft_constraint', lambda p : 0)
+
+    if opt["algorithm"] in ('scipy_minimize','pygad') or callable(opt["algorithm"]):
+        if scale is None : 
+            scale = 1
+            warnings.warn("'scale' is recommeded for scipy_minimize...")
+        scaled_low, scaled_high = scale_bounds(bounds,len(initial_guess),scale)
+        def obj_fn(p_scaled):
+            p_unscaled = p_scaled * scale
+            try:
+                pred_Z = wrapedCircuit(f, *p_unscaled)
+                error =  np.sum(((pred_Z - target_Z) / sigma)**2) + soft_constraint(p_unscaled)
+            except Exception:
+                return np.inf
+            return error
+        pbar = None
+        show_progress = opt.pop('show_progress', 
+                    kwargs.get('show_progress', True))
+        if show_progress:
+            if opt["algorithm"] ==  'pygad':
+                maxiter = opt.get('num_generations', 1000)
+            else:
+                maxiter = kwargs.get('options', {}).get('maxiter', None)
+            try:
+                from tqdm.auto import tqdm
+                pbar = tqdm(total=maxiter, desc="circuit fit")
+            except ImportError:
+                warn('tqdm not found, progress cannot be plotted !!!')
+    
+    if opt["algorithm"] == 'curve_fit':
         if 'maxfev' not in kwargs:
             kwargs['maxfev'] = 1e5
         if 'ftol' not in kwargs:
@@ -150,7 +236,7 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
             kwargs['sigma'] = np.hstack([abs_Z, abs_Z])
 
         popt, pcov = curve_fit(wrapedCircuit, f,
-                               np.hstack([Z.real, Z.imag]),
+                               target_Z,
                                p0=initial_guess, bounds=bounds, **kwargs)
 
         # Calculate one standard deviation error estimates for fit parameters,
@@ -158,7 +244,7 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
         # https://stackoverflow.com/a/52275674/5144795
         perror = np.sqrt(np.diag(pcov))
 
-    else:
+    elif opt["algorithm"] == 'basinhopping':
         if 'seed' not in kwargs:
             kwargs['seed'] = 0
 
@@ -213,8 +299,140 @@ def __call__(self, **kwargs):
             warnings.warn('Failed to compute perror')
             perror = None
 
-    return popt, perror
+    elif opt["algorithm"] == 'scipy_minimize':
+        method = opt.pop('method', 'L-BFGS-B')
+        print(f"Running {opt['algorithm']} with {method}...")
+
+        from scipy.optimize import minimize
+        user_callback = kwargs.pop('callback', None)
+        def combined_callback(xk, *args, **kwds):
+            if pbar is not None:
+                pbar.update(1)
+            if user_callback is not None:
+                user_callback(xk, *args, **kwds)
+
+        min_bounds_scaled = list(zip(scaled_low, scaled_high))
+        res = minimize(obj_fn, initial_guess, bounds=min_bounds_scaled, callback=combined_callback, **kwargs)
+        if pbar is not None:
+            pbar.close()
+        popt = res.x * scale
+        if hasattr(res, 'hess_inv'):
+            pcov = res.hess_inv
+            if hasattr(pcov, "todense"): pcov = pcov.todense()
+            pcov = pcov * np.outer(scale, scale)
+        else:
+            pcov = np.zeros((len(popt), len(popt)))
+        perror = np.sqrt(np.diag(pcov))
 
+    elif opt["algorithm"] == 'pygad':
+        print(f"Running {opt['algorithm']}...")
+        import pygad
+
+        def fitness_func(ga_instance, solution, solution_idx):
+            return 1./obj_fn(solution)
+
+        gene_space = opt.pop('gene_space', None)
+        if gene_space is None and scaled_low is not None:
+            gene_space = [{'low': low, 'high': high} for low, high in zip(scaled_low, scaled_high)]
+
+        num_generations = opt.pop('num_generations', 1000)
+        num_parents_mating = opt.pop('num_parents_mating', 4)
+        sol_per_pop = opt.pop('sol_per_pop', 20)
+        num_genes=len(initial_guess)
+        
+        initial_population = opt.pop('initial_population', None)
+        if initial_population is None:
+            if scaled_low is None:
+                raise ValueError("Bounds must be provided for PyGAD optimization to generate the initial population.")
+            
+            if np.any(np.isinf(scaled_low)) or np.any(np.isinf(scaled_high)):
+                raise ValueError("Bounds must be finite for PyGAD optimization to generate the initial population.")
+                
+            initial_population = np.empty((sol_per_pop, num_genes))
+            initial_population[0] = np.array(initial_guess) / scale
+            
+            for i in range(1, sol_per_pop):
+                initial_population[i] = np.random.uniform(scaled_low, scaled_high)
+                
+            initial_population = np.clip(initial_population, scaled_low, scaled_high)
+        else:
+            initial_population = np.array(initial_population) / scale
+
+        plot_pygad = opt.pop('plot', False)
+        user_on_generation = opt.pop('on_generation', None)
+            
+        def on_generation(ga_instance):
+            if pbar is not None:
+                pbar.update(1)
+            if user_on_generation:
+                user_on_generation(ga_instance)
+
+        ga_instance = pygad.GA(num_generations=num_generations,
+                                num_parents_mating=num_parents_mating,
+                                fitness_func=fitness_func,
+                                initial_population=initial_population,
+                                sol_per_pop=sol_per_pop,
+                                num_genes=num_genes,
+                                gene_space=gene_space,
+                                on_generation=on_generation,
+                                parent_selection_type=opt.pop('parent_selection_type', 'sss'), #'tournament'
+                                keep_elitism=opt.pop('keep_elitism', 1),
+                                **kwargs)
+        ga_instance.run()
+        if pbar is not None:
+            pbar.close()
+            
+        if plot_pygad:
+            ga_instance.plot_fitness()
+
+        solution, solution_fitness, solution_idx = ga_instance.best_solution()
+        popt = solution * scale
+        pcov = np.zeros((len(popt), len(popt)))        
+        perror = np.sqrt(np.diag(pcov))
+
+    elif callable(opt["algorithm"]):
+        algo=opt.pop('algorithm')
+        import inspect
+        sig = inspect.signature(algo)
+        valid_params = sig.parameters
+        
+        call_kwargs = {}
+        # Map parameters dynamically based on the callable's signature
+        if 'initial_guess' in valid_params:
+            call_kwargs['initial_guess'] = initial_guess
+        elif 'x0' in valid_params: # Standard scipy optimize param
+            call_kwargs['x0'] = initial_guess
+        else:
+            warn('Initial guess was ignored')
+        if 'bounds' in valid_params:
+            call_kwargs['bounds'] = bounds
+        else:
+            warn('bounds was ignored')
+        if 'scale' in valid_params:
+            call_kwargs['scale'] = scale
+        elif not is_scalarval(scale,1): #scale != 1 : 
+            warn('scale was ignored')
+        if 'fun' in valid_params:
+            call_kwargs['fun'] = obj_fn
+        else:
+            warn('objective function was ignored (as callable does not accept "fun" parameter)')
+            
+        accepts_kwargs = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in valid_params.values())
+        for k, v in opt.items():
+            if k in valid_params or accepts_kwargs:
+                call_kwargs[k] = v
+                
+        res = algo(**call_kwargs)
+        popt = res.x if hasattr(res, 'x') else res
+        pcov = np.zeros((len(popt), len(popt)))        
+        perror = np.sqrt(np.diag(pcov))
+    else:
+        raise ValueError(f"Unknown optimization algorithm: {opt['algorithm']}")
+    if len(optimizations) > 0:
+        return circuit_fit(frequencies, impedances, circuit, initial_guess=popt, constants=constants,
+                bounds=bounds, weight_by_modulus=weight_by_modulus, global_opt=False, optimizations=optimizations, scale=scale, **kwargs_org)
+    else:
+        return popt, perror
 
 def wrapCircuit(circuit, constants):
     """ wraps function so we can pass the circuit string """
diff --git a/impedance/tests/test_circuits.py b/impedance/tests/test_circuits.py
index ec0e5c32..b3081261 100644
--- a/impedance/tests/test_circuits.py
+++ b/impedance/tests/test_circuits.py
@@ -6,6 +6,7 @@
 import pytest
 
 from impedance.models.circuits import BaseCircuit, CustomCircuit, Randles
+from impedance.models.circuits.fitting import rmse
 
 # get example data
 data = np.genfromtxt(os.path.join("./data/",
@@ -198,3 +199,29 @@ def test_CustomCircuit():
     circuit = circuit = 'R0-p(R1, C1)'
     initial_guess = [1, 2, 3]
     circuit = CustomCircuit(circuit, initial_guess=initial_guess)
+
+from .test_fitting import test_data
+def test_CustomCircuitwAlgorithm():
+    data = test_data()
+    optimizations={'algorithm':'pygad'}
+    for d in data :
+        if len(d) == 7:
+            circuit, initial_guess, scale, results, bounds, frequencies, Z = d
+            constants={}
+        elif len(d) == 8:
+            circuit, initial_guess, constants, scale, results, bounds, frequencies, Z = d
+        else: raise Exception(f"Unexpected data length: {len(d)}")
+        custom_circuit = CustomCircuit(initial_guess=initial_guess,
+                                   circuit=circuit,constants=constants)
+        custom_circuit.fit(frequencies, Z, bounds=bounds, optimizations=optimizations.copy(), scale=scale)
+        assert custom_circuit._is_fit()
+        param = custom_circuit.parameters_
+        Z_fit = custom_circuit.predict(frequencies=frequencies)
+        err = rmse(Z,Z_fit)
+        if not np.allclose(results,param, rtol=1e-1):
+            print(f'Failed {circuit}: {results} != {param}; RMSE={err}')
+        else:
+            print(f'Passed {circuit}')        
+        custom_circuit.plot(f_data=frequencies, Z_data=Z, kind="nyquist")
+        plt.show()
+ 
diff --git a/impedance/tests/test_fitting.py b/impedance/tests/test_fitting.py
index c7fb9504..14bf746f 100644
--- a/impedance/tests/test_fitting.py
+++ b/impedance/tests/test_fitting.py
@@ -143,6 +143,152 @@ def test_circuit_fit():
                                    global_opt=True, seed=42)[0],
                        results_global, rtol=1e-1)
 
+from impedance.models.circuits.elements import circuit_elements
+import matplotlib.pyplot as plt
+
+def plot_nyquist_compare(Z, Z_fit, scale=1, units='Ohms', fmt=['-',"*"], ax=None, labelsize=20,
+                 ticksize=14, **kwargs):
+    """ Plots impedance as a Nyquist plot using matplotlib
+
+        Parameters
+        ----------
+        Z: np.array of complex numbers
+            impedance data
+        scale: float
+            the scale for the axes
+        units: string
+            units for :math:`Z(\\omega)`
+        fmt: string
+            format string passed to matplotlib (e.g. '.-' or 'o')
+        ax: matplotlib.axes.Axes (optional)
+            axes on which to plot the nyquist plot
+
+        Other Parameters
+        ----------------
+        **kwargs : `matplotlib.pyplot.Line2D` properties, optional
+            Used to specify line properties like linewidth, line color,
+            marker color, and line labels.
+
+        Returns
+        -------
+        ax: matplotlib.axes.Axes
+    """
+    Z = np.array(Z, dtype=complex)
+    Z_fit = np.array(Z_fit, dtype=complex)
+
+    if ax is None:
+        _, ax = plt.subplots()
+
+    ax.plot(np.real(Z), -np.imag(Z), fmt[0], label="Origial", **kwargs)
+    ax.plot(np.real(Z_fit), -np.imag(Z_fit), fmt[1], label="Fit", **kwargs)
+    ax.legend()
+
+    # Make the axes square
+    ax.set_aspect('equal')
+
+    # Set the labels to -imaginary vs real
+    ax.set_xlabel(r'$Z^{\prime}(\omega)$ ' +
+                  '$[{}]$'.format(units), fontsize=labelsize)
+    ax.set_ylabel(r'$-Z^{\prime\prime}(\omega)$ ' +
+                  '$[{}]$'.format(units), fontsize=labelsize)
+
+    # Make the tick labels larger
+    ax.tick_params(axis='both', which='major', labelsize=ticksize)
+
+    # Change the number of labels on each axis to five
+    ax.locator_params(axis='x', nbins=5, tight=True)
+    ax.locator_params(axis='y', nbins=5, tight=True)
+
+    # Add a light grid
+    ax.grid(visible=True, which='major', axis='both', alpha=.5)
+
+    # Change axis units to 10**log10(scale) and resize the offset text
+    limits = -np.log10(scale)
+    if limits != 0:
+        ax.ticklabel_format(style='sci', axis='both',
+                            scilimits=(limits, limits))
+    y_offset = ax.yaxis.get_offset_text()
+    y_offset.set_size(18)
+    t = ax.xaxis.get_offset_text()
+    t.set_size(18)
+
+    # return ax
+    plt.show()
+
+def test_data():
+    example_frequencies_filtered, \
+        Z_correct_filtered = ignoreBelowX(example_frequencies, Z_correct)
+    data=[#circuit, initial_guess, scale, results, bounds, frequencies, Z_data]  # Test trivial model (10 Ohm resistor)
+    ('R0', [10], [10], [10], [0,100], np.array([10, 100, 1000]), np.array([10, 10, 10])),
+    # ('R0', [10], [10], [10], [0,100], [10, 100, 1000],[10, 10, 10]),
+    (
+        'R0-p(R1,C1)-p(R2-Wo1,C2)',[.01, .01, 100, .01, .05, 100, 1],np.array([1e-2,1e-2,0.1,1e-2,1e-1,1e3,1]), 
+        [1.65e-2, 5.34e-3, 0.22, 9.15e-3, 1.31e-1, 1.10e3, 2.78],[(0, 0, 0, 0, 0, 0, 0),(10, 1, 1e3, 1, 1, 1e4, 100)],
+        example_frequencies_filtered, Z_correct_filtered
+    )]
+    return data
+
+def test_circuit_fit_ga():
+    data = test_data()
+    optimizations={'algorithm':'pygad'}
+    for circuit, initial_guess, scale, results, bounds, frequencies, Z_data in data :
+        constants={}
+        buildCircuit_text=buildCircuit(circuit, constants=constants, eval_string='', index=0)[0]
+        builtCircuit = eval('lambda frequencies,parameters : ' +  buildCircuit_text, circuit_elements)
+
+        calc = circuit_fit(frequencies, Z_data, circuit,
+                                   initial_guess, constants={},
+                                   optimizations=optimizations.copy(),scale=scale,bounds=bounds)[0]
+        f = np.array(frequencies, dtype=float)
+        Z_fit = builtCircuit(f,calc)
+        err = rmse(Z_data,Z_fit)
+        if not np.allclose(results,calc, rtol=1e-1):
+            print(f'Failed {circuit}: {results} != {calc}; RMSE={err}')
+            plot_nyquist_compare(Z_data,Z_fit)
+        else:
+            print(f'Passed {circuit}')
+            
+def test_circuit_fit_callable():
+    from scipy.optimize import least_squares
+    data = test_data()
+    optimizations={'algorithm':least_squares,'method':'trf'}
+    for circuit, initial_guess, scale, results, bounds, frequencies, Z_data in data :
+        constants={}
+        buildCircuit_text=buildCircuit(circuit, constants=constants, eval_string='', index=0)[0]
+        builtCircuit = eval('lambda frequencies,parameters : ' +  buildCircuit_text, circuit_elements)
+
+        calc = circuit_fit(frequencies, Z_data, circuit,
+                                   initial_guess, constants={},
+                                   optimizations=optimizations.copy(),scale=scale,bounds=bounds)[0]
+        f = np.array(frequencies, dtype=float)
+        Z_fit = builtCircuit(f,calc)
+        err = rmse(Z_data,Z_fit)
+        if not np.allclose(results,calc, rtol=1e-1):
+            print(f'Failed {circuit}: {results} != {calc}; RMSE={err}')
+            # plot_nyquist_compare(Z_data,Z_fit)
+        else:
+            print(f'Passed {circuit}')
+
+def test_circuit_fit_seq():
+    data = test_data()
+    optimizations=[{'algorithm':'pygad'},{'algorithm':'scipy_minimize'}]
+    for circuit, initial_guess, scale, results, bounds, frequencies, Z_data in data :
+        constants={}
+        buildCircuit_text=buildCircuit(circuit, constants=constants, eval_string='', index=0)[0]
+        builtCircuit = eval('lambda frequencies,parameters : ' +  buildCircuit_text, circuit_elements)
+
+        calc = circuit_fit(frequencies, Z_data, circuit,
+                                   initial_guess, constants={},
+                                   optimizations=optimizations.copy(),scale=scale,bounds=bounds)[0]
+        f = np.array(frequencies, dtype=float)
+        Z_fit = builtCircuit(f,calc)
+        err = rmse(Z_data,Z_fit)
+        if not np.allclose(results,calc, rtol=1e-1):
+            print(f'Failed {circuit}: {results} != {calc}; RMSE={err}')
+            plot_nyquist_compare(Z_data,Z_fit)
+        else:
+            print(f'Passed {circuit}')
+
 import re
 def subsitute_values(buildCircuit_text, frequencies, parameters):
     parameters=[float(p) for p in parameters]

From bb73ac9e2f133940d83284aaea64f967432180d1 Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Wed, 6 May 2026 09:25:02 -0700
Subject: [PATCH 07/15] Added PSO using pyswarms

---
 impedance/models/circuits/fitting.py | 135 +++++++++++++++++++++++----
 impedance/tests/test_fitting.py      |  30 +++++-
 2 files changed, 148 insertions(+), 17 deletions(-)

diff --git a/impedance/models/circuits/fitting.py b/impedance/models/circuits/fitting.py
index e84036f9..1c9ca9f5 100644
--- a/impedance/models/circuits/fitting.py
+++ b/impedance/models/circuits/fitting.py
@@ -1,4 +1,19 @@
 import warnings
+import os
+
+#module:impedance/models/circuits/
+def _custom_formatwarning(msg, category, filename, lineno, line=None):
+    norm_path = os.path.normpath(filename)
+    path_parts = norm_path.split(os.sep)
+    if 'impedance' in path_parts:
+        display_name = ".".join(path_parts[path_parts.index('impedance'):])
+        if display_name.endswith('.py'):
+            display_name = display_name[:-3]
+    else:
+        display_name = os.path.basename(filename)
+    return f"{display_name}:{lineno}: {category.__name__}: {msg}\n"
+
+warnings.formatwarning = _custom_formatwarning
 
 import numpy as np
 from scipy.linalg import inv
@@ -68,19 +83,40 @@ def set_default_bounds(circuit, constants={}):
 
 
 def scale_bounds(bounds,n_guess,scale):
-    b0 = np.atleast_1d(bounds[0])
-    b1 = np.atleast_1d(bounds[1])
-    if len(b0) == 1:
-        b0 = np.repeat(b0[0], n_guess)
-    if len(b1) == 1:
-        b1 = np.repeat(b1[0], n_guess)
-    bounds = (b0, b1)
+    #We should either accept [(0,0.1),(0,100),(0,0.01),(0,10),(0,1)] or [(0,0,...),[0.1,100,...]] or [0, [0.1,100,...]]; This should also work when n_guess=2
+    is_format_1 = False
+    
+    if len(bounds) == n_guess and len(bounds) != 2:
+        is_format_1 = True
+    elif len(bounds) == 2:
+        if n_guess == 2:
+            if isinstance(bounds, list) and isinstance(bounds[0], tuple):
+                is_format_1 = True
+            else:
+                is_format_1 = False
+        else:
+            is_format_1 = False
+    else:
+        is_format_1 = True
+
+    if is_format_1:
+        b0 = np.array([b[0] for b in bounds])
+        b1 = np.array([b[1] for b in bounds])
+    else:
+        b0 = np.atleast_1d(bounds[0])
+        b1 = np.atleast_1d(bounds[1])
+        if len(b0) == 1:
+            b0 = np.repeat(b0[0], n_guess)
+        if len(b1) == 1:
+            b1 = np.repeat(b1[0], n_guess)
+
     if scale is None:
         scale = np.ones(n_guess)
     else:
         scale = np.array(scale, dtype=float)
-    scaled_low = np.array(bounds[0], dtype=float) / scale
-    scaled_high = np.array(bounds[1], dtype=float) / scale
+        
+    scaled_low = np.array(b0, dtype=float) / scale
+    scaled_high = np.array(b1, dtype=float) / scale
     return scaled_low,scaled_high
 
 def is_scalarval(var,val):
@@ -182,7 +218,7 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
         ' OR optimizations="basinhopping"', DeprecationWarning, 2)
         opt={"algorithm" : 'basinhopping'}
         optimizations=[]
-    elif optimizations == []:
+    elif optimizations == [] or optimizations == {} :
         opt={"algorithm" : 'curve_fit'}
     elif isinstance(optimizations,(list)) :
         opt=optimizations.pop(0) 
@@ -197,11 +233,17 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
 
     soft_constraint = kwargs.pop('soft_constraint', lambda p : 0)
 
-    if opt["algorithm"] in ('scipy_minimize','pygad') or callable(opt["algorithm"]):
-        if scale is None : 
-            scale = 1
-            warnings.warn("'scale' is recommeded for scipy_minimize...")
-        scaled_low, scaled_high = scale_bounds(bounds,len(initial_guess),scale)
+    algo=opt["algorithm"]
+    if algo in ('scipy_minimize','pygad','pyswarms') or callable(opt["algorithm"]):
+        needscale=True
+        if callable(algo):
+            sig = inspect.signature(algo)
+            if 'scale' not in sig.parameters: needscale=False
+        if needscale and scale is None : 
+            scale = 10 ** np.round(np.log10(np.abs(initial_guess) + np.finfo(float).eps))
+            warnings.warn(f"'scale' is recommeded for {str(algo)}. Using scale from initial_guess.")
+            
+        scaled_low, scaled_high = scale_bounds(bounds, len(initial_guess), scale)
         def obj_fn(p_scaled):
             p_unscaled = p_scaled * scale
             try:
@@ -216,11 +258,13 @@ def obj_fn(p_scaled):
         if show_progress:
             if opt["algorithm"] ==  'pygad':
                 maxiter = opt.get('num_generations', 1000)
+            elif opt["algorithm"] == 'pyswarms':
+                maxiter = opt.get('iters', 1000)
             else:
                 maxiter = kwargs.get('options', {}).get('maxiter', None)
             try:
                 from tqdm.auto import tqdm
-                pbar = tqdm(total=maxiter, desc="circuit fit")
+                pbar = tqdm(total=maxiter, desc="Circuit fit using " + str(opt["algorithm"]))
             except ImportError:
                 warn('tqdm not found, progress cannot be plotted !!!')
     
@@ -390,6 +434,65 @@ def on_generation(ga_instance):
         pcov = np.zeros((len(popt), len(popt)))        
         perror = np.sqrt(np.diag(pcov))
 
+    elif opt["algorithm"] == 'pyswarms':
+        print(f"Running {opt['algorithm']}...")
+        import pyswarms as ps
+
+        def fitness_func(x):
+            n_particles = x.shape[0]
+            j = [obj_fn(x[i]) for i in range(n_particles)]
+            if pbar is not None:
+                pbar.update(1)
+            return np.array(j)
+
+        if scaled_low is None:
+            raise ValueError("Bounds must be provided for pyswarms optimization.")
+            
+        if np.any(np.isinf(scaled_low)) or np.any(np.isinf(scaled_high)):
+            raise ValueError("Bounds must be finite for pyswarms optimization.")
+
+        bounds_ps = (np.array(scaled_low), np.array(scaled_high))
+        
+        options = opt.pop('options', {'c1': 0.5, 'c2': 0.3, 'w': 0.9})
+        n_particles = opt.pop('n_particles', 20)
+        iters = opt.pop('iters', 1000)
+        num_dimensions = len(initial_guess)
+        
+        initial_population = opt.pop('initial_population', None)
+        if initial_population is None:
+            initial_population = np.empty((n_particles, num_dimensions))
+            initial_population[0] = np.array(initial_guess) / scale
+            
+            for i in range(1, n_particles):
+                initial_population[i] = np.random.uniform(scaled_low, scaled_high)
+                
+            initial_population = np.clip(initial_population, scaled_low, scaled_high)
+        else:
+            initial_population = np.array(initial_population) / scale
+
+        optimizer = ps.single.GlobalBestPSO(n_particles=n_particles,
+                                            dimensions=num_dimensions,
+                                            options=options,
+                                            bounds=bounds_ps,
+                                            init_pos=initial_population)
+
+        verbose = opt.pop('verbose', pbar is None)
+        cost, pos = optimizer.optimize(fitness_func, iters=iters, verbose=verbose)
+        
+        if pbar is not None:
+            pbar.close()
+            
+        plot_pyswarms = opt.pop('plot', False)
+        if plot_pyswarms:
+            from pyswarms.utils.plotters import plot_cost_history
+            import matplotlib.pyplot as plt
+            plot_cost_history(cost_history=optimizer.cost_history)
+            plt.show()
+
+        popt = pos * scale
+        pcov = np.zeros((len(popt), len(popt)))        
+        perror = np.sqrt(np.diag(pcov))
+
     elif callable(opt["algorithm"]):
         algo=opt.pop('algorithm')
         import inspect
diff --git a/impedance/tests/test_fitting.py b/impedance/tests/test_fitting.py
index 14bf746f..159c49bd 100644
--- a/impedance/tests/test_fitting.py
+++ b/impedance/tests/test_fitting.py
@@ -247,7 +247,35 @@ def test_circuit_fit_ga():
             plot_nyquist_compare(Z_data,Z_fit)
         else:
             print(f'Passed {circuit}')
-            
+
+def test_circuit_fit_PSO():
+    data = test_data()
+    optimizations={'algorithm':'pyswarms'}
+    for circuit, initial_guess, scale, results, bounds, frequencies, Z_data in data :
+        constants={}
+        buildCircuit_text=buildCircuit(circuit, constants=constants, eval_string='', index=0)[0]
+        builtCircuit = eval('lambda frequencies,parameters : ' +  buildCircuit_text, circuit_elements)
+
+        calc = circuit_fit(frequencies, Z_data, circuit,
+                                   initial_guess, constants={},
+                                   optimizations=optimizations.copy(),scale=scale,bounds=bounds)[0]
+        f = np.array(frequencies, dtype=float)
+        Z_fit = builtCircuit(f,calc)
+        err = rmse(Z_data,Z_fit)
+        if not np.allclose(results,calc, rtol=1e-1):
+            print(f'Failed {circuit}: {results} != {calc}; RMSE={err}')
+            plot_nyquist_compare(Z_data,Z_fit)
+            print('Trying curve_fit from end point...')
+            calc2 = circuit_fit(frequencies, Z_data, circuit,
+                                    initial_guess=calc, constants={},
+                                    optimizations={},scale=scale,bounds=bounds)[0]
+            f = np.array(frequencies, dtype=float)
+            Z_fit2 = builtCircuit(f,calc2)
+            err2 = rmse(Z_data,Z_fit2)
+            print(f'For {circuit}: Param was {results}, PSO gave {calc} with RMSE={err}; subsequent curve_fit gave {calc2} with RMSE={err2}; ')           
+        else:
+            print(f'Passed {circuit}')
+
 def test_circuit_fit_callable():
     from scipy.optimize import least_squares
     data = test_data()

From 1b2a305661e779209e9c8523df5a2854f7ff9e07 Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Wed, 6 May 2026 09:25:52 -0700
Subject: [PATCH 08/15] Updated requirements

---
 README.md        | 2 ++
 requirements.txt | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/README.md b/README.md
index 6e8c29c9..2187e492 100644
--- a/README.md
+++ b/README.md
@@ -35,6 +35,8 @@ impedance.py requires:
 -   Matplotlib (>=3.5)
 -   Altair (>=3.0)
 -   Pandas
+-   pygad>=3.6.0
+-   pyswarms>=1.3
 
 Several example notebooks are provided in the `docs/source/examples/` directory. Opening these will require Jupyter notebook or Jupyter lab.
 
diff --git a/requirements.txt b/requirements.txt
index 3a0bdaa2..d955289e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -6,3 +6,5 @@ pandas
 pytest>=4.6
 pytest-cov
 scipy>=1.0
+pygad>=3.6.0
+pyswarms>=1.3
\ No newline at end of file

From 61d15acade458bd3afdbedf3e722a3b71e244b1f Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Wed, 6 May 2026 09:26:35 -0700
Subject: [PATCH 09/15] Added GA and PSO to fitting_example

---
 docs/source/examples/fitting_example.ipynb | 351 ++++++++++++++++++---
 1 file changed, 305 insertions(+), 46 deletions(-)

diff --git a/docs/source/examples/fitting_example.ipynb b/docs/source/examples/fitting_example.ipynb
index fe2a5777..028d70f0 100644
--- a/docs/source/examples/fitting_example.ipynb
+++ b/docs/source/examples/fitting_example.ipynb
@@ -18,7 +18,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -149,7 +149,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 3. Fit the equivalent circuits to a spectrum"
+    "## 3a. Fit the equivalent circuits to a spectrum"
    ]
   },
   {
@@ -166,6 +166,13 @@
    "execution_count": 7,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "impedance.models.circuits.elements:169: RuntimeWarning: overflow encountered in tanh\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -206,26 +213,285 @@
   },
   {
    "cell_type": "markdown",
+   "id": "8eb9ed7a",
    "metadata": {},
    "source": [
-    "## 4a. Predict circuit model and visualize with matplotlib"
+    "## 3b. Fit the equivalent circuits to a spectrum using GA and PSO"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb56f764",
+   "metadata": {
+    "lines_to_next_cell": 0
+   },
+   "source": [
+    "We can pass an additional `optimizations` parameter to the `.fit()` method. The `optimizations` could be a dict or a list of dict-s. \n",
+    "\n",
+    "* If optimizations is not passed, or optimizations=[] or {},  curve_fit is used.\n",
+    "\n",
+    "* If  `optimizations` is a single dict, \n",
+    "  * It must include the key \"algorithm\" to indicate the algorithm to be use. \n",
+    "  * Other keys in the dict would specify algorithm options. \n",
+    "  * Eg : {\"algorithm\" : 'scipy_minimize', 'method' : ...} or {\"algorithm\" : 'pygad', 'gene_space' : ...}. \n",
+    "* If `optimizations` is a list of dicts,\n",
+    "  * The individual dicts should follow the above specification. \n",
+    "  * The circuit fit would perform sequential optimization using the algorithms specified (for example it might be useful to run a gradient search following GA).\n",
+    "* We can add `\"show_progress\" : True` to show progress (default=`True`) and `\"plot\" : True` (default=`False`) to plot optimizations dict\n",
+    "* It is recommended to pass `scale` denoting the order of magnitude of the parameters in order to improve convergence.\n",
+    "  * Consider a p(R,C) or R-C circuit. \n",
+    "  * Suppose C-s is in μF while, R-s might be in ~0.1 ohms; we can pass [0.1,1e-6].\n",
+    "  * Internally the parameters are divided by scale during optimization.\n",
+    "\n",
+    "  * For the following example, since initial guess is R_1 = 5.00e-03 [Ohm], C_1 = 1.00e-01 [F], R_2 = 5.00e-03 [Ohm], C_2 = 1.00e-01 [F], Wo_1_0 = 1.00e-03 [Ohm], the fitting function will infer a scale of [1e-2,10,1e-2,1e-1,1e-3].\n",
+    "  * Alternately, since our final result is R_1 = 6.79e-03 [Ohm], C_1 = 5.62e+00 [F], R_2 = 3.91e-03 [Ohm], C_2 = 1.36e+00 [F], Wo_1_0 = 5.88e-02 [Ohm], we might use scale=[1e-2,10,1e-3,1,1e-1]\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
+   "id": "fd301e17",
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "impedance.models.circuits.fitting:244: UserWarning: 'scale' is recommeded for pygad. Using scale from initial_guess.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6da7ed67667b450e93e53876ced49401",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Circuit fit using pygad:   0%|          | 0/1000 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running pygad...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "validation.py:670: UserWarning: The percentage of genes to mutate (mutation_percent_genes=10) resulted in selecting (0) genes. The number of genes to mutate is set to 1 (mutation_num_genes=1).\n",
+      "If you do not want to mutate any gene, please set mutation_type=None.\n",
+      "impedance.models.circuits.elements:169: RuntimeWarning: overflow encountered in tanh\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Circuit string: R_0-p(R_1,C_1)-p(R_2,C_2)-Wo_1\n",
+      "Fit: True\n",
+      "\n",
+      "Constants:\n",
+      "    R_0 = 2.00e-02 [Ohm]\n",
+      "  Wo_1_1 = 2.00e+02 [sec]\n",
+      "\n",
+      "Initial guesses:\n",
+      "    R_1 = 5.00e-03 [Ohm]\n",
+      "    C_1 = 1.00e-01 [F]\n",
+      "    R_2 = 5.00e-03 [Ohm]\n",
+      "    C_2 = 1.00e-01 [F]\n",
+      "  Wo_1_0 = 1.00e-03 [Ohm]\n",
+      "\n",
+      "Fit parameters:\n",
+      "    R_1 = 2.24e-03  (+/- 0.00e+00) [Ohm]\n",
+      "    C_1 = 4.00e+01  (+/- 0.00e+00) [F]\n",
+      "    R_2 = 8.45e-03  (+/- 0.00e+00) [Ohm]\n",
+      "    C_2 = 1.64e+00  (+/- 0.00e+00) [F]\n",
+      "  Wo_1_0 = 5.85e-02  (+/- 0.00e+00) [Ohm]\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "impedance.models.circuits.fitting:244: UserWarning: 'scale' is recommeded for pyswarms. Using scale from initial_guess.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b8eeafe427764b8789c898c1ea9d534e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Circuit fit using pyswarms:   0%|          | 0/1000 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running pyswarms...\n",
+      "\n",
+      "Circuit string: R_0-p(R_1,C_1)-p(R_2,C_2)-Wo_1\n",
+      "Fit: True\n",
+      "\n",
+      "Constants:\n",
+      "    R_0 = 2.00e-02 [Ohm]\n",
+      "  Wo_1_1 = 2.00e+02 [sec]\n",
+      "\n",
+      "Initial guesses:\n",
+      "    R_1 = 5.00e-03 [Ohm]\n",
+      "    C_1 = 1.00e-01 [F]\n",
+      "    R_2 = 5.00e-03 [Ohm]\n",
+      "    C_2 = 1.00e-01 [F]\n",
+      "  Wo_1_0 = 1.00e-03 [Ohm]\n",
+      "\n",
+      "Fit parameters:\n",
+      "    R_1 = 2.99e-03  (+/- 0.00e+00) [Ohm]\n",
+      "    C_1 = 1.83e+00  (+/- 0.00e+00) [F]\n",
+      "    R_2 = 7.02e-03  (+/- 0.00e+00) [Ohm]\n",
+      "    C_2 = 2.94e+00  (+/- 0.00e+00) [F]\n",
+      "  Wo_1_0 = 6.30e-02  (+/- 0.00e+00) [Ohm]\n",
+      "\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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\n",
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e581345456b249ebb97e7d0c4c9338aa",
+       "version_major": 2,
+       "version_minor": 0
+      },
       "text/plain": [
-       "<Figure size 360x360 with 1 Axes>"
+       "Circuit fit using pygad:   0%|          | 0/1000 [00:00<?, ?it/s]"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running pygad...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "97bca4f6be714004bb44c83022b766bb",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Circuit fit using scipy_minimize: 0it [00:00, ?it/s]"
+      ]
      },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running scipy_minimize with L-BFGS-B...\n",
+      "\n",
+      "Circuit string: R_0-p(R_1,C_1)-p(R_2,C_2)-Wo_1\n",
+      "Fit: True\n",
+      "\n",
+      "Constants:\n",
+      "    R_0 = 2.00e-02 [Ohm]\n",
+      "  Wo_1_1 = 2.00e+02 [sec]\n",
+      "\n",
+      "Initial guesses:\n",
+      "    R_1 = 5.00e-03 [Ohm]\n",
+      "    C_1 = 1.00e-01 [F]\n",
+      "    R_2 = 5.00e-03 [Ohm]\n",
+      "    C_2 = 1.00e-01 [F]\n",
+      "  Wo_1_0 = 1.00e-03 [Ohm]\n",
+      "\n",
+      "Fit parameters:\n",
+      "    R_1 = 9.67e-03  (+/- 1.49e-01) [Ohm]\n",
+      "    C_1 = 2.29e+00  (+/- 1.37e+02) [F]\n",
+      "    R_2 = 7.75e-04  (+/- 2.28e-03) [Ohm]\n",
+      "    C_2 = 5.34e+00  (+/- 1.03e+00) [F]\n",
+      "  Wo_1_0 = 5.95e-02  (+/- 8.04e-01) [Ohm]\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "impedance.models.circuits.elements:118: RuntimeWarning: divide by zero encountered in divide\n",
+      "impedance.models.circuits.elements:118: RuntimeWarning: invalid value encountered in divide\n",
+      "impedance.models.circuits.elements:80: RuntimeWarning: invalid value encountered in divide\n",
+      "impedance.models.circuits.elements:81: RuntimeWarning: invalid value encountered in divide\n"
+     ]
+    }
+   ],
+   "source": [
+    "bounds=[(0,0.1),(0,100),(0,0.01),(0,10),(0,1)]\n",
+    "# GA\n",
+    "optimizations={'algorithm':'pygad', 'plot' : True}\n",
+    "customConstantCircuit.fit(frequencies, Z, optimizations=optimizations, bounds=bounds)\n",
+    "print(customConstantCircuit)\n",
+    "\n",
+    "# PSO\n",
+    "optimizations={'algorithm':'pyswarms'}\n",
+    "customConstantCircuit.fit(frequencies, Z, optimizations=optimizations, bounds=bounds)\n",
+    "print(customConstantCircuit)\n",
+    "\n",
+    "# Sequential optimization of GA followed by scipy_minimize\n",
+    "scale=[1e-2,10,1e-3,1,1e-1]\n",
+    "optimizations=[{'algorithm':'pygad'},{'algorithm':'scipy_minimize'}]\n",
+    "customConstantCircuit.fit(frequencies, Z, optimizations=optimizations, scale=scale, bounds=bounds)\n",
+    "print(customConstantCircuit)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4a. Predict circuit model and visualize with matplotlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -262,55 +528,55 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "impedance.visualization:39: UserWarning: linestyle is redundantly defined by the 'linestyle' keyword argument and the fmt string \".-\" (-> linestyle='-'). The keyword argument will take precedence.\n",
+      "impedance.visualization:39: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \".-\" (-> marker='.'). The keyword argument will take precedence.\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 360x360 with 1 Axes>"
+       "<Figure size 500x500 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 360x360 with 1 Axes>"
+       "<Figure size 500x500 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 360x360 with 1 Axes>"
+       "<Figure size 500x500 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 360x360 with 1 Axes>"
+       "<Figure size 500x500 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -332,7 +598,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -367,27 +633,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/matt/Dropbox/matt/projects/impedance.py/ECSHackWeek/impedance.py/impedance/models/circuits/circuits.py:166: UserWarning: Simulating circuit based on initial parameters\n",
-      "  warnings.warn(\"Simulating circuit based on initial parameters\")\n"
+      "impedance.models.circuits.circuits:143: UserWarning: Simulating circuit based on initial parameters\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 360x360 with 1 Axes>"
+       "<Figure size 500x500 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -402,18 +665,14 @@
     "plot_nyquist(customElementCircuit_fit, fmt='-.', ax=ax)\n",
     "plt.show()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "impedance_py",
    "language": "python",
    "name": "python3"
   },
@@ -427,7 +686,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,

From b704cc18e7e21cfabaee59676da33f954a232934 Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Wed, 6 May 2026 09:32:05 -0700
Subject: [PATCH 10/15] Fixed typo

---
 docs/source/validation.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/validation.rst b/docs/source/validation.rst
index 54765f46..d0a33c2e 100644
--- a/docs/source/validation.rst
+++ b/docs/source/validation.rst
@@ -1,7 +1,7 @@
 Validation
 ==========
 
-Interpreting EIS data fundamentally relies on the the system conforming to
+Interpreting EIS data fundamentally relies on the system conforming to
 conditions of causality, linearity, and stability. For an example of how
 the adherence to the Kramers-Kronig relations, see the `Validation Example Jupyter Notebook
 <examples/validation_example.ipynb>`_

From 34575973454857254c502ae857c546c9b03531c8 Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Fri, 8 May 2026 18:17:09 -0700
Subject: [PATCH 11/15] More robust fit for tanh in elements.py

---
 impedance/models/circuits/elements.py | 56 ++++++++++++++++++++-------
 1 file changed, 42 insertions(+), 14 deletions(-)

diff --git a/impedance/models/circuits/elements.py b/impedance/models/circuits/elements.py
index fa067407..c4a17255 100644
--- a/impedance/models/circuits/elements.py
+++ b/impedance/models/circuits/elements.py
@@ -166,7 +166,14 @@ def Wo(p, f):
     """
     omega = 2 * np.pi * np.array(f)
     Z0, tau = p[0], p[1]
-    Z = Z0 / (np.sqrt(1j * omega * tau) * np.tanh(np.sqrt(1j * omega * tau)))
+    
+    arg = np.sqrt(1j * omega * tau)
+    tanh = np.ones_like(arg, dtype=complex)
+    tanh[arg.real <= -100] = -1.0
+    mask = np.abs(arg.real) < 100
+    tanh[mask] = np.tanh(arg[mask])
+
+    Z = Z0 / (arg * tanh)
     return Z  # Zw(omega)
 
 
@@ -186,7 +193,14 @@ def Ws(p, f):
     """
     omega = 2 * np.pi * np.array(f)
     Z0, tau = p[0], p[1]
-    Z = Z0 * np.tanh(np.sqrt(1j * omega * tau)) / np.sqrt(1j * omega * tau)
+    
+    arg = np.sqrt(1j * omega * tau)
+    tanh = np.ones_like(arg, dtype=complex)
+    tanh[arg.real <= -100] = -1.0
+    mask = np.abs(arg.real) < 100
+    tanh[mask] = np.tanh(arg[mask])
+
+    Z = Z0 * tanh / arg
     return Z
 
 
@@ -288,10 +302,14 @@ def Gs(p, f):
     """
     omega = 2 * np.pi * np.array(f)
     R_G, t_G, phi = p[0], p[1], p[2]
-    Z = R_G / (
-        np.sqrt(1 + 1j * omega * t_G)
-        * np.tanh(phi * np.sqrt(1 + 1j * omega * t_G))
-    )
+    
+    arg = phi * np.sqrt(1 + 1j * omega * t_G)
+    tanh = np.ones_like(arg, dtype=complex)
+    tanh[arg.real <= -100] = -1.0
+    mask = np.abs(arg.real) < 100
+    tanh[mask] = np.tanh(arg[mask])
+
+    Z = R_G / (np.sqrt(1 + 1j * omega * t_G) * tanh)
     return Z
 
 
@@ -350,7 +368,14 @@ def TLMQ(p, f):
     omega = 2 * np.pi * np.array(f)
     Rion, Qs, gamma = p[0], p[1], p[2]
     Zs = 1 / (Qs * (1j * omega) ** gamma)
-    Z = np.sqrt(Rion * Zs) / np.tanh(np.sqrt(Rion / Zs))
+    
+    arg = np.sqrt(Rion / Zs)
+    tanh = np.ones_like(arg, dtype=complex)
+    tanh[arg.real <= -100] = -1.0
+    mask = np.abs(arg.real) < 100
+    tanh[mask] = np.tanh(arg[mask])
+
+    Z = np.sqrt(Rion * Zs) / tanh
     return Z
 
 
@@ -388,14 +413,17 @@ def T(p, f):
     A, B, a, b = p[0], p[1], p[2], p[3]
     beta = (a + 1j * omega * b) ** (1 / 2)
 
-    sinh = []
-    for x in beta:
-        if x < 100:
-            sinh.append(np.sinh(x))
-        else:
-            sinh.append(1e10)
+    mask = np.abs(beta.real) < 100
+
+    sinh = np.ones_like(beta, dtype=complex) * 1e10
+    sinh[beta.real <= -100] = -1e10
+    sinh[mask] = np.sinh(beta[mask])
+
+    tanh = np.ones_like(beta, dtype=complex)
+    tanh[beta.real <= -100] = -1.0
+    tanh[mask] = np.tanh(beta[mask])
 
-    Z = A / (beta * np.tanh(beta)) + B / (beta * np.array(sinh))
+    Z = A / (beta * tanh) + B / (beta * sinh)
     return Z
 
 

From 436d7c2fbcbd78646acf3f977f853b9f29239eed Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Fri, 8 May 2026 18:18:58 -0700
Subject: [PATCH 12/15] Added test ensuring new wrapCircuit gives same result
 as old wrapCircuit

---
 impedance/tests/fitting_org.py     | 445 +++++++++++++++++++++++++++++
 impedance/tests/test_newfitting.py |  50 ++++
 2 files changed, 495 insertions(+)
 create mode 100644 impedance/tests/fitting_org.py
 create mode 100644 impedance/tests/test_newfitting.py

diff --git a/impedance/tests/fitting_org.py b/impedance/tests/fitting_org.py
new file mode 100644
index 00000000..00656815
--- /dev/null
+++ b/impedance/tests/fitting_org.py
@@ -0,0 +1,445 @@
+import warnings
+
+import numpy as np
+from scipy.linalg import inv
+from scipy.optimize import curve_fit, basinhopping
+
+from impedance.models.circuits.elements import circuit_elements, get_element_from_name
+
+ints = '0123456789'
+
+
+def rmse(a, b):
+    """
+    A function which calculates the root mean squared error
+    between two vectors.
+
+    Notes
+    ---------
+    .. math::
+
+        RMSE = \\sqrt{\\frac{1}{n}(a-b)^2}
+    """
+
+    n = len(a)
+    return np.linalg.norm(a - b) / np.sqrt(n)
+
+
+def set_default_bounds(circuit, constants={}):
+    """ This function sets default bounds for optimization.
+
+    set_default_bounds sets bounds of 0 and np.inf for all parameters,
+    except the CPE and La alphas which have an upper bound of 1.
+
+    Parameters
+    -----------------
+    circuit : string
+        String defining the equivalent circuit to be fit
+
+    constants : dictionary, optional
+        Parameters and their values to hold constant during fitting
+        (e.g. {"RO": 0.1}). Defaults to {}
+
+    Returns
+    ------------
+    bounds : 2-tuple of array_like
+        Lower and upper bounds on parameters.
+    """
+
+    # extract the elements from the circuit
+    extracted_elements = extract_circuit_elements(circuit)
+
+    # loop through bounds
+    lower_bounds, upper_bounds = [], []
+    for elem in extracted_elements:
+        raw_element = get_element_from_name(elem)
+        for i in range(check_and_eval(raw_element).num_params):
+            if elem in constants or elem + f'_{i}' in constants:
+                continue
+            if raw_element in ['CPE', 'La'] and i == 1:
+                upper_bounds.append(1)
+            else:
+                upper_bounds.append(np.inf)
+            lower_bounds.append(0)
+
+    bounds = ((lower_bounds), (upper_bounds))
+    return bounds
+
+
+def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
+                bounds=None, weight_by_modulus=False, global_opt=False,
+                **kwargs):
+
+    """ Main function for fitting an equivalent circuit to data.
+
+    By default, this function uses `scipy.optimize.curve_fit
+    <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html>`_
+    to fit the equivalent circuit. This function generally works well for
+    simple circuits. However, the final results may be sensitive to
+    the initial conditions for more complex circuits. In these cases,
+    the `scipy.optimize.basinhopping
+    <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.basinhopping.html>`_
+    global optimization algorithm can be used to attempt a better fit.
+
+    Parameters
+    -----------------
+    frequencies : numpy array
+        Frequencies
+
+    impedances : numpy array of dtype 'complex128'
+        Impedances
+
+    circuit : string
+        String defining the equivalent circuit to be fit
+
+    initial_guess : list of floats
+        Initial guesses for the fit parameters
+
+    constants : dictionary, optional
+        Parameters and their values to hold constant during fitting
+        (e.g. {"RO": 0.1}). Defaults to {}
+
+    bounds : 2-tuple of array_like, optional
+        Lower and upper bounds on parameters. Defaults to bounds on all
+        parameters of 0 and np.inf, except the CPE alpha
+        which has an upper bound of 1
+
+    weight_by_modulus : bool, optional
+        Uses the modulus of each data (|Z|) as the weighting factor.
+        Standard weighting scheme when experimental variances are unavailable.
+        Only applicable when global_opt = False
+
+    global_opt : bool, optional
+        If global optimization should be used (uses the basinhopping
+        algorithm). Defaults to False
+
+    kwargs :
+        Keyword arguments passed to scipy.optimize.curve_fit or
+        scipy.optimize.basinhopping
+
+    Returns
+    ------------
+    p_values : list of floats
+        best fit parameters for specified equivalent circuit
+
+    p_errors : list of floats
+        one standard deviation error estimates for fit parameters
+
+    Notes
+    ---------
+    Need to do a better job of handling errors in fitting.
+    Currently, an error of -1 is returned.
+
+    """
+    f = np.array(frequencies, dtype=float)
+    Z = np.array(impedances, dtype=complex)
+
+    # set upper and lower bounds on a per-element basis
+    if bounds is None:
+        bounds = set_default_bounds(circuit, constants=constants)
+
+    if not global_opt:
+        if 'maxfev' not in kwargs:
+            kwargs['maxfev'] = 1e5
+        if 'ftol' not in kwargs:
+            kwargs['ftol'] = 1e-13
+
+        # weighting scheme for fitting
+        if weight_by_modulus:
+            abs_Z = np.abs(Z)
+            kwargs['sigma'] = np.hstack([abs_Z, abs_Z])
+
+        popt, pcov = curve_fit(wrapCircuit(circuit, constants), f,
+                               np.hstack([Z.real, Z.imag]),
+                               p0=initial_guess, bounds=bounds, **kwargs)
+
+        # Calculate one standard deviation error estimates for fit parameters,
+        # defined as the square root of the diagonal of the covariance matrix.
+        # https://stackoverflow.com/a/52275674/5144795
+        perror = np.sqrt(np.diag(pcov))
+
+    else:
+        if 'seed' not in kwargs:
+            kwargs['seed'] = 0
+
+        def opt_function(x):
+            """ Short function for basinhopping to optimize over.
+            We want to minimize the RMSE between the fit and the data.
+
+            Parameters
+            ----------
+            x : args
+                Parameters for optimization.
+
+            Returns
+            -------
+            function
+                Returns a function (RMSE as a function of parameters).
+            """
+            return rmse(wrapCircuit(circuit, constants)(f, *x),
+                        np.hstack([Z.real, Z.imag]))
+
+        class BasinhoppingBounds(object):
+            """ Adapted from the basinhopping documetation
+            https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.basinhopping.html
+            """
+
+            def __init__(self, xmin, xmax):
+                self.xmin = np.array(xmin)
+                self.xmax = np.array(xmax)
+
+            def __call__(self, **kwargs):
+                x = kwargs['x_new']
+                tmax = bool(np.all(x <= self.xmax))
+                tmin = bool(np.all(x >= self.xmin))
+                return tmax and tmin
+
+        basinhopping_bounds = BasinhoppingBounds(xmin=bounds[0],
+                                                 xmax=bounds[1])
+        results = basinhopping(opt_function, x0=initial_guess,
+                               accept_test=basinhopping_bounds, **kwargs)
+        popt = results.x
+
+        # Calculate perror
+        jac = results.lowest_optimization_result['jac'][np.newaxis]
+        try:
+            # jacobian -> covariance
+            # https://stats.stackexchange.com/q/231868
+            pcov = inv(np.dot(jac.T, jac)) * opt_function(popt) ** 2
+            # covariance -> perror (one standard deviation
+            # error estimates for fit parameters)
+            perror = np.sqrt(np.diag(pcov))
+        except (ValueError, np.linalg.LinAlgError):
+            warnings.warn('Failed to compute perror')
+            perror = None
+
+    return popt, perror
+
+
+def wrapCircuit(circuit, constants):
+    """ wraps function so we can pass the circuit string """
+    def wrappedCircuit(frequencies, *parameters):
+        """ returns a stacked array of real and imaginary impedance
+        components
+
+        Parameters
+        ----------
+        circuit : string
+        constants : dict
+        parameters : list of floats
+        frequencies : list of floats
+
+        Returns
+        -------
+        array of floats
+
+        """
+
+        x = eval(buildCircuit(circuit, frequencies, *parameters,
+                              constants=constants, eval_string='',
+                              index=0)[0],
+                 circuit_elements)
+        y_real = np.real(x)
+        y_imag = np.imag(x)
+
+        return np.hstack([y_real, y_imag])
+    return wrappedCircuit
+
+
+def buildCircuit(circuit, frequencies, *parameters,
+                 constants=None, eval_string='', index=0):
+    """ recursive function that transforms a circuit, parameters, and
+    frequencies into a string that can be evaluated
+
+    Parameters
+    ----------
+    circuit: str
+    frequencies: list/tuple/array of floats
+    parameters: list/tuple/array of floats
+    constants: dict
+
+    Returns
+    -------
+    eval_string: str
+        Python expression for calculating the resulting fit
+    index: int
+        Tracks parameter index through recursive calling of the function
+    """
+
+    parameters = np.array(parameters).tolist()
+    frequencies = np.array(frequencies).tolist()
+    circuit = circuit.replace(' ', '')
+
+    def parse_circuit(circuit, parallel=False, series=False):
+        """ Splits a circuit string by either dashes (series) or commas
+            (parallel) outside of any paranthesis. Removes any leading 'p('
+            or trailing ')' when in parallel mode """
+
+        assert parallel != series, \
+            'Exactly one of parallel or series must be True'
+
+        def count_parens(string):
+            return string.count('('), string.count(')')
+
+        if parallel:
+            special = ','
+            if circuit.endswith(')') and circuit.startswith('p('):
+                circuit = circuit[2:-1]
+        if series:
+            special = '-'
+
+        split = circuit.split(special)
+
+        result = []
+        skipped = []
+        for i, sub_str in enumerate(split):
+            if i not in skipped:
+                if '(' not in sub_str and ')' not in sub_str:
+                    result.append(sub_str)
+                else:
+                    open_parens, closed_parens = count_parens(sub_str)
+                    if open_parens == closed_parens:
+                        result.append(sub_str)
+                    else:
+                        uneven = True
+                        while i < len(split) - 1 and uneven:
+                            sub_str += special + split[i+1]
+
+                            open_parens, closed_parens = count_parens(sub_str)
+                            uneven = open_parens != closed_parens
+
+                            i += 1
+                            skipped.append(i)
+                        result.append(sub_str)
+        return result
+
+    parallel = parse_circuit(circuit, parallel=True)
+    series = parse_circuit(circuit, series=True)
+
+    if series is not None and len(series) > 1:
+        eval_string += "s(["
+        split = series
+    elif parallel is not None and len(parallel) > 1:
+        eval_string += "p(["
+        split = parallel
+    elif series == parallel:  # only single element
+        split = series
+
+    for i, elem in enumerate(split):
+        if ',' in elem or '-' in elem:
+            eval_string, index = buildCircuit(elem, frequencies,
+                                              *parameters,
+                                              constants=constants,
+                                              eval_string=eval_string,
+                                              index=index)
+        else:
+            param_string = ""
+            raw_elem = get_element_from_name(elem)
+            elem_number = check_and_eval(raw_elem).num_params
+            param_list = []
+            for j in range(elem_number):
+                if elem_number > 1:
+                    current_elem = elem + '_{}'.format(j)
+                else:
+                    current_elem = elem
+
+                if current_elem in constants.keys():
+                    param_list.append(constants[current_elem])
+                else:
+                    param_list.append(parameters[index])
+                    index += 1
+
+            param_string += str(param_list)
+            new = raw_elem + '(' + param_string + ',' + str(frequencies) + ')'
+            eval_string += new
+
+        if i == len(split) - 1:
+            if len(split) > 1:  # do not add closing brackets if single element
+                eval_string += '])'
+        else:
+            eval_string += ','
+
+    return eval_string, index
+
+
+def extract_circuit_elements(circuit):
+    """ Extracts circuit elements from a circuit string.
+
+    Parameters
+    ----------
+    circuit : str
+        Circuit string.
+
+    Returns
+    -------
+    extracted_elements : list
+        list of extracted elements.
+
+    """
+    p_string = [x for x in circuit if x not in 'p(),-']
+    extracted_elements = []
+    current_element = []
+    length = len(p_string)
+    for i, char in enumerate(p_string):
+        if char not in ints:
+            current_element.append(char)
+        else:
+            # min to prevent looking ahead past end of list
+            if p_string[min(i+1, length-1)] not in ints:
+                current_element.append(char)
+                extracted_elements.append(''.join(current_element))
+                current_element = []
+            else:
+                current_element.append(char)
+    extracted_elements.append(''.join(current_element))
+    return extracted_elements
+
+
+def calculateCircuitLength(circuit):
+    """ Calculates the number of elements in the circuit.
+
+    Parameters
+    ----------
+    circuit : str
+        Circuit string.
+
+    Returns
+    -------
+    length : int
+        Length of circuit.
+
+    """
+    length = 0
+    if circuit:
+        extracted_elements = extract_circuit_elements(circuit)
+        for elem in extracted_elements:
+            raw_element = get_element_from_name(elem)
+            num_params = check_and_eval(raw_element).num_params
+            length += num_params
+    return length
+
+
+def check_and_eval(element):
+    """ Checks if an element is valid, then evaluates it.
+
+    Parameters
+    ----------
+    element : str
+        Circuit element.
+
+    Raises
+    ------
+    ValueError
+        Raised if an element is not in the list of allowed elements.
+
+    Returns
+    -------
+    Evaluated element.
+
+    """
+    allowed_elements = circuit_elements.keys()
+    if element not in allowed_elements:
+        raise ValueError(f'{element} not in ' +
+                         f'allowed elements ({allowed_elements})')
+    else:
+        return eval(element, circuit_elements)
diff --git a/impedance/tests/test_newfitting.py b/impedance/tests/test_newfitting.py
new file mode 100644
index 00000000..9c1e9a00
--- /dev/null
+++ b/impedance/tests/test_newfitting.py
@@ -0,0 +1,50 @@
+'''
+Compares new buildCircuit with older buildCircuit
+R0-p(R1-Wo1,CPE1) : 82.97% faster
+R0-p(C1,R1,R2) : 79.30% faster
+R0-p(p(R1, C1)-R2, C2) : 82.17% faster
+p(C1,R1)-p(C2,R2) : 81.10% faster
+R1 : 85.55% faster
+'''
+
+from impedance.models.circuits.fitting import wrapCircuit as wrapCircuit_new
+from impedance.tests.fitting_org import wrapCircuit as wrapCircuit_org
+import numpy as np
+import time
+
+
+def test_newbuildCircuit():
+    data=[
+        # Test simple Randles circuit with CPE,
+        ('R0-p(R1-Wo1,CPE1)', [.1, .01, 1, 1000, 15, .9], [1000.0, 5.0, 0.01]), 
+        # Test multiple parallel elements, 
+        ('R0-p(C1,R1,R2)', [.1, .01, .2, .3], [1000.0, 5.0, 0.01]),
+        # Test nested parallel groups, 
+        ('R0-p(p(R1, C1)-R2, C2)', [1, 2, 3, 4, 5], [1000.0, 5.0, 0.01]),
+        # Test parallel elements at beginning and end,
+        ('p(C1,R1)-p(C2,R2)', [.1, .01, .2, .3], [1000.0, 5.0, 0.01]),
+        # Test single element circuit, 
+        ('R1', [100], [1000.0, 5.0, 0.01])
+    ]
+    # dt_ratio=[]
+    # for circuit, params, frequencies in data:
+    #     cktfn_new=wrapCircuit_new(circuit, constants={})
+    #     cktfn_org=wrapCircuit_org(circuit, constants={})
+    #     start = time.perf_counter()
+    #     Z_org=[cktfn_org(frequencies,*params) for i in range(100)]
+    #     end = time.perf_counter()
+    #     dt_org = end-start
+    #     start = time.perf_counter()
+    #     Z_new=[cktfn_new(frequencies,*params) for i in range(100)]
+    #     end = time.perf_counter()
+    #     dt_new = end-start
+    #     dt_ratio.append(f'{circuit} : {(1-dt_new/dt_org)*100:.2f} % faster')
+    #     assert( np.isclose(Z_new[0],Z_org[0]))
+    # print('\n'.join(dt_ratio))
+    for circuit, params, frequencies in data:
+        cktfn_new=wrapCircuit_new(circuit, constants={})
+        cktfn_org=wrapCircuit_org(circuit, constants={})
+        Z_org=cktfn_org(frequencies,*params)
+        Z_new=cktfn_new(frequencies,*params)
+        assert( np.all(np.isclose(Z_new,Z_org)) )
+

From 51a99dac9830851433e0f3c3b62c5dca6896bf7a Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Fri, 8 May 2026 18:21:46 -0700
Subject: [PATCH 13/15] Removed comparison of wrapCircuits

---
 impedance/tests/fitting_org.py     | 445 -----------------------------
 impedance/tests/test_newfitting.py |  50 ----
 2 files changed, 495 deletions(-)
 delete mode 100644 impedance/tests/fitting_org.py
 delete mode 100644 impedance/tests/test_newfitting.py

diff --git a/impedance/tests/fitting_org.py b/impedance/tests/fitting_org.py
deleted file mode 100644
index 00656815..00000000
--- a/impedance/tests/fitting_org.py
+++ /dev/null
@@ -1,445 +0,0 @@
-import warnings
-
-import numpy as np
-from scipy.linalg import inv
-from scipy.optimize import curve_fit, basinhopping
-
-from impedance.models.circuits.elements import circuit_elements, get_element_from_name
-
-ints = '0123456789'
-
-
-def rmse(a, b):
-    """
-    A function which calculates the root mean squared error
-    between two vectors.
-
-    Notes
-    ---------
-    .. math::
-
-        RMSE = \\sqrt{\\frac{1}{n}(a-b)^2}
-    """
-
-    n = len(a)
-    return np.linalg.norm(a - b) / np.sqrt(n)
-
-
-def set_default_bounds(circuit, constants={}):
-    """ This function sets default bounds for optimization.
-
-    set_default_bounds sets bounds of 0 and np.inf for all parameters,
-    except the CPE and La alphas which have an upper bound of 1.
-
-    Parameters
-    -----------------
-    circuit : string
-        String defining the equivalent circuit to be fit
-
-    constants : dictionary, optional
-        Parameters and their values to hold constant during fitting
-        (e.g. {"RO": 0.1}). Defaults to {}
-
-    Returns
-    ------------
-    bounds : 2-tuple of array_like
-        Lower and upper bounds on parameters.
-    """
-
-    # extract the elements from the circuit
-    extracted_elements = extract_circuit_elements(circuit)
-
-    # loop through bounds
-    lower_bounds, upper_bounds = [], []
-    for elem in extracted_elements:
-        raw_element = get_element_from_name(elem)
-        for i in range(check_and_eval(raw_element).num_params):
-            if elem in constants or elem + f'_{i}' in constants:
-                continue
-            if raw_element in ['CPE', 'La'] and i == 1:
-                upper_bounds.append(1)
-            else:
-                upper_bounds.append(np.inf)
-            lower_bounds.append(0)
-
-    bounds = ((lower_bounds), (upper_bounds))
-    return bounds
-
-
-def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
-                bounds=None, weight_by_modulus=False, global_opt=False,
-                **kwargs):
-
-    """ Main function for fitting an equivalent circuit to data.
-
-    By default, this function uses `scipy.optimize.curve_fit
-    <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html>`_
-    to fit the equivalent circuit. This function generally works well for
-    simple circuits. However, the final results may be sensitive to
-    the initial conditions for more complex circuits. In these cases,
-    the `scipy.optimize.basinhopping
-    <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.basinhopping.html>`_
-    global optimization algorithm can be used to attempt a better fit.
-
-    Parameters
-    -----------------
-    frequencies : numpy array
-        Frequencies
-
-    impedances : numpy array of dtype 'complex128'
-        Impedances
-
-    circuit : string
-        String defining the equivalent circuit to be fit
-
-    initial_guess : list of floats
-        Initial guesses for the fit parameters
-
-    constants : dictionary, optional
-        Parameters and their values to hold constant during fitting
-        (e.g. {"RO": 0.1}). Defaults to {}
-
-    bounds : 2-tuple of array_like, optional
-        Lower and upper bounds on parameters. Defaults to bounds on all
-        parameters of 0 and np.inf, except the CPE alpha
-        which has an upper bound of 1
-
-    weight_by_modulus : bool, optional
-        Uses the modulus of each data (|Z|) as the weighting factor.
-        Standard weighting scheme when experimental variances are unavailable.
-        Only applicable when global_opt = False
-
-    global_opt : bool, optional
-        If global optimization should be used (uses the basinhopping
-        algorithm). Defaults to False
-
-    kwargs :
-        Keyword arguments passed to scipy.optimize.curve_fit or
-        scipy.optimize.basinhopping
-
-    Returns
-    ------------
-    p_values : list of floats
-        best fit parameters for specified equivalent circuit
-
-    p_errors : list of floats
-        one standard deviation error estimates for fit parameters
-
-    Notes
-    ---------
-    Need to do a better job of handling errors in fitting.
-    Currently, an error of -1 is returned.
-
-    """
-    f = np.array(frequencies, dtype=float)
-    Z = np.array(impedances, dtype=complex)
-
-    # set upper and lower bounds on a per-element basis
-    if bounds is None:
-        bounds = set_default_bounds(circuit, constants=constants)
-
-    if not global_opt:
-        if 'maxfev' not in kwargs:
-            kwargs['maxfev'] = 1e5
-        if 'ftol' not in kwargs:
-            kwargs['ftol'] = 1e-13
-
-        # weighting scheme for fitting
-        if weight_by_modulus:
-            abs_Z = np.abs(Z)
-            kwargs['sigma'] = np.hstack([abs_Z, abs_Z])
-
-        popt, pcov = curve_fit(wrapCircuit(circuit, constants), f,
-                               np.hstack([Z.real, Z.imag]),
-                               p0=initial_guess, bounds=bounds, **kwargs)
-
-        # Calculate one standard deviation error estimates for fit parameters,
-        # defined as the square root of the diagonal of the covariance matrix.
-        # https://stackoverflow.com/a/52275674/5144795
-        perror = np.sqrt(np.diag(pcov))
-
-    else:
-        if 'seed' not in kwargs:
-            kwargs['seed'] = 0
-
-        def opt_function(x):
-            """ Short function for basinhopping to optimize over.
-            We want to minimize the RMSE between the fit and the data.
-
-            Parameters
-            ----------
-            x : args
-                Parameters for optimization.
-
-            Returns
-            -------
-            function
-                Returns a function (RMSE as a function of parameters).
-            """
-            return rmse(wrapCircuit(circuit, constants)(f, *x),
-                        np.hstack([Z.real, Z.imag]))
-
-        class BasinhoppingBounds(object):
-            """ Adapted from the basinhopping documetation
-            https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.basinhopping.html
-            """
-
-            def __init__(self, xmin, xmax):
-                self.xmin = np.array(xmin)
-                self.xmax = np.array(xmax)
-
-            def __call__(self, **kwargs):
-                x = kwargs['x_new']
-                tmax = bool(np.all(x <= self.xmax))
-                tmin = bool(np.all(x >= self.xmin))
-                return tmax and tmin
-
-        basinhopping_bounds = BasinhoppingBounds(xmin=bounds[0],
-                                                 xmax=bounds[1])
-        results = basinhopping(opt_function, x0=initial_guess,
-                               accept_test=basinhopping_bounds, **kwargs)
-        popt = results.x
-
-        # Calculate perror
-        jac = results.lowest_optimization_result['jac'][np.newaxis]
-        try:
-            # jacobian -> covariance
-            # https://stats.stackexchange.com/q/231868
-            pcov = inv(np.dot(jac.T, jac)) * opt_function(popt) ** 2
-            # covariance -> perror (one standard deviation
-            # error estimates for fit parameters)
-            perror = np.sqrt(np.diag(pcov))
-        except (ValueError, np.linalg.LinAlgError):
-            warnings.warn('Failed to compute perror')
-            perror = None
-
-    return popt, perror
-
-
-def wrapCircuit(circuit, constants):
-    """ wraps function so we can pass the circuit string """
-    def wrappedCircuit(frequencies, *parameters):
-        """ returns a stacked array of real and imaginary impedance
-        components
-
-        Parameters
-        ----------
-        circuit : string
-        constants : dict
-        parameters : list of floats
-        frequencies : list of floats
-
-        Returns
-        -------
-        array of floats
-
-        """
-
-        x = eval(buildCircuit(circuit, frequencies, *parameters,
-                              constants=constants, eval_string='',
-                              index=0)[0],
-                 circuit_elements)
-        y_real = np.real(x)
-        y_imag = np.imag(x)
-
-        return np.hstack([y_real, y_imag])
-    return wrappedCircuit
-
-
-def buildCircuit(circuit, frequencies, *parameters,
-                 constants=None, eval_string='', index=0):
-    """ recursive function that transforms a circuit, parameters, and
-    frequencies into a string that can be evaluated
-
-    Parameters
-    ----------
-    circuit: str
-    frequencies: list/tuple/array of floats
-    parameters: list/tuple/array of floats
-    constants: dict
-
-    Returns
-    -------
-    eval_string: str
-        Python expression for calculating the resulting fit
-    index: int
-        Tracks parameter index through recursive calling of the function
-    """
-
-    parameters = np.array(parameters).tolist()
-    frequencies = np.array(frequencies).tolist()
-    circuit = circuit.replace(' ', '')
-
-    def parse_circuit(circuit, parallel=False, series=False):
-        """ Splits a circuit string by either dashes (series) or commas
-            (parallel) outside of any paranthesis. Removes any leading 'p('
-            or trailing ')' when in parallel mode """
-
-        assert parallel != series, \
-            'Exactly one of parallel or series must be True'
-
-        def count_parens(string):
-            return string.count('('), string.count(')')
-
-        if parallel:
-            special = ','
-            if circuit.endswith(')') and circuit.startswith('p('):
-                circuit = circuit[2:-1]
-        if series:
-            special = '-'
-
-        split = circuit.split(special)
-
-        result = []
-        skipped = []
-        for i, sub_str in enumerate(split):
-            if i not in skipped:
-                if '(' not in sub_str and ')' not in sub_str:
-                    result.append(sub_str)
-                else:
-                    open_parens, closed_parens = count_parens(sub_str)
-                    if open_parens == closed_parens:
-                        result.append(sub_str)
-                    else:
-                        uneven = True
-                        while i < len(split) - 1 and uneven:
-                            sub_str += special + split[i+1]
-
-                            open_parens, closed_parens = count_parens(sub_str)
-                            uneven = open_parens != closed_parens
-
-                            i += 1
-                            skipped.append(i)
-                        result.append(sub_str)
-        return result
-
-    parallel = parse_circuit(circuit, parallel=True)
-    series = parse_circuit(circuit, series=True)
-
-    if series is not None and len(series) > 1:
-        eval_string += "s(["
-        split = series
-    elif parallel is not None and len(parallel) > 1:
-        eval_string += "p(["
-        split = parallel
-    elif series == parallel:  # only single element
-        split = series
-
-    for i, elem in enumerate(split):
-        if ',' in elem or '-' in elem:
-            eval_string, index = buildCircuit(elem, frequencies,
-                                              *parameters,
-                                              constants=constants,
-                                              eval_string=eval_string,
-                                              index=index)
-        else:
-            param_string = ""
-            raw_elem = get_element_from_name(elem)
-            elem_number = check_and_eval(raw_elem).num_params
-            param_list = []
-            for j in range(elem_number):
-                if elem_number > 1:
-                    current_elem = elem + '_{}'.format(j)
-                else:
-                    current_elem = elem
-
-                if current_elem in constants.keys():
-                    param_list.append(constants[current_elem])
-                else:
-                    param_list.append(parameters[index])
-                    index += 1
-
-            param_string += str(param_list)
-            new = raw_elem + '(' + param_string + ',' + str(frequencies) + ')'
-            eval_string += new
-
-        if i == len(split) - 1:
-            if len(split) > 1:  # do not add closing brackets if single element
-                eval_string += '])'
-        else:
-            eval_string += ','
-
-    return eval_string, index
-
-
-def extract_circuit_elements(circuit):
-    """ Extracts circuit elements from a circuit string.
-
-    Parameters
-    ----------
-    circuit : str
-        Circuit string.
-
-    Returns
-    -------
-    extracted_elements : list
-        list of extracted elements.
-
-    """
-    p_string = [x for x in circuit if x not in 'p(),-']
-    extracted_elements = []
-    current_element = []
-    length = len(p_string)
-    for i, char in enumerate(p_string):
-        if char not in ints:
-            current_element.append(char)
-        else:
-            # min to prevent looking ahead past end of list
-            if p_string[min(i+1, length-1)] not in ints:
-                current_element.append(char)
-                extracted_elements.append(''.join(current_element))
-                current_element = []
-            else:
-                current_element.append(char)
-    extracted_elements.append(''.join(current_element))
-    return extracted_elements
-
-
-def calculateCircuitLength(circuit):
-    """ Calculates the number of elements in the circuit.
-
-    Parameters
-    ----------
-    circuit : str
-        Circuit string.
-
-    Returns
-    -------
-    length : int
-        Length of circuit.
-
-    """
-    length = 0
-    if circuit:
-        extracted_elements = extract_circuit_elements(circuit)
-        for elem in extracted_elements:
-            raw_element = get_element_from_name(elem)
-            num_params = check_and_eval(raw_element).num_params
-            length += num_params
-    return length
-
-
-def check_and_eval(element):
-    """ Checks if an element is valid, then evaluates it.
-
-    Parameters
-    ----------
-    element : str
-        Circuit element.
-
-    Raises
-    ------
-    ValueError
-        Raised if an element is not in the list of allowed elements.
-
-    Returns
-    -------
-    Evaluated element.
-
-    """
-    allowed_elements = circuit_elements.keys()
-    if element not in allowed_elements:
-        raise ValueError(f'{element} not in ' +
-                         f'allowed elements ({allowed_elements})')
-    else:
-        return eval(element, circuit_elements)
diff --git a/impedance/tests/test_newfitting.py b/impedance/tests/test_newfitting.py
deleted file mode 100644
index 9c1e9a00..00000000
--- a/impedance/tests/test_newfitting.py
+++ /dev/null
@@ -1,50 +0,0 @@
-'''
-Compares new buildCircuit with older buildCircuit
-R0-p(R1-Wo1,CPE1) : 82.97% faster
-R0-p(C1,R1,R2) : 79.30% faster
-R0-p(p(R1, C1)-R2, C2) : 82.17% faster
-p(C1,R1)-p(C2,R2) : 81.10% faster
-R1 : 85.55% faster
-'''
-
-from impedance.models.circuits.fitting import wrapCircuit as wrapCircuit_new
-from impedance.tests.fitting_org import wrapCircuit as wrapCircuit_org
-import numpy as np
-import time
-
-
-def test_newbuildCircuit():
-    data=[
-        # Test simple Randles circuit with CPE,
-        ('R0-p(R1-Wo1,CPE1)', [.1, .01, 1, 1000, 15, .9], [1000.0, 5.0, 0.01]), 
-        # Test multiple parallel elements, 
-        ('R0-p(C1,R1,R2)', [.1, .01, .2, .3], [1000.0, 5.0, 0.01]),
-        # Test nested parallel groups, 
-        ('R0-p(p(R1, C1)-R2, C2)', [1, 2, 3, 4, 5], [1000.0, 5.0, 0.01]),
-        # Test parallel elements at beginning and end,
-        ('p(C1,R1)-p(C2,R2)', [.1, .01, .2, .3], [1000.0, 5.0, 0.01]),
-        # Test single element circuit, 
-        ('R1', [100], [1000.0, 5.0, 0.01])
-    ]
-    # dt_ratio=[]
-    # for circuit, params, frequencies in data:
-    #     cktfn_new=wrapCircuit_new(circuit, constants={})
-    #     cktfn_org=wrapCircuit_org(circuit, constants={})
-    #     start = time.perf_counter()
-    #     Z_org=[cktfn_org(frequencies,*params) for i in range(100)]
-    #     end = time.perf_counter()
-    #     dt_org = end-start
-    #     start = time.perf_counter()
-    #     Z_new=[cktfn_new(frequencies,*params) for i in range(100)]
-    #     end = time.perf_counter()
-    #     dt_new = end-start
-    #     dt_ratio.append(f'{circuit} : {(1-dt_new/dt_org)*100:.2f} % faster')
-    #     assert( np.isclose(Z_new[0],Z_org[0]))
-    # print('\n'.join(dt_ratio))
-    for circuit, params, frequencies in data:
-        cktfn_new=wrapCircuit_new(circuit, constants={})
-        cktfn_org=wrapCircuit_org(circuit, constants={})
-        Z_org=cktfn_org(frequencies,*params)
-        Z_new=cktfn_new(frequencies,*params)
-        assert( np.all(np.isclose(Z_new,Z_org)) )
-

From b96ee949ec226d92812271c4678ac396b12a4fc3 Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Sat, 9 May 2026 16:13:34 -0700
Subject: [PATCH 14/15] Fixed bug that prevent proper sigma for curve_fit

---
 impedance/models/circuits/fitting.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/impedance/models/circuits/fitting.py b/impedance/models/circuits/fitting.py
index 1c9ca9f5..3b98c36c 100644
--- a/impedance/models/circuits/fitting.py
+++ b/impedance/models/circuits/fitting.py
@@ -1,7 +1,8 @@
 import warnings
 import os
+import inspect
+
 
-#module:impedance/models/circuits/
 def _custom_formatwarning(msg, category, filename, lineno, line=None):
     norm_path = os.path.normpath(filename)
     path_parts = norm_path.split(os.sep)
@@ -229,12 +230,16 @@ def circuit_fit(frequencies, impedances, circuit, initial_guess, constants={},
     if not isinstance(opt,dict) : opt={"algorithm" : opt}
 
     target_Z = np.hstack([Z.real, Z.imag])
-    sigma = kwargs.pop('sigma', 1)
 
     soft_constraint = kwargs.pop('soft_constraint', lambda p : 0)
 
     algo=opt["algorithm"]
     if algo in ('scipy_minimize','pygad','pyswarms') or callable(opt["algorithm"]):
+        sigma = kwargs.pop('sigma', 1)
+        # weighting scheme for fitting
+        if weight_by_modulus:
+            abs_Z = np.abs(Z)
+            kwargs['sigma'] = np.hstack([abs_Z, abs_Z])
         needscale=True
         if callable(algo):
             sig = inspect.signature(algo)
@@ -495,7 +500,6 @@ def fitness_func(x):
 
     elif callable(opt["algorithm"]):
         algo=opt.pop('algorithm')
-        import inspect
         sig = inspect.signature(algo)
         valid_params = sig.parameters
         

From 5fe535b158995d4406f2939871005063b63d3988 Mon Sep 17 00:00:00 2001
From: Krishna Vijayaraghavan <prof.krishna.v@gmail.com>
Date: Sat, 9 May 2026 18:13:38 -0700
Subject: [PATCH 15/15] Set higher RMSE for other new fits

---
 impedance/tests/test_circuits.py | 22 +++++++--------
 impedance/tests/test_fitting.py  | 48 +++++++++-----------------------
 2 files changed, 24 insertions(+), 46 deletions(-)

diff --git a/impedance/tests/test_circuits.py b/impedance/tests/test_circuits.py
index b3081261..dac01d65 100644
--- a/impedance/tests/test_circuits.py
+++ b/impedance/tests/test_circuits.py
@@ -200,9 +200,9 @@ def test_CustomCircuit():
     initial_guess = [1, 2, 3]
     circuit = CustomCircuit(circuit, initial_guess=initial_guess)
 
-from .test_fitting import test_data
+from .test_fitting import get_data
 def test_CustomCircuitwAlgorithm():
-    data = test_data()
+    data = get_data()
     optimizations={'algorithm':'pygad'}
     for d in data :
         if len(d) == 7:
@@ -215,13 +215,13 @@ def test_CustomCircuitwAlgorithm():
                                    circuit=circuit,constants=constants)
         custom_circuit.fit(frequencies, Z, bounds=bounds, optimizations=optimizations.copy(), scale=scale)
         assert custom_circuit._is_fit()
-        param = custom_circuit.parameters_
-        Z_fit = custom_circuit.predict(frequencies=frequencies)
-        err = rmse(Z,Z_fit)
-        if not np.allclose(results,param, rtol=1e-1):
-            print(f'Failed {circuit}: {results} != {param}; RMSE={err}')
-        else:
-            print(f'Passed {circuit}')        
-        custom_circuit.plot(f_data=frequencies, Z_data=Z, kind="nyquist")
-        plt.show()
+        # param = custom_circuit.parameters_
+        # Z_fit = custom_circuit.predict(frequencies=frequencies)
+        # err = rmse(Z,Z_fit)
+        # if not np.allclose(results,param, rtol=1e-1):
+        #     print(f'Failed {circuit}: {results} != {param}; RMSE={err}')
+        # else:
+        #     print(f'Passed {circuit}')        
+        # custom_circuit.plot(f_data=frequencies, Z_data=Z, kind="nyquist")
+        # plt.show()
  
diff --git a/impedance/tests/test_fitting.py b/impedance/tests/test_fitting.py
index 159c49bd..e81d0584 100644
--- a/impedance/tests/test_fitting.py
+++ b/impedance/tests/test_fitting.py
@@ -212,10 +212,10 @@ def plot_nyquist_compare(Z, Z_fit, scale=1, units='Ohms', fmt=['-',"*"], ax=None
     t = ax.xaxis.get_offset_text()
     t.set_size(18)
 
-    # return ax
-    plt.show()
+    return ax
+    # plt.show()
 
-def test_data():
+def get_data():
     example_frequencies_filtered, \
         Z_correct_filtered = ignoreBelowX(example_frequencies, Z_correct)
     data=[#circuit, initial_guess, scale, results, bounds, frequencies, Z_data]  # Test trivial model (10 Ohm resistor)
@@ -228,8 +228,9 @@ def test_data():
     )]
     return data
 
+rmse_limit=1e-1
 def test_circuit_fit_ga():
-    data = test_data()
+    data = get_data()
     optimizations={'algorithm':'pygad'}
     for circuit, initial_guess, scale, results, bounds, frequencies, Z_data in data :
         constants={}
@@ -242,14 +243,10 @@ def test_circuit_fit_ga():
         f = np.array(frequencies, dtype=float)
         Z_fit = builtCircuit(f,calc)
         err = rmse(Z_data,Z_fit)
-        if not np.allclose(results,calc, rtol=1e-1):
-            print(f'Failed {circuit}: {results} != {calc}; RMSE={err}')
-            plot_nyquist_compare(Z_data,Z_fit)
-        else:
-            print(f'Passed {circuit}')
+        assert np.allclose(results,calc, rtol=1e-1) or err <= rmse_limit, f'Failed {circuit}: {results} != {calc}; RMSE={err}'
 
 def test_circuit_fit_PSO():
-    data = test_data()
+    data = get_data()
     optimizations={'algorithm':'pyswarms'}
     for circuit, initial_guess, scale, results, bounds, frequencies, Z_data in data :
         constants={}
@@ -262,23 +259,12 @@ def test_circuit_fit_PSO():
         f = np.array(frequencies, dtype=float)
         Z_fit = builtCircuit(f,calc)
         err = rmse(Z_data,Z_fit)
-        if not np.allclose(results,calc, rtol=1e-1):
-            print(f'Failed {circuit}: {results} != {calc}; RMSE={err}')
-            plot_nyquist_compare(Z_data,Z_fit)
-            print('Trying curve_fit from end point...')
-            calc2 = circuit_fit(frequencies, Z_data, circuit,
-                                    initial_guess=calc, constants={},
-                                    optimizations={},scale=scale,bounds=bounds)[0]
-            f = np.array(frequencies, dtype=float)
-            Z_fit2 = builtCircuit(f,calc2)
-            err2 = rmse(Z_data,Z_fit2)
-            print(f'For {circuit}: Param was {results}, PSO gave {calc} with RMSE={err}; subsequent curve_fit gave {calc2} with RMSE={err2}; ')           
-        else:
-            print(f'Passed {circuit}')
+        assert np.allclose(results,calc, rtol=1e-1) or err <= rmse_limit, f'Failed {circuit}: {results} != {calc}; RMSE={err}'
+
 
 def test_circuit_fit_callable():
     from scipy.optimize import least_squares
-    data = test_data()
+    data = get_data()
     optimizations={'algorithm':least_squares,'method':'trf'}
     for circuit, initial_guess, scale, results, bounds, frequencies, Z_data in data :
         constants={}
@@ -291,14 +277,10 @@ def test_circuit_fit_callable():
         f = np.array(frequencies, dtype=float)
         Z_fit = builtCircuit(f,calc)
         err = rmse(Z_data,Z_fit)
-        if not np.allclose(results,calc, rtol=1e-1):
-            print(f'Failed {circuit}: {results} != {calc}; RMSE={err}')
-            # plot_nyquist_compare(Z_data,Z_fit)
-        else:
-            print(f'Passed {circuit}')
+        assert np.allclose(results,calc, rtol=1e-1), f'Failed {circuit}: {results} != {calc}; RMSE={err}'
 
 def test_circuit_fit_seq():
-    data = test_data()
+    data = get_data()
     optimizations=[{'algorithm':'pygad'},{'algorithm':'scipy_minimize'}]
     for circuit, initial_guess, scale, results, bounds, frequencies, Z_data in data :
         constants={}
@@ -311,11 +293,7 @@ def test_circuit_fit_seq():
         f = np.array(frequencies, dtype=float)
         Z_fit = builtCircuit(f,calc)
         err = rmse(Z_data,Z_fit)
-        if not np.allclose(results,calc, rtol=1e-1):
-            print(f'Failed {circuit}: {results} != {calc}; RMSE={err}')
-            plot_nyquist_compare(Z_data,Z_fit)
-        else:
-            print(f'Passed {circuit}')
+        assert np.allclose(results,calc, rtol=1e-1) or err <= rmse_limit, f'Failed {circuit}: {results} != {calc}; RMSE={err}'
 
 import re
 def subsitute_values(buildCircuit_text, frequencies, parameters):