docs: def fraction_correct_fuzzy_linear(x_values, y_values, x_cutoff = 1.0, x_fuzzy_range = 0.1, y_scalar = 1.0, y_cutoff = None):
      '''A version of fraction_correct which is more forgiving at the boundary positions.
         In fraction_correct, if the x value is 1.01 and the y value is 0.99 (with cutoffs of 1.0) then that pair evaluates
         to zero despite the results being very close to each other.
         This function corrects for the boundary by overlapping the ranges and attenuating the endpoints.
         This version of the function uses a linear approach - a classification (positive, negative, neutral resp. P, N, X)
         is 1 for some range of values, 0 for a separate range, and between 0 and 1 for the in-between range i.e.
             N       X        P
            ----\  /----\  /-----
                 \/      \/
                 /\      /\
            ----/  \----/  \----
         This approach was suggested by Kale Kundert.
      '''
      num_points = len(x_values)
      assert(num_points == len(y_values))
      correct = 0.0
      considered_points = 0
      y_fuzzy_range = x_fuzzy_range * y_scalar
      if y_cutoff == None:
          y_cutoff = x_cutoff * y_scalar
      for i in range(num_points):
          x = x_values[i]
          y = y_values[i]
          xvec = fraction_correct_fuzzy_linear_create_vector(x, x_cutoff, x_fuzzy_range)
          yvec = fraction_correct_fuzzy_linear_create_vector(y, y_cutoff, y_fuzzy_range)
          if not(isinstance(xvec, NoneType)) and not(isinstance(yvec, NoneType)):
              correct += numpy.dot(xvec, yvec)
              considered_points += 1
      return correct / float(considered_points)