def METHOD_NAME(
    input_arg: "relay.Expr",
    floating_point_func: Callable[[np.array], np.array],
    in_scale: "relay.Expr",
    in_zero_point: "relay.Expr",
    out_scale: "relay.Expr",
    out_zero_point: "relay.Expr",
    in_axis: int = -1,
    out_axis: int = -1,
    in_dtype: str = "uint8",
    out_dtype: str = "uint8",
) -> "relay.Expr":
    """
    Create a quantized version of the given floating point unary operation using table lookup.
    Args:
      input_arg: The quantized input to the final function.
      floating_point_func: The numpy function which this table is to approximate
      in_scale: The scale of the quantized input tensor.
      in_zero_point: The zero point of the quantized input tensor.
      out_scale: The scale of the quantized output tensor.
      out_zero_point: The zero point of the quantized output tensor.
      in_axis: The axis for multi-channel quantization of the input if applicable.
      out_axis: The axis for multi-channel quantization of the output if applicable.
      in_dtype: The dtype of the input tensor.
      out_dtype: The wanted dtype of the output tensor.
    Returns:
      A Relay expression representing a quantized version of the given function.
    """
    # TODO: handle multi-channel q, below will fail with multi-channel q
    in_scale = in_scale.data.numpy().item()
    in_zero_point = in_zero_point.data.numpy().item()
    out_scale = out_scale.data.numpy().item()
    out_zero_point = out_zero_point.data.numpy().item()
    lookup_table = create_integer_lookup_table(
        floating_point_func,
        relay.const(in_scale),
        relay.const(in_zero_point, dtype="int32"),
        relay.const(out_scale),
        relay.const(out_zero_point, dtype="int32"),
        in_axis=in_axis,
        in_dtype=in_dtype,
        out_axis=out_axis,
        out_dtype=out_dtype,
    )
    in_dtype_info = np.iinfo(in_dtype)
    in_dtype_num_bits = in_dtype_info.bits
    lookup_table = relay.const(lookup_table)
    index_tensor = relay.reinterpret(input_arg, f"uint{in_dtype_num_bits}")
    result = relay.take(lookup_table, index_tensor, axis=0, mode="fast")
    return result