How to use the sherpa.optmethods._tstoptfct.init function in sherpa

print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        kowalik_osborne(name, algo)

    def brown_dennis(name, opt):
        tst_algo(opt, _tstoptfct.brown_dennis, name, 4)
    name = 'brown_dennis'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 4)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        brown_dennis(name, algo)

    def osborne1(name, opt):
        tst_algo(opt, _tstoptfct.osborne1, name, 5)
    name = 'osborne1'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 5)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        osborne1(name, algo)

    def biggs(name, opt):
        tst_algo(opt, _tstoptfct.biggs, name, 6)
    name = 'biggs'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 6)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        if algo.__class__.__name__ == 'Midnight':
            print('Minuit aborts skip test')
            continue
        biggs(name, algo)

    def osborne2(name, opt):

print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        variably_dimensioned(name, algo)

    def trigonometric(name, opt):
        tst_algo(opt, _tstoptfct.trigonometric, name, npar)
    name = 'trigonometric'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        trigonometric(name, algo)

    def brown_almost_linear(name, opt):
        tst_algo(opt, _tstoptfct.brown_almost_linear, name, npar)
    name = 'brown_almost_linear'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        brown_almost_linear(name, algo)

    def discrete_boundary(name, opt):
        tst_algo(opt, _tstoptfct.discrete_boundary, name, npar)
    name = 'discrete_boundary'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        discrete_boundary(name, algo)

    def discrete_integral(name, opt):
        tst_algo(opt, _tstoptfct.discrete_integral, name, npar)
    name = 'discrete_integral'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)

def tst_algo(opt, fcn, name, num):
        def func_wrapper(arg):
            return fcn(arg)[0]
        x0, xmin, xmax, fmin = _tstoptfct.init(name, num)
        result = opt(func_wrapper, x0, xmin, xmax)
        opt_name = opt.__class__.__name__
        print(opt_name, result[2], '=', result[1], 'in', result[0], 'nfevs')

print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        watson(name, algo)

    def penaltyI(name, opt):
        tst_algo(opt, _tstoptfct.penaltyI, name, 4)
    name = 'penaltyI'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 4)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        penaltyI(name, algo)

    def penaltyII(name, opt):
        tst_algo(opt, _tstoptfct.penaltyII, name, 4)
    name = 'penaltyII'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 4)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        penaltyII(name, algo)

    def variably_dimensioned(name, opt):
        tst_algo(opt, _tstoptfct.variably_dimensioned, name, npar)
    name = 'variably_dimensioned'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        variably_dimensioned(name, algo)

    def trigonometric(name, opt):
        tst_algo(opt, _tstoptfct.trigonometric, name, npar)
    name = 'trigonometric'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)

print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        freudenstein_roth(name, algo)
        
    def powell_badly_scaled(name, opt):
        tst_algo(opt, _tstoptfct.powell_badly_scaled, name, npar)
    name = 'powell_badly_scaled'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        powell_badly_scaled(name, algo)
        
    def brown_badly_scaled(name, opt):
        tst_algo(opt, _tstoptfct.brown_badly_scaled, name, npar)
    name = 'brown_badly_scaled'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        brown_badly_scaled(name, algo)

    def beale(name, opt):
        tst_algo(opt, _tstoptfct.beale, name, npar)
    name = 'beale'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        beale(name, algo)
        
    def jennrich_sampson(name, opt):
        tst_algo(opt, _tstoptfct.jennrich_sampson, name, npar)
    name = 'jennrich_sampson'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)

def biggs(name, opt):
        tst_algo(opt, _tstoptfct.biggs, name, 6)
    name = 'biggs'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 6)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        if algo.__class__.__name__ == 'Midnight':
            print('Minuit aborts skip test')
            continue
        biggs(name, algo)

    def osborne2(name, opt):
        tst_algo(opt, _tstoptfct.osborne2, name, 11)
    name = 'osborne2'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 11)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        osborne2(name, algo)

    def watson(name, opt):
        tst_algo(opt, _tstoptfct.watson, name, 6)
    name = 'watson'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 6)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        watson(name, algo)

    def penaltyI(name, opt):
        tst_algo(opt, _tstoptfct.penaltyI, name, 4)
    name = 'penaltyI'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 4)

print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        penaltyI(name, algo)

    def penaltyII(name, opt):
        tst_algo(opt, _tstoptfct.penaltyII, name, 4)
    name = 'penaltyII'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 4)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        penaltyII(name, algo)

    def variably_dimensioned(name, opt):
        tst_algo(opt, _tstoptfct.variably_dimensioned, name, npar)
    name = 'variably_dimensioned'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        variably_dimensioned(name, algo)

    def trigonometric(name, opt):
        tst_algo(opt, _tstoptfct.trigonometric, name, npar)
    name = 'trigonometric'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        trigonometric(name, algo)

    def brown_almost_linear(name, opt):
        tst_algo(opt, _tstoptfct.brown_almost_linear, name, npar)
    name = 'brown_almost_linear'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)

print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        gaussian(name, algo)

    def meyer(name, opt):
        tst_algo(opt, _tstoptfct.meyer, name, 3)
    name = 'meyer'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 3)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        meyer(name, algo)

    def gulf_research_development(name, opt):
        tst_algo(opt, _tstoptfct.gulf_research_development, name, 3)
    name = 'gulf_research_development'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 3)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        gulf_research_development(name, algo)

    def box3d(name, opt):
        tst_algo(opt, _tstoptfct.box3d, name, 3)
    name = 'box3d'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 3)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        box3d(name, algo)

    def powell_singular(name, opt):
        tst_algo(opt, _tstoptfct.powell_singular, name, 4 * npar)
    name = 'powell_singular'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 4 * npar)

print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        discrete_boundary(name, algo)

    def discrete_integral(name, opt):
        tst_algo(opt, _tstoptfct.discrete_integral, name, npar)
    name = 'discrete_integral'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        discrete_integral(name, algo)
        
    def broyden_tridiagonal(name, opt):
        tst_algo(opt, _tstoptfct.broyden_tridiagonal, name, npar)
    name = 'broyden_tridiagonal'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        broyden_tridiagonal(name, algo)
        
    def broyden_banded(name, opt):
        tst_algo(opt, _tstoptfct.broyden_banded, name, npar)
    name = 'broyden_banded'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        broyden_banded(name, algo)

    def linear_fullrank(name, opt):
        tst_algo(opt, _tstoptfct.linear_fullrank, name, npar)
    name = 'linear_fullrank'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)

print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        osborne2(name, algo)

    def watson(name, opt):
        tst_algo(opt, _tstoptfct.watson, name, 6)
    name = 'watson'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 6)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        watson(name, algo)

    def penaltyI(name, opt):
        tst_algo(opt, _tstoptfct.penaltyI, name, 4)
    name = 'penaltyI'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 4)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        penaltyI(name, algo)

    def penaltyII(name, opt):
        tst_algo(opt, _tstoptfct.penaltyII, name, 4)
    name = 'penaltyII'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, 4)
    print('\n', name,' fmin =', fmin)
    for algo in algorithms:
        penaltyII(name, algo)

    def variably_dimensioned(name, opt):
        tst_algo(opt, _tstoptfct.variably_dimensioned, name, npar)
    name = 'variably_dimensioned'
    x0, xmin, xmax, fmin = _tstoptfct.init(name, npar)