<pre>
Named output parameters.
</pre>

<code>map&lt;string, .tensorflow.TensorInfo&gt; outputs = 2;</code>
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;
  }
961687
@Override
    public Map<String, List<String>> toParameters() {
        final Map<String, List<String>> outParams = new LinkedHashMap<>();
        outParams.put("resource", Collections.singletonList(resource));
        outParams.put("grant_type", Collections.singletonList(GRANT_TYPE) );
        outParams.put("code", Collections.singletonList(deviceCode.getDeviceCode()));

        return outParams;
    }
880294
public static String stringForMap(Map<Object, Object> map) {
        StringBuilder sbOutput = new StringBuilder();
        if (map == null) {
            sbOutput.append("\tNULL");
        } else {
            for (Entry<Object, Object> entry : map.entrySet()) {
                sbOutput.append('\t').append(entry).append('\n');
            }
        }
        return sbOutput.toString();
    }
1373726
public Map<String, String> results(OutputVariable outputVariable) {
        return results(outputVariable, TimeUnit.NanoSeconds);
    }
268371
private static List<Parameter> convert(Map<String, Object> map) {
		Set<Entry<String, Object>> entries = map.entrySet();
		List<Parameter> parameters = new ArrayList<>(entries.size());
		for (Entry<String, Object> entry : entries) {
			if (entry.getValue() != null) {
				parameters.add(new Parameter(entry.getKey(), entry.getValue().toString()));
			}
		}
		return parameters;
	}
1058952
public static void printGenericCommandUsage(PrintStream out) {
    
    out.println("Generic options supported are");
    out.println("-conf <configuration file>     specify an application configuration file");
    out.println("-D <property=value>            use value for given property");
    out.println("-fs <local|namenode:port>      specify a namenode");
    out.println("-jt <local|jobtracker:port>    specify a job tracker");
    out.println("-files <comma separated list of files>    " + 
      "specify comma separated files to be copied to the map reduce cluster");
    out.println("-libjars <comma separated list of jars>    " +
      "specify comma separated jar files to include in the classpath.");
    out.println("-archives <comma separated list of archives>    " +
                "specify comma separated archives to be unarchived" +
                " on the compute machines.\n");
    out.println("The general command line syntax is");
    out.println("bin/hadoop command [genericOptions] [commandOptions]\n");
  }
1190739
private void computeNamedParams() {
        rawArgs.stream().filter(this::isNamedParam).forEach(arg -> {
            final int eqIdx = arg.indexOf('=');
            String key = arg.substring(2, eqIdx);
            String value = arg.substring(eqIdx + 1);
            namedParams.put(key, value);
        });
    }
1248435
def get_operation_output_names(self, operation_name):
    
    for output_tensor in self._name_to_operation(operation_name).outputs:
      yield output_tensor.name
1220982
@Override
    public synchronized Collection<IOutput> outputs()
    {
        if (null == outputs)
        {
            outputs = new ArrayList<IOutput>();
            final Iterator<Output> processInputs = service.getProcess().getOutputs().iterator();
            while (processInputs.hasNext())
            {
                outputs.add(new IOutput()
                {
                    private Output owlOutput = processInputs.next();

                    @Override
                    public String name()
                    {
                        return owlOutput.getName();
                    }

                    @Override
                    public ISemanticIdentifier getSemanticAnnotation()
                    {
                        //return new SemanticIdentifier(owlOutput.getType().getURI());
                        return new SemanticIdentifier(owlOutput.getParamType().getURI());
                    }
                });
            }
        }

        return outputs;
    }
120483
private String typeParameters(Options opt, ParameterizedType t) {
	if (t == null)
	    return "";
	StringBuffer tp = new StringBuffer(1000).append("&lt;");
	Type args[] = t.typeArguments();
	for (int i = 0; i < args.length; i++) {
	    tp.append(type(opt, args[i], true));
	    if (i != args.length - 1)
		tp.append(", ");
	}
	return tp.append("&gt;").toString();
    }
716609
function (outputName, renderer) {
        var outputInfo = this.outputs[outputName];
        var parameters = outputInfo.parameters;
        var parametersCopy = outputInfo._parametersCopy;
        if (!parametersCopy) {
            parametersCopy = outputInfo._parametersCopy = {};
        }
        if (parameters) {
            for (var key in parameters) {
                if (key !== 'width' && key !== 'height') {
                    parametersCopy[key] = parameters[key];
                }
            }
        }
        var width, height;
        if (typeof parameters.width === 'function') {
            width = parameters.width.call(this, renderer);
        }
        else {
            width = parameters.width;
        }
        if (typeof parameters.height === 'function') {
            height = parameters.height.call(this, renderer);
        }
        else {
            height = parameters.height;
        }
        width = Math.ceil(width);
        height = Math.ceil(height);
        if (
            parametersCopy.width !== width
            || parametersCopy.height !== height
        ) {
            if (this._outputTextures[outputName]) {
                this._outputTextures[outputName].dispose(renderer);
            }
        }
        parametersCopy.width = width;
        parametersCopy.height = height;

        return parametersCopy;
    }
836349
int getNumberOfNullEnderParameter(List<String> parameters) {
		int nbnull = 0;
		for (int i = parameters.size() - 1; i >= 0; i--) {
			String parameter = parameters.get(i);
			if (parameter.equals("null")) {
				nbnull++;
			} else {
				break;
			}
		}
		return nbnull;
	}
1064906
public java.util.List<org.tensorflow.framework.OpDef.ArgDef> getOutputArgList() {
    return outputArg_;
  }
659350
public java.util.Map<java.lang.String, org.tensorflow.framework.SignatureDef> getSignatureDefMap() {
    return internalGetSignatureDef().getMap();
  }
950193
private void getOutput(double[] y) {
        if (y.length != outputLayer.units) {
            throw new IllegalArgumentException(String.format("Invalid output vector size: %d, expected: %d", y.length, outputLayer.units));
        }
        System.arraycopy(outputLayer.output, 0, y, 0, outputLayer.units);
    }
1106834
private ArrayList<String> outputCalibrationResult(double[] parameters) {

		ArrayList<String> calibrationOutput = new ArrayList<String>();

		//We change the parameters of the model
		CalibratableProcess newModel = model.getCloneForModifiedParameters(parameters);
		CharacteristicFunctionModel newModelFourier = newModel.getCharacteristicFunctionModel();

		int numberOfMaturities = surface.getMaturities().length;
		double mats[] = surface.getMaturities();

		QuotingConvention targetConvention = surface.getQuotingConvention();

		double value;
		double targetValue;
		double T;
		double K;

		calibrationOutput.add("Strike"+ "\t" + "Maturity"+ "\t" + "Market Value" + "\t" + "Model Value" + "\t" + "Squared Error");

		for(int t = 0; t<numberOfMaturities; t++) {
			T = mats[t];
			OptionSmileData currentSmile = surface.getSmile(mats[t]);
			double[] currentStrikes = currentSmile.getStrikes();

			EuropeanOptionSmile newPricer = pricer.getCloneWithModifiedParameters(mats[t],currentStrikes);

			try {
				Map<String, Function<Double, Double>> currentModelPrices = newPricer.getValue(0.0, newModelFourier);

				for(int i = 0; i<currentStrikes.length;i++) {
					K = currentStrikes[i];
					targetValue = currentSmile.getOption(currentStrikes[i]).getValue();

					if(targetConvention.equals(QuotingConvention.VOLATILITYLOGNORMAL)) {
						//we convert prices into lognormal volatilities
						double forward = surface.getEquityForwardCurve().getDiscountFactor(mats[t]);
						double optionMaturity =mats[t];
						double optionStrike = currentStrikes[i];
						double payoffUnit = surface.getDiscountCurve().getDiscountFactor(mats[t]);
						double optionValue = currentModelPrices.get("valuePerStrike").apply(optionStrike);//currentModelPrices.get(currentStrikes[i]);
						value = net.finmath.functions.AnalyticFormulas.blackScholesOptionImpliedVolatility(forward, optionMaturity, optionStrike, payoffUnit, optionValue);


					}else if(targetConvention.equals(QuotingConvention.VOLATILITYNORMAL)) {
						//we convert prices into normal volatilities
						double forward = surface.getEquityForwardCurve().getDiscountFactor(mats[t]);
						double optionMaturity =mats[t];
						double optionStrike = currentStrikes[i];
						double payoffUnit = surface.getDiscountCurve().getDiscountFactor(mats[t]);
						double optionValue = currentModelPrices.get("valuePerStrike").apply(optionStrike);//currentModelPrices.get(currentStrikes[i]);
						value = net.finmath.functions.AnalyticFormulas.bachelierOptionImpliedVolatility(forward, optionMaturity, optionStrike, payoffUnit, optionValue);
					}else {
						//just output the prices
						value = currentModelPrices.get("valuePerStrike").apply(currentStrikes[i]);//currentModelPrices.get(currentStrikes[i]);
					}
					calibrationOutput.add(K+ "\t" + T + "\t" + targetValue + "\t" + value+ "\t" + Math.pow(targetValue-value,2));
				}
			} catch (CalculationException e) {
				e.printStackTrace();
			}


		}
		return calibrationOutput;
	}
277707
def _output(cls, fluents: Sequence[FluentPair]) -> Sequence[tf.Tensor]:
        ''''''
        return tuple(cls._dtype(t) for t in cls._tensors(fluents))