//-------------------------------------------------------------------------
private void assertDefinition(RatesCurveGroupDefinition defn)
{
assertEquals(defn.Name, CurveGroupName.of("Default"));
assertEquals(defn.Entries.size(), 3);
assertEquals(defn.SeasonalityDefinitions.size(), 1);
assertEquals(defn.SeasonalityDefinitions.get(CurveName.of("USD-CPI")).AdjustmentType, ShiftType.SCALED);
RatesCurveGroupEntry entry0 = findEntry(defn, "USD-Disc");
RatesCurveGroupEntry entry1 = findEntry(defn, "USD-3ML");
RatesCurveGroupEntry entry2 = findEntry(defn, "USD-CPI");
CurveDefinition defn0 = defn.findCurveDefinition(entry0.CurveName).get();
CurveDefinition defn1 = defn.findCurveDefinition(entry1.CurveName).get();
CurveDefinition defn2 = defn.findCurveDefinition(entry2.CurveName).get();
assertEquals(entry0.DiscountCurrencies, ImmutableSet.of(Currency.USD));
assertEquals(entry0.Indices, ImmutableSet.of());
assertEquals(defn0.Name, CurveName.of("USD-Disc"));
assertEquals(defn0.YValueType, ValueType.ZERO_RATE);
assertEquals(defn0.ParameterCount, 17);
assertEquals(entry1.DiscountCurrencies, ImmutableSet.of());
assertEquals(entry1.Indices, ImmutableSet.of(IborIndices.USD_LIBOR_3M));
assertEquals(defn1.Name, CurveName.of("USD-3ML"));
assertEquals(defn1.YValueType, ValueType.ZERO_RATE);
assertEquals(defn1.ParameterCount, 27);
assertEquals(entry2.DiscountCurrencies, ImmutableSet.of());
assertEquals(entry2.Indices, ImmutableSet.of(PriceIndices.US_CPI_U));
assertEquals(defn2.Name, CurveName.of("USD-CPI"));
assertEquals(defn2.YValueType, ValueType.PRICE_INDEX);
assertEquals(defn2.ParameterCount, 2);
}
//-------------------------------------------------------------------------
/// <summary>
/// Adds the definition of a discount curve to the curve group definition.
/// </summary>
/// <param name="curveDefinition"> the discount curve configuration </param>
/// <param name="otherCurrencies"> additional currencies for which the curve can provide discount factors </param>
/// <param name="currency"> the currency for which the curve provides discount rates </param>
/// <returns> this builder </returns>
public RatesCurveGroupDefinitionBuilder addDiscountCurve(CurveDefinition curveDefinition, Currency currency, params Currency[] otherCurrencies)
{
ArgChecker.notNull(curveDefinition, "curveDefinition");
ArgChecker.notNull(currency, "currency");
RatesCurveGroupEntry entry = RatesCurveGroupEntry.builder().curveName(curveDefinition.Name).discountCurrencies(ImmutableSet.copyOf(Lists.asList(currency, otherCurrencies))).build();
return(merge(entry, curveDefinition));
}
//-------------------------------------------------------------------------
/// <summary>
/// Adds the definition of a forward curve to the curve group definition.
/// </summary>
/// <param name="curveDefinition"> the definition of the forward curve </param>
/// <param name="index"> the index for which the curve provides forward rates </param>
/// <param name="otherIndices"> the additional indices for which the curve provides forward rates </param>
/// <returns> this builder </returns>
public RatesCurveGroupDefinitionBuilder addForwardCurve(CurveDefinition curveDefinition, Index index, params Index[] otherIndices)
{
ArgChecker.notNull(curveDefinition, "curveDefinition");
ArgChecker.notNull(index, "index");
RatesCurveGroupEntry entry = RatesCurveGroupEntry.builder().curveName(curveDefinition.Name).indices(indices(index, otherIndices)).build();
return(merge(entry, curveDefinition));
}
//-------------------------------------------------------------------------
/// <summary>
/// Adds the definition of a curve to the curve group definition which is used to provide
/// discount rates and forward rates.
/// </summary>
/// <param name="curveDefinition"> the definition of the forward curve </param>
/// <param name="currency"> the currency for which the curve provides discount rates </param>
/// <param name="index"> the index for which the curve provides forward rates </param>
/// <param name="otherIndices"> the additional indices for which the curve provides forward rates </param>
/// <returns> this builder </returns>
public RatesCurveGroupDefinitionBuilder addCurve(CurveDefinition curveDefinition, Currency currency, RateIndex index, params RateIndex[] otherIndices)
{
ArgChecker.notNull(curveDefinition, "curveDefinition");
ArgChecker.notNull(currency, "currency");
ArgChecker.notNull(index, "index");
RatesCurveGroupEntry entry = RatesCurveGroupEntry.builder().curveName(curveDefinition.Name).discountCurrencies(ImmutableSet.of(currency)).indices(indices(index, otherIndices)).build();
return(merge(entry, curveDefinition));
}
// one valuation date, one set of market data
private MarketDataBox <RatesCurveInputs> buildSingleCurveInputs <T1>(CurveDefinition filteredDefn, IDictionary <T1> marketData, LocalDate valuationDate, ReferenceData refData) where T1 : com.opengamma.strata.data.MarketDataId <T1>
{
// There is only a single map of values and single valuation date - create a single CurveInputs instance
CurveMetadata curveMetadata = filteredDefn.metadata(valuationDate, refData);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<? extends com.opengamma.strata.data.MarketDataId<?>, ?> singleMarketDataValues = com.opengamma.strata.collect.MapStream.of(marketData).mapValues(box -> box.getSingleValue()).toMap();
IDictionary <MarketDataId <object>, ?> singleMarketDataValues = MapStream.of(marketData).mapValues(box => box.SingleValue).toMap();
RatesCurveInputs curveInputs = RatesCurveInputs.of(singleMarketDataValues, curveMetadata);
return(MarketDataBox.ofSingleValue(curveInputs));
}
//
//
/// <summary>
/// Add a curve by definition.
/// </summary>
/// <param name="graphEngine"></param>
/// <param name="graphName"></param>
/// <param name="curveName"></param>
/// <param name="graphID"></param>
/// <param name="color"></param>
/// <param name="dashStyle"></param>
/// <param name="symbolType"></param>
/// <returns></returns>
public static void AddCurveToGraphEngine(ZGraphEngine graphEngine, string graphName, string curveName, int graphID, Color color, DashStyle dashStyle, SymbolType symbolType)
{
CurveDefinition curveDefinition = new CurveDefinition();
curveDefinition.GraphName = graphName;
curveDefinition.CurveName = curveName;
curveDefinition.GraphID = graphID;
curveDefinition.CurveColor = color;
curveDefinition.DashStyle = dashStyle;
curveDefinition.Symbol = symbolType;
graphEngine.AddDefinition(curveDefinition);
}
/// <summary>
/// Returns the inputs required for the curve if available.
/// <para>
/// If no market data is required to build the curve an empty set of inputs is returned.
/// If the curve requires inputs which are available in {@code marketData} they are returned.
/// If the curve requires inputs which are not available in {@code marketData} an exception is thrown
///
/// </para>
/// </summary>
/// <param name="curveDefn"> the curve definition </param>
/// <param name="marketData"> the market data </param>
/// <param name="groupName"> the name of the curve group being built </param>
/// <param name="obsSource"> the source of the observable market data </param>
/// <returns> the input data required for the curve if available </returns>
private MarketDataBox <RatesCurveInputs> curveInputs(CurveDefinition curveDefn, ScenarioMarketData marketData, CurveGroupName groupName, ObservableSource obsSource)
{
// only try to get inputs from the market data if the curve needs market data
if (requiresMarketData(curveDefn))
{
RatesCurveInputsId curveInputsId = RatesCurveInputsId.of(groupName, curveDefn.Name, obsSource);
return(marketData.getValue(curveInputsId));
}
else
{
return(MarketDataBox.ofSingleValue(RatesCurveInputs.builder().build()));
}
}
public MarketDataRequirements requirements(RatesCurveInputsId id, MarketDataConfig marketDataConfig)
{
RatesCurveGroupDefinition groupConfig = marketDataConfig.get(typeof(RatesCurveGroupDefinition), id.CurveGroupName);
Optional <CurveDefinition> optionalDefinition = groupConfig.findCurveDefinition(id.CurveName);
if (!optionalDefinition.Present)
{
return(MarketDataRequirements.empty());
}
CurveDefinition definition = optionalDefinition.get();
return(MarketDataRequirements.builder().addValues(nodeRequirements(ImmutableList.of(definition))).build());
}
/// <summary>
/// Add a curve by definition.
/// </summary>
/// <param name="graphEngine"></param>
/// <param name="graphName"></param>
/// <param name="curveName"></param>
/// <param name="graphID"></param>
/// <param name="color"></param>
/// <param name="isLineVisible"></param>
/// <param name="symbolType"></param>
/// <param name="symbolFillColor"></param>
/// <returns></returns>
public static void AddCurveToGraphEngine(ZGraphEngine graphEngine, string graphName, string curveName, int graphID, Color color, bool isLineVisible, SymbolType symbolType, Color symbolFillColor)
{
CurveDefinition curveDefinition = new CurveDefinition();
curveDefinition.GraphName = graphName;
curveDefinition.CurveName = curveName;
curveDefinition.GraphID = graphID;
curveDefinition.CurveColor = color;
curveDefinition.IsLineVisible = isLineVisible;
curveDefinition.Symbol = symbolType;
curveDefinition.SymbolFillColor = symbolFillColor;
graphEngine.AddDefinition(curveDefinition);
}
// build the map of additional info
private CurveMetadata childMetadata(CurveMetadata metadata, CurveDefinition curveDefn, IDictionary <CurveName, JacobianCalibrationMatrix> jacobians, IDictionary <CurveName, DoubleArray> sensitivitiesMarketQuote)
{
JacobianCalibrationMatrix jacobian = jacobians[curveDefn.Name];
CurveMetadata metadataResult = metadata;
if (jacobian != null)
{
metadataResult = metadata.withInfo(CurveInfoType.JACOBIAN, jacobian);
}
DoubleArray sensitivity = sensitivitiesMarketQuote[curveDefn.Name];
if (sensitivity != null)
{
metadataResult = metadataResult.withInfo(CurveInfoType.PV_SENSITIVITY_TO_MARKET_QUOTE, sensitivity);
}
return(metadataResult);
}
public MarketDataBox <RatesCurveInputs> build(RatesCurveInputsId id, MarketDataConfig marketDataConfig, ScenarioMarketData marketData, ReferenceData refData)
{
CurveGroupName groupName = id.CurveGroupName;
CurveName curveName = id.CurveName;
RatesCurveGroupDefinition groupDefn = marketDataConfig.get(typeof(RatesCurveGroupDefinition), groupName);
Optional <CurveDefinition> optionalDefinition = groupDefn.findCurveDefinition(id.CurveName);
if (!optionalDefinition.Present)
{
throw new System.ArgumentException(Messages.format("No curve named '{}' found in group '{}'", curveName, groupName));
}
CurveDefinition configuredDefn = optionalDefinition.get();
// determine market data needs
MarketDataBox <LocalDate> valuationDates = marketData.ValuationDate;
bool multipleValuationDates = valuationDates.ScenarioValue;
// curve definition can vary for each valuation date
if (multipleValuationDates)
{
IList <CurveDefinition> curveDefns = IntStream.range(0, valuationDates.ScenarioCount).mapToObj(valuationDates.getValue).map((LocalDate valDate) => configuredDefn.filtered(valDate, refData)).collect(toImmutableList());
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Set<com.opengamma.strata.data.MarketDataId<?>> requirements = nodeRequirements(curveDefns);
ISet <MarketDataId <object> > requirements = nodeRequirements(curveDefns);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, com.opengamma.strata.data.scenario.MarketDataBox<?>> marketDataValues = requirements.stream().collect(toImmutableMap(k -> k, k -> marketData.getValue(k)));
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IDictionary <MarketDataId <object>, MarketDataBox <object> > marketDataValues = requirements.collect(toImmutableMap(k => k, k => marketData.getValue(k)));
return(buildMultipleCurveInputs(MarketDataBox.ofScenarioValues(curveDefns), marketDataValues, valuationDates, refData));
}
// only one valuation date
LocalDate valuationDate = valuationDates.getValue(0);
CurveDefinition filteredDefn = configuredDefn.filtered(valuationDate, refData);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Set<com.opengamma.strata.data.MarketDataId<?>> requirements = nodeRequirements(com.google.common.collect.ImmutableList.of(filteredDefn));
ISet <MarketDataId <object> > requirements = nodeRequirements(ImmutableList.of(filteredDefn));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, com.opengamma.strata.data.scenario.MarketDataBox<?>> marketDataValues = requirements.stream().collect(toImmutableMap(k -> k, k -> marketData.getValue(k)));
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IDictionary <MarketDataId <object>, MarketDataBox <object> > marketDataValues = requirements.collect(toImmutableMap(k => k, k => marketData.getValue(k)));
// Do any of the inputs contain values for multiple scenarios, or do they contain 1 value each?
bool multipleInputValues = marketDataValues.Values.Any(MarketDataBox.isScenarioValue);
return(multipleInputValues || multipleValuationDates?buildMultipleCurveInputs(MarketDataBox.ofSingleValue(filteredDefn), marketDataValues, valuationDates, refData) : buildSingleCurveInputs(filteredDefn, marketDataValues, valuationDate, refData));
}
//-------------------------------------------------------------------------
public ImmutableRatesProvider generate(DoubleArray parameters, IDictionary <CurveName, JacobianCalibrationMatrix> jacobians, IDictionary <CurveName, DoubleArray> sensitivitiesMarketQuote)
{
// collect curves for child provider based on existing provider
IDictionary <Currency, Curve> discountCurves = new Dictionary <Currency, Curve>();
IDictionary <Index, Curve> indexCurves = new Dictionary <Index, Curve>();
//JAVA TO C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'putAll' method:
discountCurves.putAll(knownProvider.DiscountCurves);
//JAVA TO C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'putAll' method:
indexCurves.putAll(knownProvider.IndexCurves);
// generate curves from combined parameter array
int startIndex = 0;
for (int i = 0; i < curveDefinitions.size(); i++)
{
CurveDefinition curveDefn = curveDefinitions.get(i);
CurveMetadata metadata = curveMetadata.get(i);
CurveName name = curveDefn.Name;
// extract parameters for the child curve
int paramCount = curveDefn.ParameterCount;
DoubleArray curveParams = parameters.subArray(startIndex, startIndex + paramCount);
startIndex += paramCount;
// create the child curve
CurveMetadata childMetadata = this.childMetadata(metadata, curveDefn, jacobians, sensitivitiesMarketQuote);
Curve curve = curveDefn.curve(knownProvider.ValuationDate, childMetadata, curveParams);
// put child curve into maps
ISet <Currency> currencies = discountCurveNames.get(name);
foreach (Currency currency in currencies)
{
discountCurves[currency] = curve;
}
ISet <Index> indices = forwardCurveNames.get(name);
foreach (Index index in indices)
{
indexCurves[index] = curve;
}
}
return(knownProvider.toBuilder().discountCurves(discountCurves).indexCurves(indexCurves).build());
}
IEnumerator Run_Coroutine(CurveDefinition curveDefinition)
{
// !BENKLUGE! This gives the instantiations a chance to place the object being driven before
// we start moving it, and let's us get a valid mStartPosition.
yield return null;
mStartPosition = transform.position;
mCurrentTime = -Time.deltaTime;
mDuration = curveDefinition.duration;
float xScale = curveDefinition.xScale.GetRandom();
float yScale = curveDefinition.yScale.GetRandom();
float zScale = curveDefinition.zScale.GetRandom();
while(mCurrentTime <= mDuration || _loop)
{
mCurrentTime += Time.deltaTime;
float pct = Mathf.Clamp01(mCurrentTime / curveDefinition.duration);
if(!_isPositionLocal)
{
target.SetLocalX(curveDefinition.xValue.Evaluate(pct) * xScale);
target.SetLocalY(curveDefinition.yValue.Evaluate(pct) * yScale);
target.SetLocalZ(curveDefinition.zValue.Evaluate(pct) * zScale);
}
else
{
target.SetX(mStartPosition.x + curveDefinition.xValue.Evaluate(pct) * xScale);
target.SetY(mStartPosition.y + curveDefinition.yValue.Evaluate(pct) * yScale);
target.SetZ(mStartPosition.z + curveDefinition.zValue.Evaluate(pct) * zScale);
}
yield return null;
}
if(mOnComplete == OnCompleteAction.Destroy)
Destroy(gameObject);
else
enabled = false;
}
// one valuation date, scenario market data
private MarketDataBox <RatesCurveInputs> buildMultipleCurveInputs <T1>(MarketDataBox <CurveDefinition> filteredDefns, IDictionary <T1> marketData, MarketDataBox <LocalDate> valuationDates, ReferenceData refData) where T1 : com.opengamma.strata.data.MarketDataId <T1>
{
// If there are multiple values for any of the input data values or for the valuation
// dates then we need to create multiple sets of inputs
int scenarioCount = RatesCurveInputsMarketDataFunction.scenarioCount(valuationDates, marketData);
ImmutableList.Builder <CurveMetadata> curveMetadataBuilder = ImmutableList.builder();
for (int i = 0; i < scenarioCount; i++)
{
LocalDate valDate = valuationDates.getValue(i);
CurveDefinition defn = filteredDefns.getValue(i);
curveMetadataBuilder.add(defn.metadata(valDate, refData));
}
IList <CurveMetadata> curveMetadata = curveMetadataBuilder.build();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<java.util.Map<? extends com.opengamma.strata.data.MarketDataId<?>, ?>> scenarioValues = java.util.stream.IntStream.range(0, scenarioCount).mapToObj(i -> buildScenarioValues(marketData, i)).collect(toImmutableList());
IList <IDictionary <MarketDataId <object>, ?> > scenarioValues = IntStream.range(0, scenarioCount).mapToObj(i => buildScenarioValues(marketData, i)).collect(toImmutableList());
IList <RatesCurveInputs> curveInputs = zip(scenarioValues.stream(), curveMetadata.stream()).map(pair => RatesCurveInputs.of(pair.First, pair.Second)).collect(toImmutableList());
return(MarketDataBox.ofScenarioValues(curveInputs));
}
//
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer); // call QuoteEngine base class
if (ParentStrategy != null)
{
m_GraphEngine = ParentStrategy.m_GraphEngine;
}
#region Initialize Graph
if (m_IsGraphEnabled && m_GraphEngine != null)
{
string[] strArray = this.m_EngineName.Split(':');
string graphName = strArray[strArray.Length - 1];
int graphID = 0;
foreach (CurveDefinition c in m_GraphEngine.CurveDefinitions.CurveDefinitions)
{
if (graphID <= c.GraphID)
{
graphID = c.GraphID + 1;
} // use next available ID#.
}
m_GraphID = graphID;
CurveDefinition cdef;
/*
* cdef = new CurveDefinition();
* cdef.GraphName = string.Format("{0}", graphName);
* cdef.CurveName = "Price";
* cdef.GraphID = graphID;
* cdef.CurveColor = Color.Black;
* cdef.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
* cdef.Symbol = ZedGraph.SymbolType.None;
* m_GraphEngine.AddDefinition(cdef);
*/
cdef = new CurveDefinition();
cdef.GraphName = string.Format("{0}", graphName);
cdef.CurveName = "Bid";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Gray;
cdef.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
cdef.Symbol = ZedGraph.SymbolType.None;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.GraphName = string.Format("{0}", graphName);
cdef.CurveName = "Ask";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Gray;
cdef.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
cdef.Symbol = ZedGraph.SymbolType.None;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.CurveName = UV.Lib.Utilities.QTMath.MktSideToLongString(0);
cdef.GraphID = graphID;
cdef.CurveColor = Color.Blue;
cdef.CurveWidth = 2.0F;
cdef.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
cdef.Symbol = ZedGraph.SymbolType.None;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.CurveName = UV.Lib.Utilities.QTMath.MktSideToLongString(1);
cdef.GraphID = graphID;
cdef.CurveColor = Color.Red;
cdef.CurveWidth = 2.0F;
cdef.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
cdef.Symbol = ZedGraph.SymbolType.None;
m_GraphEngine.AddDefinition(cdef);
//
// Position indicators
//
cdef = new CurveDefinition();
cdef.CurveName = "Long Entry";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Blue;
cdef.IsLineVisible = false;
cdef.Symbol = ZedGraph.SymbolType.Triangle;
cdef.SymbolFillColor = Color.Blue;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.CurveName = "Long Exit";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Blue;
cdef.IsLineVisible = false;
cdef.Symbol = ZedGraph.SymbolType.TriangleDown;
cdef.SymbolFillColor = Color.White;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.CurveName = "Short Entry";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Red;
cdef.IsLineVisible = false;
cdef.Symbol = ZedGraph.SymbolType.TriangleDown;
cdef.SymbolFillColor = Color.Red;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.CurveName = "Short Exit";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Red;
cdef.IsLineVisible = false;
cdef.Symbol = ZedGraph.SymbolType.Triangle;
cdef.SymbolFillColor = Color.White;
m_GraphEngine.AddDefinition(cdef);
//
// Stops
//
cdef = new CurveDefinition();
cdef.CurveName = "Stop Price";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Green;
cdef.IsLineVisible = false;
cdef.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
cdef.Symbol = ZedGraph.SymbolType.HDash;
m_GraphEngine.AddDefinition(cdef);
}
else
{
m_IsGraphEnabled = false;
}
#endregion // graph initialization.
}
//
#endregion//Properties
#region Public Methods
// *************************************************
// **** Public Methods ****
// *************************************************
//
//
//
// *************************************************
// **** Add Definition() ****
// *************************************************
public void AddDefinition(CurveDefinition cdef)
{
m_CurveDefintions.CurveDefinitions.Add(cdef);
}
//
//
private void SetupGraph()
{
#region Initialize Graph
if (m_GraphEngine != null)
{
string[] strArray = this.m_EngineName.Split(':');
string graphName = strArray[strArray.Length - 1];
//
// Plot #1
//
// Can we ask graphEngine for a new graphId and give it the name etc, then?
int graphID = 0;
foreach (CurveDefinition c in m_GraphEngine.CurveDefinitions.CurveDefinitions)
{
if (graphID <= c.GraphID)
{
graphID = c.GraphID + 1;
} // use next available ID#.
}
m_GraphID = graphID;
CurveDefinition cdef = new CurveDefinition();
cdef.CurveName = "Price";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Black;
cdef.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
cdef.Symbol = ZedGraph.SymbolType.None;
m_GraphEngine.AddDefinition(cdef);
cdef.GraphName = string.Format("{0} #{1}", graphName, this.m_EngineID.ToString());
cdef = new CurveDefinition();
cdef.CurveName = UV.Lib.Utilities.QTMath.MktSideToLongString(0);
cdef.GraphID = graphID;
cdef.CurveColor = Color.Blue;
cdef.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
cdef.Symbol = ZedGraph.SymbolType.None;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.CurveName = UV.Lib.Utilities.QTMath.MktSideToLongString(1);
cdef.GraphID = graphID;
cdef.CurveColor = Color.Red;
cdef.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
cdef.Symbol = ZedGraph.SymbolType.None;
m_GraphEngine.AddDefinition(cdef);
//
// Position indicators
//
cdef = new CurveDefinition();
cdef.CurveName = "Long Entry";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Blue;
cdef.IsLineVisible = false;
cdef.Symbol = ZedGraph.SymbolType.Triangle;
cdef.SymbolFillColor = Color.Blue;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.CurveName = "Long Exit";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Blue;
cdef.IsLineVisible = false;
cdef.Symbol = ZedGraph.SymbolType.TriangleDown;
cdef.SymbolFillColor = Color.White;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.CurveName = "Short Entry";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Red;
cdef.IsLineVisible = false;
cdef.Symbol = ZedGraph.SymbolType.TriangleDown;
cdef.SymbolFillColor = Color.Red;
m_GraphEngine.AddDefinition(cdef);
cdef = new CurveDefinition();
cdef.CurveName = "Short Exit";
cdef.GraphID = graphID;
cdef.CurveColor = Color.Red;
cdef.IsLineVisible = false;
cdef.Symbol = ZedGraph.SymbolType.Triangle;
cdef.SymbolFillColor = Color.White;
m_GraphEngine.AddDefinition(cdef);
}
#endregion // graph initialization.
}// SetupGraph
//-------------------------------------------------------------------------
// merges the definition and entry
private RatesCurveGroupDefinitionBuilder merge(RatesCurveGroupEntry newEntry, CurveDefinition curveDefinition)
{
curveDefinitions[curveDefinition.Name] = curveDefinition;
return(mergeEntry(newEntry));
}
/// <summary>
/// Checks if the curve configuration requires market data.
/// <para>
/// If the curve configuration contains all the data required to build the curve it is not necessary to
/// request input data for the curve points. However if market data is required for any point on the
/// curve this function must add <seealso cref="RatesCurveInputs"/> to its market data requirements.
///
/// </para>
/// </summary>
/// <param name="curveDefn"> the curve definition </param>
/// <returns> true if the curve requires market data for calibration </returns>
private bool requiresMarketData(CurveDefinition curveDefn)
{
return(curveDefn.Nodes.Any(node => !node.requirements().Empty));
}
