code: def test_ticket_11800(self):
      # parameters
      beta_true = np.array([1.0, 2.3, 1.1, -1.0, 1.3, 0.5])
      nr_measurements = 10
  
      std_dev_x = 0.01
      x_error = np.array(
          [
              [
                  0.00063445,
                  0.00515731,
                  0.00162719,
                  0.01022866,
                  -0.01624845,
                  0.00482652,
                  0.00275988,
                  -0.00714734,
                  -0.00929201,
                  -0.00687301,
              ],
              [
                  -0.00831623,
                  -0.00821211,
                  -0.00203459,
                  0.00938266,
                  -0.00701829,
                  0.0032169,
                  0.00259194,
                  -0.00581017,
                  -0.0030283,
                  0.01014164,
              ],
          ]
      )
  
      std_dev_y = 0.05
      y_error = np.array(
          [
              [
                  0.05275304,
                  0.04519563,
                  -0.07524086,
                  0.03575642,
                  0.04745194,
                  0.03806645,
                  0.07061601,
                  -0.00753604,
                  -0.02592543,
                  -0.02394929,
              ],
              [
                  0.03632366,
                  0.06642266,
                  0.08373122,
                  0.03988822,
                  -0.0092536,
                  -0.03750469,
                  -0.03198903,
                  0.01642066,
                  0.01293648,
                  -0.05627085,
              ],
          ]
      )
  
      beta_solution = np.array(
          [
              2.62920235756665876536e00,
              -1.26608484996299608838e02,
              1.29703572775403074502e02,
              -1.88560985401185465804e00,
              7.83834160771274923718e01,
              -7.64124076838087091801e01,
          ]
      )
  
      # model's function and Jacobians
      def func(beta, x):
          y0 = beta[0] + beta[1] * x[0, :] + beta[2] * x[1, :]
          y1 = beta[3] + beta[4] * x[0, :] + beta[5] * x[1, :]
  
          return np.vstack((y0, y1))
  
      def df_dbeta_odr(beta, x):
          nr_meas = np.shape(x)[1]
          zeros = np.zeros(nr_meas)
          ones = np.ones(nr_meas)
  
          dy0 = np.array([ones, x[0, :], x[1, :], zeros, zeros, zeros])
          dy1 = np.array([zeros, zeros, zeros, ones, x[0, :], x[1, :]])
  
          return np.stack((dy0, dy1))
  
      def df_dx_odr(beta, x):
          nr_meas = np.shape(x)[1]
          ones = np.ones(nr_meas)
  
          dy0 = np.array([beta[1] * ones, beta[2] * ones])
          dy1 = np.array([beta[4] * ones, beta[5] * ones])
          return np.stack((dy0, dy1))
  
      # do measurements with errors in independent and dependent variables
      x0_true = np.linspace(1, 10, nr_measurements)
      x1_true = np.linspace(1, 10, nr_measurements)
      x_true = np.array([x0_true, x1_true])
  
      y_true = func(beta_true, x_true)
  
      x_meas = x_true + x_error
      y_meas = y_true + y_error
  
      # estimate model's parameters
      model_f = Model(func, fjacb=df_dbeta_odr, fjacd=df_dx_odr)
  
      data = RealData(x_meas, y_meas, sx=std_dev_x, sy=std_dev_y)
  
      odr_obj = ODR(data, model_f, beta0=0.9 * beta_true, maxit=100)
      # odr_obj.set_iprint(init=2, iter=0, iter_step=1, final=1)
      odr_obj.set_job(deriv=3)
  
      odr_out = odr_obj.run()
  
      # check results
      assert_equal(odr_out.info, 1)
      assert_array_almost_equal(odr_out.beta, beta_solution)
  
imports: import tempfile
  import shutil
  import os
  import numpy
  from numpy import pi
  from numpy.testing import assert_array_almost_equal, assert_equal, assert_warns, assert_allclose
  import pytest
  from pytest import raises
  from scipy.odr import Data, Model, ODR, RealData, OdrStop, OdrWarning, multilinear, exponential, unilinear, quadratic, polynomial
label_desc: Use image node_id 18 for calling the TestODR obj's underlying member method code with example usage: obj.test_ticket_11800() and returns: np, np, np