<pre>
Description of the output(s).
</pre>

<code>repeated .tensorflow.OpDef.ArgDef output_arg = 3;</code>
542793
public org.tensorflow.framework.OpDef.ArgDef getOutputArg(int index) {
    return outputArg_.get(index);
  }
422769
def p_statement_draw3(p):
    
    p[0] = make_sentence('DRAW3',
                         make_typecast(TYPE.integer, p[2], p.lineno(3)),
                         make_typecast(TYPE.integer, p[4], p.lineno(5)),
                         make_typecast(TYPE.float_, p[6], p.lineno(5)))
277707
def _output(cls, fluents: Sequence[FluentPair]) -> Sequence[tf.Tensor]:
        ''''''
        return tuple(cls._dtype(t) for t in cls._tensors(fluents))
1340635
public String generateOutput() {
        if (blockDynTab[0].instances == 0) {
            addBlockByNo(0);
        } // add main block
        for (int blockNo = 0; blockNo < mtp.blockTabCnt; blockNo++) {
            BlockDynTabRec bdtr = blockDynTab[blockNo];
            bdtr.currBlockInstNo = bdtr.firstBlockInstNo;
        }
        StringBuilder out = new StringBuilder();
        writeBlockInstances(out, 0, -1);
        return out.toString();
    }
162088
public org.tensorflow.framework.TensorInfo getOutputsOrDefault(
      java.lang.String key,
      org.tensorflow.framework.TensorInfo defaultValue) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, org.tensorflow.framework.TensorInfo> map =
        internalGetOutputs().getMap();
    return map.containsKey(key) ? map.get(key) : defaultValue;
  }
1130904
public static synchronized Map<String,OpDef> opDescs() {
        if(DESCRIPTORS != null){
            return DESCRIPTORS;
        }

        try (InputStream contents = new ClassPathResource("ops.proto").getInputStream(); BufferedInputStream bis2 = new BufferedInputStream(contents); BufferedReader reader = new BufferedReader(new InputStreamReader(bis2))) {
            org.tensorflow.framework.OpList.Builder builder = org.tensorflow.framework.OpList.newBuilder();

            StringBuilder str = new StringBuilder();
            String line = null;
            while ((line = reader.readLine()) != null) {
                str.append(line);//.append("\n");
            }


            TextFormat.getParser().merge(str.toString(), builder);
            List<OpDef> list =  builder.getOpList();
            Map<String,OpDef> map = new HashMap<>();
            for(OpDef opDef : list) {
                map.put(opDef.getName(),opDef);
            }

            DESCRIPTORS = map;
            return DESCRIPTORS;
        } catch (Exception e) {
            throw new ND4JIllegalStateException("Unable to load tensorflow descriptors", e);
        }

    }
1255943
function buildArgs (source, givenOutput, loop, initialVolume, showOsd) {
	let output = '';

	if (givenOutput) {

		if (ALLOWED_OUTPUTS.indexOf(givenOutput) === -1) {
			throw new Error(`Output ${givenOutput} not allowed.`);
		}

		output = givenOutput;

	} else {
		output = 'local';
	}

	let osd = false;
	if (showOsd) {
		osd = showOsd;
	}

	let args = [source, '-o', output, '--blank', osd ? '' : '--no-osd'];

	// Handle the loop argument, if provided
	if (loop) {
		args.push('--loop');
	}

	// Handle the initial volume argument, if provided
	if (Number.isInteger(initialVolume)) {
		args.push('--vol', initialVolume);
	}

	return args;

}
703852
public OpDef getOpDefByTensorflowName(String name) {
        if(!tensorflowOpDescriptors.containsKey(name)) {
            throw new ND4JIllegalStateException("No op found with name " + name);
        }

        return tensorflowOpDescriptors.get(name);
    }
783189
def write(self, output):
        
        w = c_int32()
        # print "output max", max(abs(output))
        self.WriteAnalogF64(self.bufsize, 0, 10.0, DAQmx_Val_GroupByChannel,
                            output, w, None);
228697
public static void printResult(Number[][] m1, Number[][] m2, Number[][] m3, char op, PrintStream out)
    {
        for (int i = 0; i < m1.length; i++)
        {
            for (int j = 0; j < m1[0].length; j++)
            {
                out.print(" " + m1[i][j]);
            }

            if (i == m1.length / 2)
            {
                out.print("  " + op + "  ");
            }
            else
            {
                out.print("     ");
            }

            for (int j = 0; j < m2.length; j++)
            {
                out.print(" " + m2[i][j]);
            }

            if (i == m1.length / 2)
            {
                out.print("  =  ");
            }
            else
            {
                out.print("     ");
            }

            for (int j = 0; j < m3.length; j++)
            {
                out.print(m3[i][j] + " ");
            }

            out.println();
        }
    }
724096
public java.util.List<org.tensorflow.framework.OpDef.AttrDef> getAttrList() {
    return attr_;
  }
341734
public org.tensorflow.distruntime.TraceOpts getOptions() {
    return options_ == null ? org.tensorflow.distruntime.TraceOpts.getDefaultInstance() : options_;
  }
531761
public static String print(ArgModifier modifier) {
        return modifier.match(new ArgModifier.MatchBlock<String>() {

            @Override
            public String _case(Final x) {
                return "final";
            }

            @Override
            public String _case(Volatile x) {
                return "volatile";
            }

            @Override
            public String _case(Transient x) {
                return "transient";
            }
        });
    }
758685
def show(self):
        
        off = 0
        for n, i in enumerate(self.get_instructions()):
            print("{:8d} (0x{:08x}) {:04x} {:30} {}".format(n, off, i.get_op_value(), i.get_name(), i.get_output(self.idx)))
            off += i.get_length()
409693
private String getMethodArgs(Method m)
    {
        StringBuffer sb = new StringBuffer();
        Class [] argTypes = m.getParameterTypes();
        for (int i = 0; i < argTypes.length; i++)
        {
            if (i != 0) sb.append(",");
            sb.append(argTypes[i].toString());
        }
        return sb.toString();
    }
558780
def _output(cls, fluents: Sequence[FluentPair]) -> Sequence[tf.Tensor]:
        ''''''
        output = []
        for _, fluent in fluents:
            tensor = fluent.tensor
            if tensor.dtype != tf.float32:
                tensor = tf.cast(tensor, tf.float32)
            output.append(tensor)
        return tuple(output)
1096207
def convert_predictions_to_image_summaries(hook_args):
  
  decode_hparams = hook_args.decode_hparams
  if not decode_hparams.display_decoded_images:
    return []
  predictions = hook_args.predictions[0]

  # Display ten random inputs and outputs so that tensorboard does not hang.
  all_summaries = []
  rand_predictions = np.random.choice(predictions, size=10)
  for ind, prediction in enumerate(rand_predictions):
    output_summary = image_to_tf_summary_value(
        prediction["outputs"], tag="%d_output" % ind)
    input_summary = image_to_tf_summary_value(
        prediction["inputs"], tag="%d_input" % ind)
    all_summaries.append(input_summary)
    all_summaries.append(output_summary)
  return all_summaries