code: def _process_ndarray(
      X_col, nonmissings, categories, processing, min_unique_continuous
  ):
      if processing == "continuous":
          # called under: fit or predict
          X_col, bad = _process_continuous(X_col, nonmissings)
          return "continuous", X_col, None, bad
      elif processing == "nominal":
          if categories is None:
              # called under: fit
              X_col, categories = _process_column_initial(
                  X_col, nonmissings, None, None
              )
              return "nominal", X_col, categories, None
          else:
              # called under: predict
              X_col, bad = _encode_categorical_existing(
                  X_col, nonmissings, categories
              )
              return "nominal", X_col, categories, bad
      elif processing == "ordinal":
          if categories is None:
              # called under: fit
              # if the caller passes "ordinal" during fit, the only order that makes sense is either
              # alphabetical or based on float values. Frequency doesn't make sense
              # if the caller would prefer an error, they can check feature_types themselves
              X_col, categories = _process_column_initial(
                  X_col, nonmissings, None, None
              )
              return "ordinal", X_col, categories, None
          else:
              # called under: predict
              X_col, bad = _encode_categorical_existing(
                  X_col, nonmissings, categories
              )
              return "ordinal", X_col, categories, bad
      elif processing is None or processing == "auto":
          # called under: fit
          X_col, categories = _process_column_initial(
              X_col, nonmissings, None, min_unique_continuous
          )
          return (
              "continuous" if categories is None else "nominal",
              X_col,
              categories,
              None,
          )
      elif (
          processing == "nominal_prevalence"
          or processing == "nominal_alphabetical"
      ):
          # called under: fit
          X_col, categories = _process_column_initial(
              X_col, nonmissings, processing, None
          )
          return "nominal", X_col, categories, None
      elif (
          processing == "quantile"
          or processing == "rounded_quantile"
          or processing == "uniform"
          or processing == "winsorized"
      ):
          # called under: fit
          X_col, bad = _process_continuous(X_col, nonmissings)
          return "continuous", X_col, None, bad
      elif isinstance(processing, int):
          # called under: fit
          X_col, categories = _process_column_initial(
              X_col, nonmissings, None, processing
          )
          return (
              "continuous" if categories is None else "nominal",
              X_col,
              categories,
              None,
          )
      elif processing == "ignore":
          # called under: fit or predict
          X_col, categories = _process_column_initial(
              X_col, nonmissings, None, None
          )
          mapping = np.empty(len(categories) + 1, np.object_)
          mapping.itemset(0, None)
          for category, idx in categories.items():
              mapping.itemset(idx, category)
          bad = mapping[X_col]
          return "ignore", None, None, bad
      elif isinstance(processing, str):
          # called under: fit
  
          # don't allow strings to get to the np.array conversion below
          msg = f"{processing} type invalid"
          _log.error(msg)
          raise ValueError(msg)
      else:
          # called under: fit
  
          n_items = 0
          n_ordinals = 0
          n_continuous = 0
          try:
              for item in processing:
                  n_items += 1
                  if isinstance(item, str):
                      n_ordinals += 1
                  elif (
                      isinstance(item, float)
                      or isinstance(item, int)
                      or isinstance(item, np.floating)
                      or isinstance(item, np.integer)
                  ):
                      n_continuous += 1
          except TypeError:
              msg = f"{processing} type invalid"
              _log.error(msg)
              raise TypeError(msg)
  
          if n_continuous == n_items:
              # if n_items == 0 then it must be continuous since we
              # can have zero cut points, but not zero ordinal categories
              X_col, bad = _process_continuous(X_col, nonmissings)
              return "continuous", X_col, None, bad
          elif n_ordinals == n_items:
              categories = dict(zip(processing, count(1)))
              X_col, bad = _encode_categorical_existing(
                  X_col, nonmissings, categories
              )
              return "ordinal", X_col, categories, bad
          else:
              msg = f"{processing} type invalid"
              _log.error(msg)
              raise TypeError(msg)
  
imports: from collections import Counter
  from itertools import count
  import numpy
  import numpy.ma
  import logging
label_desc: Use image node_id 7 for calling a global function with example usage: _process_ndarray(X_col, nonmissings, categories, processing, min_unique_continuous) and returns: str,  X_col,  None,  bad, str,  X_col,  categories,  None, str,  X_col,  categories,  bad, str,  X_col,  categories,  None, str,  X_col,  categories,  bad, unknown,  X_col,  categories,  None, str,  X_col,  categories,  None, str,  X_col,  None,  bad, unknown,  X_col,  categories,  None, str,  None,  None,  bad, str,  X_col,  None,  bad, str,  X_col,  categories,  bad