parameters: (tyctx, shape_tuple, value, axis)
return_statement: return function_sig, codegen
docstring: Generates a tuple that can be used to index a specific slice from an
      array for sum with axis.  shape_tuple is the size of the dimensions of
      the input array.  'value' is the value to put in the indexing tuple
      in the axis dimension and 'axis' is that dimension.  For this to work,
      axis has to be a const.
docstring_summary: Generates a tuple that can be used to index a specific slice from an
      array for sum with axis.  shape_tuple is the size of the dimensions of
      the input array.  'value' is the value to put in the indexing tuple
      in the axis dimension and 'axis' is that dimension.  For this to work,
      axis has to be a const.
docstring_tokens: Generates a tuple that can be used to index a specific slice from an array for sum with axis . shape_tuple is the size of the dimensions of the input array . value is the value to put in the indexing tuple in the axis dimension and axis is that dimension . For this to work axis has to be a const .
function: def _gen_index_tuple(tyctx, shape_tuple, value, axis):
      """
      Generates a tuple that can be used to index a specific slice from an
      array for sum with axis.  shape_tuple is the size of the dimensions of
      the input array.  'value' is the value to put in the indexing tuple
      in the axis dimension and 'axis' is that dimension.  For this to work,
      axis has to be a const.
      """
      if not isinstance(axis, types.Literal):
          raise RequireLiteralValue('axis argument must be a constant')
      # Get the value of the axis constant.
      axis_value = axis.literal_value
      # The length of the indexing tuple to be output.
      nd = len(shape_tuple)
  
      # If the axis value is impossible for the given size array then
      # just fake it like it was for axis 0.  This will stop compile errors
      # when it looks like it could be called from array_sum_axis but really
      # can't because that routine checks the axis mismatch and raise an
      # exception.
      if axis_value >= nd:
          axis_value = 0
  
      # Calculate the type of the indexing tuple.  All the non-axis
      # dimensions have slice2 type and the axis dimension has int type.
      before = axis_value
      after = nd - before - 1
  
      types_list = []
      types_list += [types.slice2_type] * before
      types_list += [types.intp]
      types_list += [types.slice2_type] * after
  
      # Creates the output type of the function.
      tupty = types.Tuple(types_list)
      # Defines the signature of the intrinsic.
      function_sig = tupty(shape_tuple, value, axis)
  
      def codegen(cgctx, builder, signature, args):
          lltupty = cgctx.get_value_type(tupty)
          # Create an empty indexing tuple.
          tup = cgutils.get_null_value(lltupty)
  
          # We only need value of the axis dimension here.
          # The rest are constants defined above.
          [_, value_arg, _] = args
  
          def create_full_slice():
              return slice(None, None)
  
          # loop to fill the tuple with slice(None,None) before
          # the axis dimension.
  
          # compile and call create_full_slice
          slice_data = cgctx.compile_internal(builder, create_full_slice,
                                              types.slice2_type(),
                                              [])
          for i in range(0, axis_value):
              tup = builder.insert_value(tup, slice_data, i)
  
          # Add the axis dimension 'value'.
          tup = builder.insert_value(tup, value_arg, axis_value)
  
          # loop to fill the tuple with slice(None,None) after
          # the axis dimension.
          for i in range(axis_value + 1, nd):
              tup = builder.insert_value(tup, slice_data, i)
          return tup
  
      return function_sig, codegen
function_tokens: def _gen_index_tuple ( tyctx , shape_tuple , value , axis ) : if not isinstance ( axis , types . Literal ) : raise RequireLiteralValue ( 'axis argument must be a constant' ) # Get the value of the axis constant. axis_value = axis . literal_value # The length of the indexing tuple to be output. nd = len ( shape_tuple ) # If the axis value is impossible for the given size array then # just fake it like it was for axis 0.  This will stop compile errors # when it looks like it could be called from array_sum_axis but really # can't because that routine checks the axis mismatch and raise an # exception. if axis_value >= nd : axis_value = 0 # Calculate the type of the indexing tuple.  All the non-axis # dimensions have slice2 type and the axis dimension has int type. before = axis_value after = nd - before - 1 types_list = [ ] types_list += [ types . slice2_type ] * before types_list += [ types . intp ] types_list += [ types . slice2_type ] * after # Creates the output type of the function. tupty = types . Tuple ( types_list ) # Defines the signature of the intrinsic. function_sig = tupty ( shape_tuple , value , axis ) def codegen ( cgctx , builder , signature , args ) : lltupty = cgctx . get_value_type ( tupty ) # Create an empty indexing tuple. tup = cgutils . get_null_value ( lltupty ) # We only need value of the axis dimension here. # The rest are constants defined above. [ _ , value_arg , _ ] = args def create_full_slice ( ) : return slice ( None , None ) # loop to fill the tuple with slice(None,None) before # the axis dimension. # compile and call create_full_slice slice_data = cgctx . compile_internal ( builder , create_full_slice , types . slice2_type ( ) , [ ] ) for i in range ( 0 , axis_value ) : tup = builder . insert_value ( tup , slice_data , i ) # Add the axis dimension 'value'. tup = builder . insert_value ( tup , value_arg , axis_value ) # loop to fill the tuple with slice(None,None) after # the axis dimension. for i in range ( axis_value + 1 , nd ) : tup = builder . insert_value ( tup , slice_data , i ) return tup return function_sig , codegen