/* (non-Javadoc)
@see net.finmath.fouriermethod.products.FourierTransformProduct#getValue(double, net.finmath.modelling.Model)
772227
@Override
	public Double getValue(double evaluationTime, Model model) {
		Double value = null;
		try {
			value = getValue((CharacteristicFunctionModel) model);
		} catch (CalculationException e) {
		}

		return value;
	}
1098780
@Override
    public synchronized Object getValue() {
        if (id != null) {
            if (serializedValue != null) {
                long oldSize = -1;
                if (cacheEntryPool != null) {
                    if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
                        oldSize = getObjectSize();
                    }
                }

                try {
                    value = SerializationUtility.deserialize(serializedValue, cacheName);
                } catch (Exception ex) {
                    com.ibm.ws.ffdc.FFDCFilter.processException(ex, "com.ibm.ws.cache.CacheEntry.getValue", "200", this);
                }
                if (value != null) {
                    serializedValue = null;
                    if (cacheEntryPool != null) {
                        if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
                            long newSize = getObjectSize();
                            if (oldSize != -1 && newSize != -1) {
                                cacheEntryPool.cache.increaseCacheSizeInBytes(newSize - oldSize, "GET_VALUE");
                            } else {
                                cacheEntryPool.cache.disableCacheSizeInMB();
                            }
                        }
                    }
                }
            }
        }
        return value;
    }
260498
@Override
	public Map<String, Object> getValues(double evaluationTime, Model model) {
		Map<String, Object> results;
		if(model instanceof MonteCarloSimulationModel) {
			try {
				results = getValues(evaluationTime, (MonteCarloSimulationModel)model);
			} catch (CalculationException e) {
				results = new HashMap<>();
				results.put("exception", e);
			}
		}
		else {
			Exception e = new IllegalArgumentException("The product " + this.getClass()
			+ " cannot be valued against a model " + model.getClass() + "."
			+ "It requires a model of type " + MonteCarloSimulationModel.class + ".");
			results = new HashMap<>();
			results.put("exception", e);
		}

		return results;
	}
1138606
@Override
	public Number getValue(ValueDimension dim, int index) {
		return values.get(dim).get(index);
	}
304786
public double getNumericValue(Part part) {
        Part.Type type=part.type;
        if(type==Part.Type.ARG_INT) {
            return part.value;
        } else if(type==Part.Type.ARG_DOUBLE) {
            return numericValues.get(part.value);
        } else {
            return NO_NUMERIC_VALUE;
        }
    }
1098735
public Double getColumnValueAsDouble(final int col, final double defaultValue) {
		Double value = getColumnValueAsDouble(col);
		if (value == null) {
			value = defaultValue;
		}
		return value;
	}
1315838
public org.tensorflow.framework.Summary.ValueOrBuilder getValueOrBuilder(
      int index) {
    return value_.get(index);
  }
828608
@Override
	public RandomVariableInterface getValue(double evaluationTime, LIBORModelMonteCarloSimulationInterface model) throws CalculationException {

		if(inceptionTime > evaluationTime) {
			return new RandomVariable(0.0);
		}
		if(accrualPeriod <= 0) {
			return new RandomVariable(Double.MAX_VALUE);
		}

		// Initialize the value of the account to 1.0
		RandomVariableInterface value = new RandomVariable(initialValue);

		// Loop over accrual periods
		for(double time=inceptionTime; time<evaluationTime; time += accrualPeriod) {
			// Get the forward fixed at the beginning of the period
			RandomVariableInterface	forwardRate				= model.getLIBOR(time, time, time+accrualPeriod);
			double					currentAccrualPeriod	= Math.min(accrualPeriod , evaluationTime-time);

			// Accrue the value using the current forward rate
			value = value.accrue(forwardRate, currentAccrualPeriod);
		}

		return value;
	}
287520
public float getValue() {
    if (VariableAssignment_Type.featOkTst && ((VariableAssignment_Type)jcasType).casFeat_value == null)
      jcasType.jcas.throwFeatMissing("value", "ch.epfl.bbp.uima.types.VariableAssignment");
    return jcasType.ll_cas.ll_getFloatValue(addr, ((VariableAssignment_Type)jcasType).casFeatCode_value);}
681954
private float getValue(int propertyConstant) {
        //final View.TransformationInfo info = mView.mTransformationInfo;
        View v = mView.get();
        if (v != null) {
            switch (propertyConstant) {
                case TRANSLATION_X:
                    //return info.mTranslationX;
                    return v.getTranslationX();
                case TRANSLATION_Y:
                    //return info.mTranslationY;
                    return v.getTranslationY();
                case ROTATION:
                    //return info.mRotation;
                    return v.getRotation();
                case ROTATION_X:
                    //return info.mRotationX;
                    return v.getRotationX();
                case ROTATION_Y:
                    //return info.mRotationY;
                    return v.getRotationY();
                case SCALE_X:
                    //return info.mScaleX;
                    return v.getScaleX();
                case SCALE_Y:
                    //return info.mScaleY;
                    return v.getScaleY();
                case X:
                    //return v.mLeft + info.mTranslationX;
                    return v.getX();
                case Y:
                    //return v.mTop + info.mTranslationY;
                    return v.getY();
                case ALPHA:
                    //return info.mAlpha;
                    return v.getAlpha();
            }
        }
        return 0;
    }
177456
public org.tensorflow.framework.Summary.Value getValue(int index) {
    return value_.get(index);
  }
147411
@Override
    public double getValue(IntDoubleVector params) {
        double sum = params.dot(params);
        sum *= 1./2. * lambda;
        return - sum;
    }
493131
public String getValue() {
    if (MMAXAttribute_Type.featOkTst && ((MMAXAttribute_Type)jcasType).casFeat_value == null)
      jcasType.jcas.throwFeatMissing("value", "de.julielab.jules.types.mmax.MMAXAttribute");
    return jcasType.ll_cas.ll_getStringValue(addr, ((MMAXAttribute_Type)jcasType).casFeatCode_value);}
167770
@Override
    public double getDoubleValue( final String       key,
                                  final double       defaultValue )
    {
        return formatDoubleValue( key, getFormattedPropValue( key ), defaultValue );
    }
311598
public Object getValue(String k) {
	if (values == null) {
	    return null;
	} else {
	    return values.get(k);
	}
    }
826045
@Override
    public double getValue(int idx) {
        int vSize = MVecArray.count(varBeliefs);
        if (idx < vSize) {
            return MVecArray.getValue(idx, varBeliefs);
        } else {
            return MVecArray.getValue(idx - vSize, facBeliefs);
        }
    }
297937
@Override
    public Object getValue(ELContext context) throws PropertyNotFoundException,
            ELException {
        EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
                this.varMapper);
        context.notifyBeforeEvaluation(getExpressionString());
        Object value = this.getNode().getValue(ctx);
        if (this.expectedType != null) {
            value = context.convertToType(value, this.expectedType);
        }
        context.notifyAfterEvaluation(getExpressionString());
        return value;
    }