code: def ref_arccosine_kernel(
      X: AnyNDArray,
      order: int,
      weight_variances: AnyNDArray,
      bias_variance: AnyNDArray,
      signal_variance: AnyNDArray,
  ) -> AnyNDArray:
      num_points = X.shape[0]
      kernel = np.empty((num_points, num_points))
      for row in range(num_points):
          for col in range(num_points):
              x = X[row]
              y = X[col]
  
              numerator = (weight_variances * x).dot(y) + bias_variance
  
              x_denominator = np.sqrt(
                  (weight_variances * x).dot(x) + bias_variance
              )
              y_denominator = np.sqrt(
                  (weight_variances * y).dot(y) + bias_variance
              )
              denominator = x_denominator * y_denominator
  
              theta = np.arccos(
                  np.clip(numerator / denominator, -1.0, 1.0)
              )
              if order == 0:
                  J = np.pi - theta
              elif order == 1:
                  J = np.sin(theta) + (np.pi - theta) * np.cos(theta)
              elif order == 2:
                  J = 3.0 * np.sin(theta) * np.cos(theta)
                  J += (np.pi - theta) * (
                      1.0 + 2.0 * np.cos(theta) ** 2
                  )
  
              kernel[row, col] = (
                  signal_variance
                  * (1.0 / np.pi)
                  * J
                  * x_denominator**order
                  * y_denominator**order
              )
      return kernel
  
imports: import numpy
  from check_shapes import check_shapes
  from gpflow.base import AnyNDArray
label_desc: Use image node_id 2 for calling a global function with example usage: ref_arccosine_kernel(X, order, weight_variances, bias_variance, signal_variance) and returns: kernel