//------------------------------------------------------------------------- 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)); }