class_docstr: Construct a multi-dimensional "meshgrid".
  
  ``grid = nd_grid()`` creates an instance which will return a mesh-grid
  when indexed.  The dimension and number of the output arrays are equal
  to the number of indexing dimensions.  If the step length is not a
  complex number, then the stop is not inclusive.
  
  However, if the step length is a **complex number** (e.g. 5j), then the
  integer part of its magnitude is interpreted as specifying the
  number of points to create between the start and stop values, where
  the stop value **is inclusive**.
  
  If instantiated with an argument of ``sparse=True``, the mesh-grid is
  open (or not fleshed out) so that only one-dimension of each returned
  argument is greater than 1.
  
  Parameters
  ----------
  sparse : bool, optional
      Whether the grid is sparse or not. Default is False.
  
  Notes
  -----
  Two instances of `nd_grid` are made available in the NumPy namespace,
  `mgrid` and `ogrid`, approximately defined as::
  
      mgrid = nd_grid(sparse=False)
      ogrid = nd_grid(sparse=True)
  
  Users should use these pre-defined instances instead of using `nd_grid`
  directly.
class_docstr_tok: ["Construct","a","multi-dimensional","``","meshgrid","''",".","``","grid","=","nd_grid","(",")","``","creates","an","instance","which","will","return","a","mesh-grid","when","indexed",".","The","dimension","and","number","of","the","output","arrays","are","equal","to","the","number","of","indexing","dimensions",".","If","the","step","length","is","not","a","complex","number",",","then","the","stop","is","not","inclusive",".","However",",","if","the","step","length","is","a","*","*","complex","number","*","*","(","e.g",".","5j",")",",","then","the","integer","part","of","its","magnitude","is","interpreted","as","specifying","the","number","of","points","to","create","between","the","start","and","stop","values",",","where","the","stop","value","*","*","is","inclusive","*","*",".","If","instantiated","with","an","argument","of","``","sparse=True","``",",","the","mesh-grid","is","open","(","or","not","fleshed","out",")","so","that","only","one-dimension","of","each","returned","argument","is","greater","than","1",".","Parameters","--","--","--","--","--","sparse",":","bool",",","optional","Whether","the","grid","is","sparse","or","not",".","Default","is","False",".","Notes","--","--","-","Two","instances","of","`","nd_grid","`","are","made","available","in","the","NumPy","namespace",",","`","mgrid","`","and","`","ogrid","`",",","approximately","defined","as",":",":","mgrid","=","nd_grid","(","sparse=False",")","ogrid","=","nd_grid","(","sparse=True",")","Users","should","use","these","pre-defined","instances","instead","of","using","`","nd_grid","`","directly","."]
code: def __getitem__(self, key):
      try:
          size = []
          typ = int
          for k in range(len(key)):
              step = key[k].step
              start = key[k].start
              if start is None:
                  start = 0
              if step is None:
                  step = 1
              if isinstance(step, complex):
                  size.append(int(abs(step)))
                  typ = float
              else:
                  size.append(
                      int(
                          math.ceil(
                              (key[k].stop - start) / (step * 1.0)
                          )
                      )
                  )
              if (
                  isinstance(step, float)
                  or isinstance(start, float)
                  or isinstance(key[k].stop, float)
              ):
                  typ = float
          if self.sparse:
              nn = [
                  _nx.arange(_x, dtype=_t)
                  for _x, _t in zip(size, (typ,) * len(size))
              ]
          else:
              nn = _nx.indices(size, typ)
          for k in range(len(size)):
              step = key[k].step
              start = key[k].start
              if start is None:
                  start = 0
              if step is None:
                  step = 1
              if isinstance(step, complex):
                  step = int(abs(step))
                  if step != 1:
                      step = (key[k].stop - start) / float(step - 1)
              nn[k] = nn[k] * step + start
          if self.sparse:
              slobj = [_nx.newaxis] * len(size)
              for k in range(len(size)):
                  slobj[k] = slice(None, None)
                  nn[k] = nn[k][tuple(slobj)]
                  slobj[k] = _nx.newaxis
          return nn
      except (IndexError, TypeError):
          step = key.step
          stop = key.stop
          start = key.start
          if start is None:
              start = 0
          if isinstance(step, complex):
              step = abs(step)
              length = int(step)
              if step != 1:
                  step = (key.stop - start) / float(step - 1)
              stop = key.stop + step
              return _nx.arange(0, length, 1, float) * step + start
          else:
              return _nx.arange(start, stop, step)
  
imports: from __future__ import division, absolute_import, print_function
  import functools
  import sys
  import math
  import numpy.core.numeric
  from numpy.core.numeric import asarray, ScalarType, array, alltrue, cumprod, arange, ndim
  from numpy.core.numerictypes import find_common_type, issubdtype
  import numpy.matrixlib
  from .function_base import diff
  from numpy.core.multiarray import ravel_multi_index, unravel_index
  from numpy.core.overrides import set_module
  from numpy.core import overrides, linspace
  from numpy.lib.stride_tricks import as_strided
label_desc: Use image node_id 2 for calling the nd_grid obj's underlying member method code with example usage: obj.__getitem__(key) and returns: nn, unknown, _nx