class_docstr: Generate code for a fused-type special function that can be
  cimported in Cython.
code: def _generate_from_outargs_and_no_return(self):
      tab = " " * 4
      all_tmpvars = set()
      specs, body = [], []
      for signum, sig in enumerate(self.signatures):
          (
              func_name,
              incodes,
              outcodes,
              retcode,
              intypes,
              outtypes,
              rettype,
              c,
              lines,
              sp,
          ) = self._get_common(signum, sig)
          body.extend(lines)
  
          # Generate the call to the specialized function
          callvars = self._get_incallvars(intypes, c)
          outcallvars, tmpvars, casts = self._get_outcallvars(
              outtypes, c
          )
          callvars.extend(outcallvars)
          all_tmpvars.update(tmpvars)
  
          call = "{}({})".format(func_name, ", ".join(callvars))
          body.append(sp + call)
          body.extend([sp + x for x in casts])
          if len(outcodes) == 1:
              sig = f"{incodes}->{outcodes}"
              specs.append(sig)
          else:
              sig = f"{incodes}*{outcodes}->v"
              specs.append(sig)
  
      if len(specs) > 1:
          lines = self._get_nan_decs()
          body.extend(lines)
  
      if len(self.outvars) == 1:
          line = f"return {self.outvars[0]}[0]"
          body.append(tab + line)
  
      # Generate the head of the function
      callvars, head = [], []
      for invar, (intype, _) in zip(self.invars, self.intypes):
          callvars.append(f"{intype} {invar}")
      if len(self.outvars) > 1:
          for outvar, (outtype, _) in zip(self.outvars, self.outtypes):
              callvars.append(f"{outtype} *{outvar}")
      if len(self.outvars) == 1:
          outtype, _ = self.outtypes[0]
          dec = "cpdef {} {}({}) noexcept nogil".format(
              outtype, self.name, ", ".join(callvars)
          )
      else:
          dec = "cdef void {}({}) noexcept nogil".format(
              self.name, ", ".join(callvars)
          )
      head.append(dec + ":")
      head.append(tab + f'"""{self.doc}"""')
      if len(self.outvars) == 1:
          outvar = self.outvars[0]
          outtype, _ = self.outtypes[0]
          line = f"cdef {outtype} {outvar}"
          head.append(tab + line)
      head.extend(self._get_tmp_decs(all_tmpvars))
  
      src = "\n".join(head + body)
      return dec, src, specs
  
imports: import itertools
  import json
  import os
  from stat import ST_MTIME
  import argparse
  import re
  import textwrap
  import numpy
label_desc: Use image node_id 13 for calling the FusedFunc obj's underlying member method code with example usage: obj._generate_from_outargs_and_no_return() and returns: dec,  src,  specs