code: def rand_zipfian(true_classes, num_sampled, range_max, ctx=None):
      """Draw random samples from an approximately log-uniform or Zipfian distribution.
  
      This operation randomly samples *num_sampled* candidates the range of integers [0, range_max).
      The elements of sampled_candidates are drawn with replacement from the base distribution.
  
      The base distribution for this operator is an approximately log-uniform or Zipfian distribution:
  
      P(class) = (log(class + 2) - log(class + 1)) / log(range_max + 1)
  
      This sampler is useful when the true classes approximately follow such a distribution.
      For example, if the classes represent words in a lexicon sorted in decreasing order of \
      frequency. If your classes are not ordered by decreasing frequency, do not use this op.
  
      Additionaly, it also returns the number of times each of the \
      true classes and the sampled classes is expected to occur.
  
      Parameters
      ----------
      true_classes : NDArray
          A 1-D NDArray of the target classes.
      num_sampled: int
          The number of classes to randomly sample.
      range_max: int
          The number of possible classes.
      ctx : Context
          Device context of output. Default is current context.
  
      Returns
      -------
      samples: NDArray
          The sampled candidate classes in 1-D `int64` dtype.
      expected_count_true: NDArray
          The expected count for true classes in 1-D `float64` dtype.
      expected_count_sample: NDArray
          The expected count for sampled candidates in 1-D `float64` dtype.
  
      Examples
      --------
      >>> true_cls = mx.nd.array([3])
      >>> samples, exp_count_true, exp_count_sample = mx.nd.contrib.rand_zipfian(true_cls, 4, 5)
      >>> samples
      [1 3 3 3]
      <NDArray 4 @cpu(0)>
      >>> exp_count_true
      [ 0.12453879]
      <NDArray 1 @cpu(0)>
      >>> exp_count_sample
      [ 0.22629439  0.12453879  0.12453879  0.12453879]
      <NDArray 4 @cpu(0)>
      """
      if ctx is None:
          ctx = current_device()
      log_range = math.log(range_max + 1)
      rand = uniform(
          0, log_range, shape=(num_sampled,), dtype="float64", ctx=ctx
      )
      # make sure sampled_classes are in the range of [0, range_max)
      sampled_classes = (rand.exp() - 1).astype("int64") % range_max
  
      true_cls = true_classes.as_in_context(ctx).astype("float64")
      expected_count_true = (
          ((true_cls + 2.0) / (true_cls + 1.0)).log()
          / log_range
          * num_sampled
      )
      # cast sampled classes to fp64 to avoid interget division
      sampled_cls_fp64 = sampled_classes.astype("float64")
      expected_prob_sampled = (
          (sampled_cls_fp64 + 2.0) / (sampled_cls_fp64 + 1.0)
      ).log() / log_range
      expected_count_sampled = expected_prob_sampled * num_sampled
      return (
          sampled_classes,
          expected_count_true,
          expected_count_sampled,
      )
  
imports: import math
  import numpy
  import mxnet
  from ..device import current_device
  from ..random import uniform
  from ..base import _as_list
  from .None import ndarray
label_desc: Use image node_id 2 for calling a global function with example usage: rand_zipfian(true_classes, num_sampled, range_max, ctx) and returns: sampled_classes,  expected_count_true,  expected_count_sampled