code: def test_L4(self):
      # Lampinen ([5]) test problem 4
      def f(x):
          return np.sum(x[:3])
  
      A = np.zeros((4, 9))
      A[1, [4, 6]] = 0.0025, 0.0025
      A[2, [5, 7, 4]] = 0.0025, 0.0025, -0.0025
      A[3, [8, 5]] = 0.01, -0.01
      A = A[1:, 1:]
      b = np.array([1, 1, 1])
  
      def c1(x):
          x = np.hstack(([0], x))  # 1-indexed to match reference
          return [
              x[1] * x[6] - 833.33252 * x[4] - 100 * x[1] + 83333.333,
              x[2] * x[7] - 1250 * x[5] - x[2] * x[4] + 1250 * x[4],
              x[3] * x[8] - 1250000 - x[3] * x[5] + 2500 * x[5],
          ]
  
      L = LinearConstraint(A, -np.inf, 1)
      N = NonlinearConstraint(c1, 0, np.inf)
  
      bounds = [(100, 10000)] + [(1000, 10000)] * 2 + [(10, 1000)] * 5
      constraints = (L, N)
  
      with suppress_warnings() as sup:
          sup.filter(UserWarning)
          res = differential_evolution(
              f,
              bounds,
              strategy="rand1bin",
              seed=1234,
              constraints=constraints,
              popsize=3,
          )
  
      f_opt = 7049.248
  
      x_opt = [
          579.306692,
          1359.97063,
          5109.9707,
          182.0177,
          295.601172,
          217.9823,
          286.416528,
          395.601172,
      ]
  
      assert_allclose(f(x_opt), f_opt, atol=0.001)
      assert_allclose(res.fun, f_opt, atol=0.001)
  
      # use higher tol here for 32-bit Windows, see gh-11693
      if (
          platform.system() == "Windows"
          and np.dtype(np.intp).itemsize < 8
      ):
          assert_allclose(res.x, x_opt, rtol=2.4e-6, atol=0.0035)
      else:
          # tolerance determined from macOS + MKL failure, see gh-12701
          assert_allclose(res.x, x_opt, rtol=5e-6, atol=0.0024)
  
      assert res.success
      assert_(np.all(A @ res.x <= b))
      assert_(np.all(np.array(c1(res.x)) >= 0))
      assert_(np.all(res.x >= np.array(bounds)[:, 0]))
      assert_(np.all(res.x <= np.array(bounds)[:, 1]))
  
imports: import multiprocessing
  import platform
  from scipy.optimize._differentialevolution import DifferentialEvolutionSolver, _ConstraintWrapper
  from scipy.optimize import differential_evolution
  from scipy.optimize._constraints import Bounds, NonlinearConstraint, LinearConstraint
  from scipy.optimize import rosen
  from scipy.sparse import csr_matrix
  from scipy._lib._pep440 import Version
  import numpy
  from numpy.testing import assert_equal, assert_allclose, assert_almost_equal, assert_array_equal, assert_string_equal, assert_, suppress_warnings
  from pytest import raises, warns
  import pytest
label_desc: Use image node_id 50 for calling the TestDifferentialEvolutionSolver obj's underlying member method code with example usage: obj.test_L4() and returns: np, list