code: def fixed_point_quantize(
      x,
      sign=True,
      n=8,
      delta=2**-4,
      quantize=True,
      ste_fine_grained=True,
      outputs=None,
  ):
      r"""Fixed Point Quantize.
  
      This function simulates to uniformly quantize values in fixed-point number representation.
  
      Args:
          x (Variable): An input variable.
          sign (bool): Indicate the signed number or the unsigned number. Default is true.
          n (int): Bit width used. Note that `sign` consumes one bit. :math:`n-1` is used for number representation in `signed` case.   
          delta (float): Step size.
          quantize (bool): If true, quantize input, otherwise not.
          ste_fine_grained (bool): If true, STE is not 1.
  
      Returns:
          ~nnabla.Variable: N-D array.
  
      See Also:
          ``nnabla.function_bases.fixed_point_quantize``.
  
      In the forward pass, 
  
      .. math::
  
          \begin{equation}
              q_i= \left\{
                 \begin{array}{ll}
                      max & if \ \ \ x_i > max \\
                      sign(x_i) \times floor(|x_i| \delta^{-1} + 2^{-1}) \times \delta & if \ \ min \le x_i \le max \\
                      min & if \ \ x_i < min \\
                 \end{array} \right.,
          \end{equation}
  
      where :math:`\delta` is the step size, 
      :math:`(min, max) :=(- (2^{n-1} - 1)\delta, (2^{n-1} - 1)\delta)` if :math:`sign` is true, 
      :math:`(min, max) := (0, (2^n - 1) \delta)` otherwise, and  
      :math:`n` is the total bit-width used.
  
      In the backward pass when using `ste_fine_grained` as false,  
  
      .. math::
  
          \begin{equation}
              \frac{\partial q_i}{\partial x_i} = 1.
          \end{equation}
  
      In the backward pass when using `ste_fine_grained` as true,  
  
      .. math::
  
          \begin{equation}
              \frac{\partial q_i}{\partial x_i}= \left\{
                      \begin{array}{ll}
                                  0 & if \ \ \ x_i > max \\
                              1 & if \ \ min \le x_i \le max \\
                              0 & if \ \ x_i < min \\
                      \end{array} \right..
          \end{equation}
  
      .. note::
  
          Quantized values are stored as floating point number, since this function is for simulation purposes.
  
      """
      from .function_bases import (
          fixed_point_quantize as fixed_point_quantize_base,
      )
  
      if not quantize:
          return x
      return fixed_point_quantize_base(
          x, sign, n, delta, ste_fine_grained, outputs=outputs
      )
  
imports: from __future__ import absolute_import
  from .function_bases import *
  from .None import dtypes
  import nnabla
  import numpy
  from .normalization_functions import *
  from .numpy_compat_functions import *
label_desc: Use image node_id 14 for calling a global function with example usage: fixed_point_quantize(x, sign, n, delta, quantize, ste_fine_grained, outputs) and returns: fixed_point_quantize_base, x