code: def _transform(X, X1, parameters, parameters1, n_features_per_kernel):
      num_examples, input_length = X.shape
  
      dilations, num_features_per_dilation, biases = parameters
      dilations1, num_features_per_dilation1, biases1 = parameters1
  
      # equivalent to:
      # >>> from itertools import combinations
      # >>> indices = np.array(
      #   [_ for _ in combinations(np.arange(9), 3)], dtype = np.int32
      # )
      indices = np.array(
          (
              0,
              1,
              2,
              0,
              1,
              3,
              0,
              1,
              4,
              0,
              1,
              5,
              0,
              1,
              6,
              0,
              1,
              7,
              0,
              1,
              8,
              0,
              2,
              3,
              0,
              2,
              4,
              0,
              2,
              5,
              0,
              2,
              6,
              0,
              2,
              7,
              0,
              2,
              8,
              0,
              3,
              4,
              0,
              3,
              5,
              0,
              3,
              6,
              0,
              3,
              7,
              0,
              3,
              8,
              0,
              4,
              5,
              0,
              4,
              6,
              0,
              4,
              7,
              0,
              4,
              8,
              0,
              5,
              6,
              0,
              5,
              7,
              0,
              5,
              8,
              0,
              6,
              7,
              0,
              6,
              8,
              0,
              7,
              8,
              1,
              2,
              3,
              1,
              2,
              4,
              1,
              2,
              5,
              1,
              2,
              6,
              1,
              2,
              7,
              1,
              2,
              8,
              1,
              3,
              4,
              1,
              3,
              5,
              1,
              3,
              6,
              1,
              3,
              7,
              1,
              3,
              8,
              1,
              4,
              5,
              1,
              4,
              6,
              1,
              4,
              7,
              1,
              4,
              8,
              1,
              5,
              6,
              1,
              5,
              7,
              1,
              5,
              8,
              1,
              6,
              7,
              1,
              6,
              8,
              1,
              7,
              8,
              2,
              3,
              4,
              2,
              3,
              5,
              2,
              3,
              6,
              2,
              3,
              7,
              2,
              3,
              8,
              2,
              4,
              5,
              2,
              4,
              6,
              2,
              4,
              7,
              2,
              4,
              8,
              2,
              5,
              6,
              2,
              5,
              7,
              2,
              5,
              8,
              2,
              6,
              7,
              2,
              6,
              8,
              2,
              7,
              8,
              3,
              4,
              5,
              3,
              4,
              6,
              3,
              4,
              7,
              3,
              4,
              8,
              3,
              5,
              6,
              3,
              5,
              7,
              3,
              5,
              8,
              3,
              6,
              7,
              3,
              6,
              8,
              3,
              7,
              8,
              4,
              5,
              6,
              4,
              5,
              7,
              4,
              5,
              8,
              4,
              6,
              7,
              4,
              6,
              8,
              4,
              7,
              8,
              5,
              6,
              7,
              5,
              6,
              8,
              5,
              7,
              8,
              6,
              7,
              8,
          ),
          dtype=np.int32,
      ).reshape(84, 3)
  
      num_kernels = len(indices)
      num_dilations = len(dilations)
      num_dilations1 = len(dilations1)
  
      num_features = num_kernels * np.sum(num_features_per_dilation)
      num_features1 = num_kernels * np.sum(num_features_per_dilation1)
  
      features = np.zeros(
          (
              num_examples,
              (num_features + num_features1) * n_features_per_kernel,
          ),
          dtype=np.float32,
      )
      n_features_per_transform = np.int64(features.shape[1] / 2)
  
      for example_index in prange(num_examples):
          _X = X[example_index]
  
          A = -_X  # A = alpha * X = -X
          G = _X + _X + _X  # G = gamma * X = 3X
  
          # Base series
          feature_index_start = 0
  
          for dilation_index in range(num_dilations):
              _padding0 = dilation_index % 2
  
              dilation = dilations[dilation_index]
              padding = ((9 - 1) * dilation) // 2
  
              num_features_this_dilation = num_features_per_dilation[
                  dilation_index
              ]
  
              C_alpha = np.zeros(input_length, dtype=np.float32)
              C_alpha[:] = A
  
              C_gamma = np.zeros((9, input_length), dtype=np.float32)
              C_gamma[9 // 2] = G
  
              start = dilation
              end = input_length - padding
  
              for gamma_index in range(9 // 2):
                  C_alpha[-end:] = C_alpha[-end:] + A[:end]
                  C_gamma[gamma_index, -end:] = G[:end]
  
                  end += dilation
  
              for gamma_index in range(9 // 2 + 1, 9):
                  C_alpha[:-start] = C_alpha[:-start] + A[start:]
                  C_gamma[gamma_index, :-start] = G[start:]
  
                  start += dilation
  
              for kernel_index in range(num_kernels):
                  feature_index_end = (
                      feature_index_start + num_features_this_dilation
                  )
  
                  _padding1 = (_padding0 + kernel_index) % 2
  
                  index_0, index_1, index_2 = indices[kernel_index]
  
                  C = (
                      C_alpha
                      + C_gamma[index_0]
                      + C_gamma[index_1]
                      + C_gamma[index_2]
                  )
  
                  if _padding1 == 0:
                      for feature_count in range(
                          num_features_this_dilation
                      ):
                          feature_index = (
                              feature_index_start + feature_count
                          )
                          _bias = biases[feature_index]
  
                          ppv = 0
                          last_val = 0
                          max_stretch = 0.0
                          mean_index = 0
                          mean = 0
  
                          for j in range(C.shape[0]):
                              if C[j] > _bias:
                                  ppv += 1
                                  mean_index += j
                                  mean += C[j] + _bias
                              elif C[j] < _bias:
                                  stretch = j - last_val
                                  if stretch > max_stretch:
                                      max_stretch = stretch
                                  last_val = j
                          stretch = C.shape[0] - 1 - last_val
                          if stretch > max_stretch:
                              max_stretch = stretch
  
                          end = feature_index
                          features[example_index, end] = (
                              ppv / C.shape[0]
                          )
                          end = end + num_features
                          features[example_index, end] = max_stretch
                          end = end + num_features
                          features[example_index, end] = (
                              mean / ppv if ppv > 0 else 0
                          )
                          end = end + num_features
                          features[example_index, end] = (
                              mean_index / ppv if ppv > 0 else -1
                          )
                  else:
                      _c = C[padding:-padding]
  
                      for feature_count in range(
                          num_features_this_dilation
                      ):
                          feature_index = (
                              feature_index_start + feature_count
                          )
                          _bias = biases[feature_index]
  
                          ppv = 0
                          last_val = 0
                          max_stretch = 0.0
                          mean_index = 0
                          mean = 0
  
                          for j in range(_c.shape[0]):
                              if _c[j] > _bias:
                                  ppv += 1
                                  mean_index += j
                                  mean += _c[j] + _bias
                              elif _c[j] < _bias:
                                  stretch = j - last_val
                                  if stretch > max_stretch:
                                      max_stretch = stretch
                                  last_val = j
                          stretch = _c.shape[0] - 1 - last_val
                          if stretch > max_stretch:
                              max_stretch = stretch
  
                          end = feature_index
                          features[example_index, end] = (
                              ppv / _c.shape[0]
                          )
                          end = end + num_features
                          features[example_index, end] = max_stretch
                          end = end + num_features
                          features[example_index, end] = (
                              mean / ppv if ppv > 0 else 0
                          )
                          end = end + num_features
                          features[example_index, end] = (
                              mean_index / ppv if ppv > 0 else -1
                          )
  
                  feature_index_start = feature_index_end
  
          # First order difference
          _X1 = X1[example_index]
          A1 = -_X1  # A = alpha * X = -X
          G1 = _X1 + _X1 + _X1  # G = gamma * X = 3X
  
          feature_index_start = 0
  
          for dilation_index in range(num_dilations1):
              _padding0 = dilation_index % 2
  
              dilation = dilations1[dilation_index]
              padding = ((9 - 1) * dilation) // 2
  
              num_features_this_dilation = num_features_per_dilation1[
                  dilation_index
              ]
  
              C_alpha = np.zeros(input_length - 1, dtype=np.float32)
              C_alpha[:] = A1
  
              C_gamma = np.zeros(
                  (9, input_length - 1), dtype=np.float32
              )
              C_gamma[9 // 2] = G1
  
              start = dilation
              end = input_length - padding
  
              for gamma_index in range(9 // 2):
                  C_alpha[-end:] = C_alpha[-end:] + A1[:end]
                  C_gamma[gamma_index, -end:] = G1[:end]
  
                  end += dilation
  
              for gamma_index in range(9 // 2 + 1, 9):
                  C_alpha[:-start] = C_alpha[:-start] + A1[start:]
                  C_gamma[gamma_index, :-start] = G1[start:]
  
                  start += dilation
  
              for kernel_index in range(num_kernels):
                  feature_index_end = (
                      feature_index_start + num_features_this_dilation
                  )
  
                  _padding1 = (_padding0 + kernel_index) % 2
  
                  index_0, index_1, index_2 = indices[kernel_index]
  
                  C = (
                      C_alpha
                      + C_gamma[index_0]
                      + C_gamma[index_1]
                      + C_gamma[index_2]
                  )
  
                  if _padding1 == 0:
                      for feature_count in range(
                          num_features_this_dilation
                      ):
                          feature_index = (
                              feature_index_start + feature_count
                          )
                          _bias = biases1[feature_index]
  
                          ppv = 0
                          last_val = 0
                          max_stretch = 0.0
                          mean_index = 0
                          mean = 0
  
                          for j in range(C.shape[0]):
                              if C[j] > _bias:
                                  ppv += 1
                                  mean_index += j
                                  mean += C[j] + _bias
                              elif C[j] < _bias:
                                  stretch = j - last_val
                                  if stretch > max_stretch:
                                      max_stretch = stretch
                                  last_val = j
                          stretch = C.shape[0] - 1 - last_val
                          if stretch > max_stretch:
                              max_stretch = stretch
  
                          end = feature_index + n_features_per_transform
                          features[example_index, end] = (
                              ppv / C.shape[0]
                          )
                          end = end + num_features
                          features[example_index, end] = max_stretch
                          end = end + num_features
                          features[example_index, end] = (
                              mean / ppv if ppv > 0 else 0
                          )
                          end = end + num_features
                          features[example_index, end] = (
                              mean_index / ppv if ppv > 0 else -1
                          )
                  else:
                      _c = C[padding:-padding]
  
                      for feature_count in range(
                          num_features_this_dilation
                      ):
                          feature_index = (
                              feature_index_start + feature_count
                          )
                          _bias = biases1[feature_index]
  
                          ppv = 0
                          last_val = 0
                          max_stretch = 0.0
                          mean_index = 0
                          mean = 0
  
                          for j in range(_c.shape[0]):
                              if _c[j] > _bias:
                                  ppv += 1
                                  mean_index += j
                                  mean += _c[j] + _bias
                              elif _c[j] < _bias:
                                  stretch = j - last_val
                                  if stretch > max_stretch:
                                      max_stretch = stretch
                                  last_val = j
                          stretch = _c.shape[0] - 1 - last_val
                          if stretch > max_stretch:
                              max_stretch = stretch
  
                          end = feature_index + n_features_per_transform
                          features[example_index, end] = (
                              ppv / _c.shape[0]
                          )
                          end = end + num_features
                          features[example_index, end] = max_stretch
                          end = end + num_features
                          features[example_index, end] = (
                              mean / ppv if ppv > 0 else 0
                          )
                          end = end + num_features
                          features[example_index, end] = (
                              mean_index / ppv if ppv > 0 else -1
                          )
  
                  feature_index_start = feature_index_end
  
      return features
  
imports: import numpy
  from sktime.utils.numba.njit import njit
  from sktime.utils.validation._dependencies import _check_soft_dependencies
label_desc: Use image node_id 1 for calling a global function with example usage: _transform(X, X1, parameters, parameters1, n_features_per_kernel) and returns: features