public static List<IComponentOld> DeserializeComponents(string data, ReferenceData[] references)
        {
            var components = DeserializeComponents(data);
            InjectReferences(components, references);

            return components;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var jo = serializer.Deserialize<JObject>(reader);

            var refData = new ReferenceData();

            foreach (var e in jo.Properties())
            {
                var prop = objectType.GetProperties().Where(x => x.GetCustomAttributes(typeof(JsonPropertyAttribute), false).FirstOrDefault() != null)
                                                    .Select(x =>
                                                    {
                                                        var jsonAttribute = (JsonPropertyAttribute)x.GetCustomAttributes(typeof(JsonPropertyAttribute), false).FirstOrDefault();
                                                        return new { Property = x, JsonName = jsonAttribute.PropertyName };
                                                    }).FirstOrDefault(x => x.JsonName == e.Name);

                if (prop != null)
                {
                    prop.Property.SetValue(refData, e.Value.ToString());
                }
                else
                {
                    if (refData.KeyValues == null)
                    {
                        refData.KeyValues = new List<KeyValuePair<string, string>>();
                    }
                    refData.KeyValues.Add(new KeyValuePair<string, string>(e.Name, e.Value.ToString()));
                }

            }

            return refData;
        }
        /// <summary>
        /// Gets the reference data list asynchronous.
        /// </summary>
        /// <returns>reference data as a task</returns>
        public async Task<ReferenceData> ListAsync()
        {
            var referenceData = new ReferenceData();
            var countries = this.referenceDataRepository.RetrieveCountryListAsync(null, null);
            var states = this.referenceDataRepository.RetrieveStateListAsync();
            var ports = this.referenceDataRepository.RetrievePortListAsync();
            var brands = this.referenceDataRepository.RetrieveBrandListAsync();
            var personTypes = this.referenceDataRepository.RetrievePersonTypeListAsync();
            var loyaltyLevelTypes = this.referenceDataRepository.RetrieveLoyaltyLevelTypeListAsync();
            var documentTypes = this.referenceDataRepository.RetrieveDocumentTypeListAsync();
            await Task.WhenAll(countries, states, ports, brands, personTypes, loyaltyLevelTypes, documentTypes);

            await MapBrandPortIds(brands.Result);

            referenceData.AssignCountries(countries.Result.Items);
            referenceData.AssignStates(states.Result.Items);
            referenceData.AssignPorts(ports.Result.Items);
            referenceData.AssignBrands(brands.Result.Items);
            referenceData.AssignPersonTypes(personTypes.Result.Items);
            referenceData.AssignLoyaltyLevelTypes(loyaltyLevelTypes.Result.Items);
            referenceData.AssignDocumentTypes(documentTypes.Result.Items);

            return referenceData;
        }
Exemple #4
0
        public virtual void calculateMultiScenarioAsync <T1>(CalculationRules calculationRules, IList <T1> targets, IList <Column> columns, ScenarioMarketData marketData, ReferenceData refData, CalculationListener listener) where T1 : com.opengamma.strata.basics.CalculationTarget
        {
            CalculationTasks tasks = CalculationTasks.of(calculationRules, targets, columns, refData);

            taskRunner.calculateMultiScenarioAsync(tasks, marketData, refData, listener);
        }
Exemple #5
0
        private static double TestPointCR(ReferenceData referenceData, TestDataCollection testDataCollection, string testType, string temp, int port, string pSetting)
        {
            var pointTestData = testDataCollection.GetTestData(testType, "Point", "PointPDL");

            if (pointTestData == null)
            {
                throw new MeasuringException("没有计算CR所需测试数据");
            }

            /*
             * var wl = pSetting.CastTo(double.MinValue);
             * if (wl == double.MinValue)
             *  throw new MeasuringException("波长设置错误");
             *
             * var item = pointTestData.GetDataItem(temp, port, wl);
             * if (item == null)
             * {
             *  throw new MeasuringException("没有计算CR所需测试数据");
             * }
             * var refpower = referenceData.GetReference(1, port, wl);
             * var power = item.Power + Windows.IniProfile<BusinessLogic.Setting.SystemSetting>.Instance.Profile.ExtraLosssCompensation;
             * var cr = MeasuringManager.Convert_dBm2mW(power - refpower.Power);
             * cr = Math.Round(cr * 100D, 2);
             */

            var wl = pSetting.CastTo(double.MaxValue);

            if (wl == double.MinValue)
            {
                throw new MeasuringException("波长设置错误");
            }

            var testData = pointTestData.GetTestData();

            if (!testData.ContainsKey(temp))
            {
                throw new MeasuringException("没有计算CL所需测试数据");
            }
            var data     = testData[temp];
            var inPower  = 0D;
            var allPower = 0D;

            var setting = TestPortSetting.Get(port);

            foreach (var item in data)
            {
                var ch = item.Key;
                if (ch < 1 || !item.Value.ContainsKey(wl))
                {
                    continue;
                }

                var chSetting = TestPortSetting.Get(ch);
                if (chSetting.DataID != setting.DataID)
                {
                    continue;
                }

                var testItem = item.Value[wl];
                if (testItem.Power == double.MinValue)
                {
                    continue;
                }

                var power = MeasuringManager.Convert_dBm2mW(testItem.IL);
                if (port == ch)
                {
                    inPower = power;
                }

                allPower += power;
            }
            var cr = allPower == 0D ? 0D : inPower / allPower;

            cr = Math.Round(cr * 100D, 2);
            return(cr);
        }
Exemple #6
0
        public ContentWindowReferenceData(ReferenceData refData)
        {
            InitializeComponent();

            myDataGrid.ItemsSource = refData.ReferenceDataEntrys;
        }
Exemple #7
0
 public ResolvedTermDepositTrade resolvedTrade(double quantity, MarketData marketData, ReferenceData refData)
 {
     return(trade(quantity, marketData, refData).resolve(refData));
 }
        /// <summary>
        /// Tests setup for methods and data
        /// </summary>
        protected override void OnSetup()
        {
            mockLoggingHelper = CreateMock <ILoggingHelper>();

            // Data Setup
            userUnitInfoDataDTOList = new List <UserUnitInfoDataDTO>()
            {
                new UserUnitInfoDataDTO()
                {
                    UserName   = "******",
                    LocationId = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A")
                },

                new UserUnitInfoDataDTO()
                {
                    UserName   = "******",
                    LocationId = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A")
                }
            };

            List <AccessFunction> accessFunctionList = new List <AccessFunction>()
            {
                new AccessFunction()
                {
                    RoleName     = "manager",
                    LocationID   = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
                    UserName     = "******",
                    FunctionName = "PrintMap",
                    ActionName   = "Print",
                    UserId       = new Guid("5B9C7207-3D20-E711-9F8C-28D244AEF9ED"),
                },

                new AccessFunction()
                {
                    RoleName     = "collection hub",
                    LocationID   = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
                    UserName     = "******",
                    FunctionName = "accesslink",
                    ActionName   = "create",
                    UserId       = new Guid("5B9C7207-3D20-E711-9F8C-28D244AEF9ED"),
                },

                new AccessFunction()
                {
                    RoleName     = "delivery unit",
                    LocationID   = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
                    UserName     = "******",
                    FunctionName = "delivery point",
                    ActionName   = "create",
                    UserId       = new Guid("6B9C7207-3D20-E711-9F8C-28D244AEF9ED"),
                }
            };

            UserRoleLocation userRoleLocation = new UserRoleLocation()
            {
                LocationID = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
                UserID     = new Guid("5B9C7207-3D20-E711-9F8C-28D244AEF9ED")
            };

            User user = new User()
            {
                ID       = new Guid("5B9C7207-3D20-E711-9F8C-28D244AEF9ED"),
                UserName = "******"
            };

            LocationReferenceData locationReferenceData = new LocationReferenceData()
            {
                ReferenceDataID = new Guid("AFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
                LocationID      = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A")
            };

            ReferenceData referenceData = new ReferenceData()
            {
                ID = new Guid("AFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
                ReferenceDataValue = "Type1"
            };

            PostalAddressIdentifier postalAddressIdentifier = new PostalAddressIdentifier()
            {
                ID = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
                IdentifierTypeGUID = new Guid("AFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
                Name = "Unit1"
            };

            //Setup for UserRoleLocation
            mockRMDBContext = CreateMock <ActionDBContext>();
            var mockAsynEnumerable1 = new DbAsyncEnumerable <UserRoleLocation>(new List <UserRoleLocation>()
            {
                userRoleLocation
            });
            var mockUserRoleLocation = MockDbSet(new List <UserRoleLocation>()
            {
                userRoleLocation
            });

            mockUserRoleLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
            mockUserRoleLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
            mockUserRoleLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
            mockUserRoleLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <UserRoleLocation>)mockAsynEnumerable1).GetAsyncEnumerator());

            mockUserRoleLocation.Setup(x => x.AsNoTracking()).Returns(mockUserRoleLocation.Object);

            mockRMDBContext.Setup(x => x.Set <UserRoleLocation>()).Returns(mockUserRoleLocation.Object);
            mockRMDBContext.Setup(x => x.UserRoleLocations).Returns(mockUserRoleLocation.Object);
            mockUserRoleLocation.Setup(x => x.Include(It.IsAny <string>())).Returns(mockUserRoleLocation.Object);

            //Setup for User
            var mockAsynEnumerable2 = new DbAsyncEnumerable <User>(new List <User>()
            {
                user
            });
            var mockUser = MockDbSet(new List <User>()
            {
                user
            });

            mockUser.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
            mockUser.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
            mockUser.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
            mockUser.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <User>)mockAsynEnumerable2).GetAsyncEnumerator());

            mockRMDBContext.Setup(x => x.Set <User>()).Returns(mockUser.Object);
            mockRMDBContext.Setup(x => x.Users).Returns(mockUser.Object);
            mockUser.Setup(x => x.Include(It.IsAny <string>())).Returns(mockUser.Object);

            //Setup for LocationReferenceData
            var mockAsynEnumerable3 = new DbAsyncEnumerable <LocationReferenceData>(new List <LocationReferenceData>()
            {
                locationReferenceData
            });
            var mockLocationReferenceData = MockDbSet(new List <LocationReferenceData>()
            {
                locationReferenceData
            });

            mockLocationReferenceData.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable3.AsQueryable().Provider);
            mockLocationReferenceData.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable3.AsQueryable().Expression);
            mockLocationReferenceData.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable3.AsQueryable().ElementType);
            mockLocationReferenceData.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <LocationReferenceData>)mockAsynEnumerable3).GetAsyncEnumerator());

            mockRMDBContext.Setup(x => x.Set <LocationReferenceData>()).Returns(mockLocationReferenceData.Object);
            mockRMDBContext.Setup(x => x.LocationReferenceDatas).Returns(mockLocationReferenceData.Object);
            mockLocationReferenceData.Setup(x => x.Include(It.IsAny <string>())).Returns(mockLocationReferenceData.Object);

            //Setup for LocationReferenceData
            var mockAsynEnumerable4 = new DbAsyncEnumerable <ReferenceData>(new List <ReferenceData>()
            {
                referenceData
            });
            var mockReferenceData = MockDbSet(new List <ReferenceData>()
            {
                referenceData
            });

            mockReferenceData.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable4.AsQueryable().Provider);
            mockReferenceData.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable4.AsQueryable().Expression);
            mockReferenceData.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable4.AsQueryable().ElementType);
            mockReferenceData.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <ReferenceData>)mockAsynEnumerable4).GetAsyncEnumerator());

            mockRMDBContext.Setup(x => x.Set <ReferenceData>()).Returns(mockReferenceData.Object);
            mockRMDBContext.Setup(x => x.ReferenceDatas).Returns(mockReferenceData.Object);
            mockReferenceData.Setup(x => x.Include(It.IsAny <string>())).Returns(mockReferenceData.Object);

            //Setup for PostalAddressIdentifier
            var mockAsynEnumerable5 = new DbAsyncEnumerable <PostalAddressIdentifier>(new List <PostalAddressIdentifier>()
            {
                postalAddressIdentifier
            });
            var mockPostalAddressIdentifier = MockDbSet(new List <PostalAddressIdentifier>()
            {
                postalAddressIdentifier
            });

            mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable5.AsQueryable().Provider);
            mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable5.AsQueryable().Expression);
            mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable5.AsQueryable().ElementType);
            mockPostalAddressIdentifier.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddressIdentifier>)mockAsynEnumerable5).GetAsyncEnumerator());

            mockRMDBContext.Setup(x => x.Set <PostalAddressIdentifier>()).Returns(mockPostalAddressIdentifier.Object);
            mockRMDBContext.Setup(x => x.PostalAddressIdentifiers).Returns(mockPostalAddressIdentifier.Object);
            mockPostalAddressIdentifier.Setup(x => x.Include(It.IsAny <string>())).Returns(mockPostalAddressIdentifier.Object);

            //Setup for AccessFunction
            var mockAsynEnumerable6 = new DbAsyncEnumerable <AccessFunction>(accessFunctionList);
            var mockAccessFunction  = MockDbSet(accessFunctionList);

            mockAccessFunction.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable6.AsQueryable().Provider);
            mockAccessFunction.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable6.AsQueryable().Expression);
            mockAccessFunction.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable6.AsQueryable().ElementType);
            mockAccessFunction.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <AccessFunction>)mockAsynEnumerable6).GetAsyncEnumerator());

            mockAccessFunction.Setup(x => x.AsNoTracking()).Returns(mockAccessFunction.Object);

            mockRMDBContext.Setup(x => x.Set <AccessFunction>()).Returns(mockAccessFunction.Object);
            mockRMDBContext.Setup(x => x.AccessFunctions).Returns(mockAccessFunction.Object);
            mockAccessFunction.Setup(x => x.Include(It.IsAny <string>())).Returns(mockAccessFunction.Object);

            //Setup for Logging
            var rmTraceManagerMock = new Mock <IRMTraceManager>();

            rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
            mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);

            mockDatabaseFactory = CreateMock <IDatabaseFactory <ActionDBContext> >();
            mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
            testCandidate = new ActionManagerDataService(mockDatabaseFactory.Object, mockLoggingHelper.Object);
        }
 //-------------------------------------------------------------------------
 /// <summary>
 /// Creates an instance.
 /// </summary>
 /// <param name="pricer">  the cap pricer </param>
 /// <param name="referenceData">  the reference data </param>
 /// <returns> the instance </returns>
 public static SurfaceIborCapletFloorletVolatilityBootstrapper of(VolatilityIborCapFloorLegPricer pricer, ReferenceData referenceData)
 {
     return(new SurfaceIborCapletFloorletVolatilityBootstrapper(pricer, referenceData));
 }
        internal virtual LegalEntitySurvivalProbabilities calibrate(IList <CdsIsdaCreditCurveNode> curveNodes, CurveName name, MarketData marketData, ImmutableCreditRatesProvider ratesProvider, DayCount definitionDayCount, Currency definitionCurrency, bool computeJacobian, bool storeTrade, ReferenceData refData)
        {
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
            IEnumerator <StandardId> legalEntities = curveNodes.Select(CdsIsdaCreditCurveNode::getLegalEntityId).collect(Collectors.toSet()).GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
            StandardId legalEntityId = legalEntities.next();

//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
            ArgChecker.isFalse(legalEntities.hasNext(), "legal entity must be common to curve nodes");
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
            IEnumerator <Currency> currencies = curveNodes.Select(n => n.Template.Convention.Currency).collect(Collectors.toSet()).GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
            Currency currency = currencies.next();

//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
            ArgChecker.isFalse(currencies.hasNext(), "currency must be common to curve nodes");
            ArgChecker.isTrue(definitionCurrency.Equals(currency), "curve definition currency must be the same as the currency of CDS");
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
            IEnumerator <CdsQuoteConvention> quoteConventions = curveNodes.Select(n => n.QuoteConvention).collect(Collectors.toSet()).GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
            CdsQuoteConvention quoteConvention = quoteConventions.next();

//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
            ArgChecker.isFalse(quoteConventions.hasNext(), "quote convention must be common to curve nodes");
            LocalDate valuationDate = marketData.ValuationDate;

            ArgChecker.isTrue(valuationDate.Equals(marketData.ValuationDate), "ratesProvider and marketDate must be based on the same valuation date");
            CreditDiscountFactors discountFactors = ratesProvider.discountFactors(currency);

            ArgChecker.isTrue(definitionDayCount.Equals(discountFactors.DayCount), "credit curve and discount curve must be based on the same day count convention");
            RecoveryRates recoveryRates = ratesProvider.recoveryRates(legalEntityId);

            int nNodes = curveNodes.Count;

            double[] coupons = new double[nNodes];
            double[] pufs    = new double[nNodes];
//JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java:
//ORIGINAL LINE: double[][] diag = new double[nNodes][nNodes];
            double[][] diag = RectangularArrays.ReturnRectangularDoubleArray(nNodes, nNodes);
            ImmutableList.Builder <ResolvedCdsTrade> tradesBuilder = ImmutableList.builder();
            for (int i = 0; i < nNodes; i++)
            {
                CdsCalibrationTrade tradeCalibration = curveNodes[i].trade(1d, marketData, refData);
                ResolvedCdsTrade    trade            = tradeCalibration.UnderlyingTrade.resolve(refData);
                tradesBuilder.add(trade);
                double[] temp = getStandardQuoteForm(trade, tradeCalibration.Quote, valuationDate, discountFactors, recoveryRates, computeJacobian, refData);
                coupons[i] = temp[0];
                pufs[i]    = temp[1];
                diag[i][i] = temp[2];
            }
            ImmutableList <ResolvedCdsTrade> trades = tradesBuilder.build();
            NodalCurve nodalCurve = calibrate(trades, DoubleArray.ofUnsafe(coupons), DoubleArray.ofUnsafe(pufs), name, valuationDate, discountFactors, recoveryRates, refData);

            if (computeJacobian)
            {
                LegalEntitySurvivalProbabilities            creditCurve      = LegalEntitySurvivalProbabilities.of(legalEntityId, IsdaCreditDiscountFactors.of(currency, valuationDate, nodalCurve));
                ImmutableCreditRatesProvider                ratesProviderNew = ratesProvider.toBuilder().creditCurves(ImmutableMap.of(Pair.of(legalEntityId, currency), creditCurve)).build();
                System.Func <ResolvedCdsTrade, DoubleArray> sensiFunc        = quoteConvention.Equals(CdsQuoteConvention.PAR_SPREAD) ? getParSpreadSensitivityFunction(ratesProviderNew, name, currency, refData) : getPointsUpfrontSensitivityFunction(ratesProviderNew, name, currency, refData);
                DoubleMatrix sensi = DoubleMatrix.ofArrayObjects(nNodes, nNodes, i => sensiFunc(trades.get(i)));
                sensi = (DoubleMatrix)MATRIX_ALGEBRA.multiply(DoubleMatrix.ofUnsafe(diag), sensi);
                JacobianCalibrationMatrix jacobian = JacobianCalibrationMatrix.of(ImmutableList.of(CurveParameterSize.of(name, nNodes)), MATRIX_ALGEBRA.getInverse(sensi));
                nodalCurve = nodalCurve.withMetadata(nodalCurve.Metadata.withInfo(CurveInfoType.JACOBIAN, jacobian));
            }

            ImmutableList <ParameterMetadata> parameterMetadata;

            if (storeTrade)
            {
                parameterMetadata = IntStream.range(0, nNodes).mapToObj(n => ResolvedTradeParameterMetadata.of(trades.get(n), curveNodes[n].Label)).collect(Guavate.toImmutableList());
            }
            else
            {
                parameterMetadata = IntStream.range(0, nNodes).mapToObj(n => curveNodes[n].metadata(trades.get(n).Product.ProtectionEndDate)).collect(Guavate.toImmutableList());
            }
            nodalCurve = nodalCurve.withMetadata(nodalCurve.Metadata.withParameterMetadata(parameterMetadata));

            return(LegalEntitySurvivalProbabilities.of(legalEntityId, IsdaCreditDiscountFactors.of(currency, valuationDate, nodalCurve)));
        }
 private System.Func <ResolvedCdsTrade, DoubleArray> getParSpreadSensitivityFunction(CreditRatesProvider ratesProvider, CurveName curveName, Currency currency, ReferenceData refData)
 {
     System.Func <ResolvedCdsTrade, DoubleArray> func = (ResolvedCdsTrade trade) =>
     {
         PointSensitivities point = tradePricer.parSpreadSensitivity(trade, ratesProvider, refData);
         return(ratesProvider.parameterSensitivity(point).getSensitivity(curveName, currency).Sensitivity);
     };
     return(func);
 }
Exemple #12
0
        protected override void LoadProject()
        {
            _projectLoaded = true;

            //Read Step5 Project into a Byte-Array
            Stream fsProject = _ziphelper.GetReadStream(_projectfilename);

            s5ProjectByteArray = new byte[_ziphelper.GetStreamLength(_projectfilename, fsProject)];
            fsProject.Read(s5ProjectByteArray, 0, s5ProjectByteArray.Length);
            fsProject.Close();

            //Read the Project Name
            ProjectName = System.Text.Encoding.UTF7.GetString(s5ProjectByteArray, 0x08, 8);

            //Read the Project Size
            Size = s5ProjectByteArray[0x14] + s5ProjectByteArray[0x15] * 0x100;

            //Create the main Project Folder
            ProjectStructure = new Step5ProgrammFolder()
            {
                Project = this, Name = this.ToString()
            };
            _allFolders.Add(ProjectStructure);

            //int startpos = s5ProjectByteArray[0x12] * 0x80;

            int anz_sections = s5ProjectByteArray[0x16];

            List <int> sections_lst = new List <int>();

            for (int j = 0; j < anz_sections; j++)
            {
                int pos = 0x44 + j * 19;
                sections_lst.Add(s5ProjectByteArray[pos + 15] + s5ProjectByteArray[pos + 16] * 0x100);
            }


            Step5BlocksFolder blkFld = new Step5BlocksFolder()
            {
                Name = "Blocks", Project = this, Parent = ProjectStructure
            };

            BlocksFolder = blkFld;
            ProjectStructure.SubItems.Add(blkFld);

            //int section_start = startpos;

            int n = 0;

            List <int> ByteAddressOFExistingBlocks = new List <int>();

            foreach (int secpos in sections_lst)
            {
                int section_start = secpos * 0x80;
                /* The len for a Section is not always calculated right, so if the Section does not begin with the filename add 0x80 until it works */
                /* But I don't know why it's wrong */

                /*
                 * while (System.Text.Encoding.UTF7.GetString(s5ProjectByteArray, section_start, 8) != ProjectName)
                 * {
                 *  section_start += 0x80;
                 *  if (section_start>=s5ProjectByteArray.Length)
                 *      break;
                 * }
                 */

                if (section_start >= s5ProjectByteArray.Length)
                {
                    break;
                }

                //if (section_start == 0x1580)  //only for debbuging
                //    section_start = section_start;

                //Don't know what this Byte means, maybe it describes wich Blocks are in the Section?
                int section_header_type = s5ProjectByteArray[section_start + 8];

                int akanz  = 0;
                int anzbst = s5ProjectByteArray[section_start + 22];

                List <byte[]> bstHeaders = new List <byte[]>();
                for (int j = 0; j < anzbst; j++)
                {
                    byte[] tmp = new byte[15];
                    Array.Copy(s5ProjectByteArray, section_start + 68 + j * 15, tmp, 0, 15);
                    bstHeaders.Add(tmp);
                }


                //int section_size = ((s5ProjectByteArray[section_start + 21] * 0x100) + s5ProjectByteArray[section_start + 20]) * 0x80;

                //if (section_size == 0)   //only for debbuging
                //    section_size = section_size;

                /*
                 * int section_header_size = anzbst * 15 + 68;
                 * section_header_size = (section_header_size / 0x80) * 0x80;
                 * if ((anzbst * 15 + 68) % 0x80 != 0)
                 *  section_header_size += 0x80;
                 */

                //Don't know wich Information is in the Section Header!
                int section_header_size = s5ProjectByteArray[section_start + 18] * 0x80;



                //Read the Block normaly (using the Section-Headers)
                {
                    //for (int n = blkstart + blkheadersize; n < blkstart + blksize /* s5ProjectByteArray.Length - 2 */; n++)
                    n = section_start + section_header_size;
                    //while (s5ProjectByteArray[n] == 0x00 && s5ProjectByteArray[n + 1] == 0x00)
                    //    n += 0x80;

                    while (akanz < anzbst && n + 1 < s5ProjectByteArray.Length)
                    //n < section_start + section_size)
                    {
                        akanz++;
                        int len = 0;

                        ByteAddressOFExistingBlocks.Add(n);
                        var tmp = AddBlockInfo(s5ProjectByteArray, ref n, blkFld,
                                               bstHeaders[akanz - 1]);
                        if (tmp != null)
                        {
                            blkFld.step5BlocksinfoList.Add(tmp);
                        }

                        /*
                         * if (s5ProjectByteArray[n] == 0x70 && s5ProjectByteArray[n + 1] == 0x70) //Step5 Block
                         * // && s5ProjectByteArray[n - 1] == 0x00)
                         * {
                         *  len = (s5ProjectByteArray[n + 8] * 0x100 + s5ProjectByteArray[n + 9]) * 2;
                         *
                         *  Step5ProjectBlockInfo tmpBlk = new Step5ProjectBlockInfo();
                         *  //S5Block tmpBlk = new S5Block();
                         *
                         *  //if (((IList<int>)Enum.GetValues(typeof(PLCBlockType))).Contains((s5ProjectByteArray[n + 2] | 0xf00))) //only for debbuging
                         *  tmpBlk.BlockType = (PLCBlockType)(s5ProjectByteArray[n + 2] | 0xf00);
                         *  //else
                         *  //    tt_nr = tt_nr;
                         *
                         *  tmpBlk.BlockNumber = s5ProjectByteArray[n + 3];
                         *
                         *  tmpBlk._blkHeaderByte = bstHeaders[akanz - 1];
                         *
                         *  //byte n+4 -> kennungen für das programiergerät
                         *  //byte n+5,6,7 -> bib nummer
                         *
                         *  byte[] code = new byte[len];
                         *  Array.Copy(s5ProjectByteArray, n, code, 0, len);
                         *  tmpBlk._blkByte = code;
                         *  tmpBlk.ParentFolder = blkFld;
                         *
                         *  blkFld.step5BlocksinfoList.Add(tmpBlk);
                         *  //string aa = System.Text.Encoding.GetEncoding("ISO-8859-1").GetString(code);
                         * }
                         * else if (s5ProjectByteArray[n] == 0x06) //DB - Vorkopf
                         * {
                         *  len = (s5ProjectByteArray[n + 4] * 0x100 + s5ProjectByteArray[n + 5]) * 2;
                         *  Step5ProjectBlockInfo tmpBlk = new Step5ProjectBlockInfo();
                         *  //S5Block tmpBlk = new S5Block();
                         *
                         *  tmpBlk.BlockType = PLCBlockType.S5_DV;
                         *
                         *  tmpBlk.BlockNumber = s5ProjectByteArray[n + 1];
                         *
                         *  byte[] code = new byte[len];
                         *  Array.Copy(s5ProjectByteArray, n, code, 0, len);
                         *  tmpBlk._blkByte = code;
                         *  tmpBlk.ParentFolder = blkFld;
                         *
                         *  blkFld.step5BlocksinfoList.Add(tmpBlk);
                         * }
                         * else if (s5ProjectByteArray[n] == 0x11) //DX - Vorkopf
                         * {
                         *  len = (s5ProjectByteArray[n + 4] * 0x100 + s5ProjectByteArray[n + 5]) * 2;
                         *  Step5ProjectBlockInfo tmpBlk = new Step5ProjectBlockInfo();
                         *  //S5Block tmpBlk = new S5Block();
                         *
                         *  tmpBlk.BlockType = PLCBlockType.S5_DVX;
                         *
                         *  tmpBlk.BlockNumber = s5ProjectByteArray[n + 1];
                         *
                         *  byte[] code = new byte[len];
                         *  Array.Copy(s5ProjectByteArray, n, code, 0, len);
                         *  tmpBlk._blkByte = code;
                         *  tmpBlk.ParentFolder = blkFld;
                         *
                         *  blkFld.step5BlocksinfoList.Add(tmpBlk);
                         * }
                         * else if (s5ProjectByteArray[n] == 0x0D) //FB - Vorkopf
                         * {
                         *  len = (s5ProjectByteArray[n + 4] * 0x100 + s5ProjectByteArray[n + 5]) * 2;
                         *  Step5ProjectBlockInfo tmpBlk = new Step5ProjectBlockInfo();
                         *  //S5Block tmpBlk = new S5Block();
                         *
                         *  tmpBlk.BlockType = PLCBlockType.S5_FV;
                         *
                         *  tmpBlk.BlockNumber = s5ProjectByteArray[n + 1];
                         *
                         *  byte[] code = new byte[len];
                         *  Array.Copy(s5ProjectByteArray, n, code, 0, len);
                         *  tmpBlk._blkByte = code;
                         *  tmpBlk.ParentFolder = blkFld;
                         *
                         *  blkFld.step5BlocksinfoList.Add(tmpBlk);
                         * }
                         * else if (s5ProjectByteArray[n] == 0x0A) //FX - Vorkopf
                         * {
                         *  len = (s5ProjectByteArray[n + 4] * 0x100 + s5ProjectByteArray[n + 5]) * 2;
                         *  Step5ProjectBlockInfo tmpBlk = new Step5ProjectBlockInfo();
                         *  //S5Block tmpBlk = new S5Block();
                         *
                         *  tmpBlk.BlockType = PLCBlockType.S5_FVX;
                         *
                         *  tmpBlk.BlockNumber = s5ProjectByteArray[n + 1];
                         *
                         *  byte[] code = new byte[len];
                         *  Array.Copy(s5ProjectByteArray, n, code, 0, len);
                         *  tmpBlk._blkByte = code;
                         *  tmpBlk.ParentFolder = blkFld;
                         *
                         *  blkFld.step5BlocksinfoList.Add(tmpBlk);
                         * }
                         * else
                         * {
                         *  //Here are the $ Blocks woch are not yet implemented!
                         *  //akanz--;
                         *  len = 0x80;
                         * }
                         *
                         * n += (len / 0x80) * 0x80;
                         * if (len % 0x80 != 0)
                         *  n += 0x80;
                         */
                    }
                }
                section_start = n;
                //section_start += section_size;
            }

            if (_showDeleted)
            {
                //Read also the deleted Blocks, that means, don't use the Section Headers ...
                int akpos = s5ProjectByteArray[0x12] * 0x80;

                while (akpos <= s5ProjectByteArray.Length - 0x80)
                {
                    while (!IsCurrentPosABlockStart(s5ProjectByteArray, akpos) &&
                           akpos <= s5ProjectByteArray.Length - 0x80)
                    {
                        akpos += 0x80;
                    }

                    if (akpos <= s5ProjectByteArray.Length - 0x80)
                    {
                        bool blkExists = ByteAddressOFExistingBlocks.Contains(akpos);
                        var  tmp       = AddBlockInfo(s5ProjectByteArray, ref akpos, blkFld, null);
                        if (!blkExists)
                        {
                            tmp.Deleted = true;
                            blkFld.step5BlocksinfoList.Add(tmp);
                        }
                    }
                }
            }

            if (_projectfilename.ToLower().Contains("st.s5d") && _ziphelper.FileExists(_projectfilename.ToLower().Replace("st.s5d", "z0.seq")))
            {
                Stream symTabStream = _ziphelper.GetReadStream(_projectfilename.ToLower().Replace("st.s5d", "z0.seq"));

                SymbolTable symtab = new SymbolTable();
                symtab.LoadSymboltable(symTabStream);
                symTabStream.Close();
                symtab.Parent  = ProjectStructure;
                symtab.Project = this;
                ProjectStructure.SubItems.Add(symtab);
                _allFolders.Add(symtab);
            }

            var refFld = new ReferenceData((Step5ProgrammFolder)ProjectStructure, this);

            ProjectStructure.SubItems.Add(refFld); // { Parent = ProjectStructure, Project = this });
            _allFolders.Add(refFld);
        }
        //-------------------------------------------------------------------------
        /// <summary>
        /// Calibrates the ISDA compliant credit curve to the market data.
        /// <para>
        /// This creates the single credit curve for a legal entity.
        /// The curve nodes in {@code IsdaCreditCurveDefinition} should be single-name credit default swaps on this legal entity.
        /// </para>
        /// <para>
        /// The relevant discount curve and recovery rate curve must be stored in {@code ratesProvider}.
        /// The day count convention for the resulting credit curve is the same as that of the discount curve.
        ///
        /// </para>
        /// </summary>
        /// <param name="curveDefinition">  the curve definition </param>
        /// <param name="marketData">  the market data </param>
        /// <param name="ratesProvider">  the rates provider </param>
        /// <param name="refData">  the reference data </param>
        /// <returns> the ISDA compliant credit curve </returns>
        public virtual LegalEntitySurvivalProbabilities calibrate(IsdaCreditCurveDefinition curveDefinition, MarketData marketData, ImmutableCreditRatesProvider ratesProvider, ReferenceData refData)
        {
            ArgChecker.isTrue(curveDefinition.CurveValuationDate.Equals(ratesProvider.ValuationDate), "ratesProvider and curveDefinition must be based on the same valuation date");
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
            ImmutableList <CdsIsdaCreditCurveNode> curveNodes = curveDefinition.CurveNodes.Where(n => n is CdsIsdaCreditCurveNode).Select(n => (CdsIsdaCreditCurveNode)n).collect(Guavate.toImmutableList());

            return(calibrate(curveNodes, curveDefinition.Name, marketData, ratesProvider, curveDefinition.DayCount, curveDefinition.Currency, curveDefinition.ComputeJacobian, curveDefinition.StoreNodeTrade, refData));
        }
        //-------------------------------------------------------------------------
        /// <summary>
        /// Creates an {@code IborRateObservation} from an index and fixing date.
        /// <para>
        /// The reference data is used to find the maturity date from the fixing date.
        ///
        /// </para>
        /// </summary>
        /// <param name="index">  the index </param>
        /// <param name="fixingDate">  the fixing date </param>
        /// <param name="refData">  the reference data to use when resolving holiday calendars </param>
        /// <returns> the rate observation </returns>
        public static OvernightIndexObservation of(OvernightIndex index, LocalDate fixingDate, ReferenceData refData)
        {
            LocalDate publicationDate = index.calculatePublicationFromFixing(fixingDate, refData);
            LocalDate effectiveDate   = index.calculateEffectiveFromFixing(fixingDate, refData);
            LocalDate maturityDate    = index.calculateMaturityFromEffective(effectiveDate, refData);

            return(OvernightIndexObservation.builder().index(index).fixingDate(fixingDate).publicationDate(publicationDate).effectiveDate(effectiveDate).maturityDate(maturityDate).yearFraction(index.DayCount.yearFraction(effectiveDate, maturityDate)).build());
        }
 protected override void Initialize(ContainerRecord record, ReferenceData referenceData)
 {
     base.Initialize(record, referenceData);
     lockData = new LockData(referenceData.LockLevel, referenceData.Trap, referenceData.Key);
 }
        // calculate the end date
        private LocalDate calculateEnd(LocalDate valuationDate, ReferenceData refData)
        {
            SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData);

            return(trade.Product.EndDate.adjusted(refData));
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="GangwaySettingsUserControlViewModel" /> class.
 /// </summary>
 /// <param name="referenceData">The reference data.</param>
 /// <param name="isRedirectedForcefullyToSaveSettings">if set to <c>true</c> [is redirected to save settings].</param>
 public GangwaySettingsUserControlViewModel(ReferenceData referenceData, bool isRedirectedForcefullyToSaveSettings)
 {
     this.RegisterEvents();
     this.referenceData = referenceData;
     this.referenceDataService = DIContainer.Instance.Resolve<IReferenceDataService>();
     this.canCancel = !isRedirectedForcefullyToSaveSettings;
 }
 /// <summary>
 /// Calibrate the ISDA compliant credit curve to points upfront and fractional spread.
 /// </summary>
 /// <param name="calibrationCDSs">  the calibration CDS </param>
 /// <param name="flactionalSpreads">  the fractional spreads </param>
 /// <param name="pointsUpfront">  the points upfront values </param>
 /// <param name="name">  the curve name </param>
 /// <param name="valuationDate">  the valuation date </param>
 /// <param name="discountFactors">  the discount factors </param>
 /// <param name="recoveryRates">  the recovery rates </param>
 /// <param name="refData">  the reference data </param>
 /// <returns> the ISDA compliant credit curve </returns>
 public abstract NodalCurve calibrate(IList <ResolvedCdsTrade> calibrationCDSs, DoubleArray flactionalSpreads, DoubleArray pointsUpfront, CurveName name, LocalDate valuationDate, CreditDiscountFactors discountFactors, RecoveryRates recoveryRates, ReferenceData refData);
        public static void SerializeComponents(List<IComponentOld> components, out string data, out ReferenceData[] references)
        {
            var referenceList = new List<ReferenceData>();

            for (int i = 0; i < components.Count; i++)
            {
                var component = components[i];
                ExtractReferences(component, i, "", referenceList);
            }

            data = SerializeComponents(components);
            references = referenceList.ToArray();
            InjectReferences(components, references);
        }
 private double[] getStandardQuoteForm(ResolvedCdsTrade calibrationCds, CdsQuote marketQuote, LocalDate valuationDate, CreditDiscountFactors discountFactors, RecoveryRates recoveryRates, bool computeJacobian, ReferenceData refData)
 {
     double[] res = new double[3];
     res[2] = 1d;
     if (marketQuote.QuoteConvention.Equals(CdsQuoteConvention.PAR_SPREAD))
     {
         res[0] = marketQuote.QuotedValue;
     }
     else if (marketQuote.QuoteConvention.Equals(CdsQuoteConvention.QUOTED_SPREAD))
     {
         double     qSpread                 = marketQuote.QuotedValue;
         CurveName  curveName               = CurveName.of("quoteConvertCurve");
         NodalCurve tempCreditCurve         = calibrate(ImmutableList.of(calibrationCds), DoubleArray.of(qSpread), DoubleArray.of(0d), curveName, valuationDate, discountFactors, recoveryRates, refData);
         Currency   currency                = calibrationCds.Product.Currency;
         StandardId legalEntityId           = calibrationCds.Product.LegalEntityId;
         ImmutableCreditRatesProvider rates = ImmutableCreditRatesProvider.builder().valuationDate(valuationDate).discountCurves(ImmutableMap.of(currency, discountFactors)).recoveryRateCurves(ImmutableMap.of(legalEntityId, recoveryRates)).creditCurves(ImmutableMap.of(Pair.of(legalEntityId, currency), LegalEntitySurvivalProbabilities.of(legalEntityId, IsdaCreditDiscountFactors.of(currency, valuationDate, tempCreditCurve)))).build();
         res[0] = calibrationCds.Product.FixedRate;
         res[1] = tradePricer.price(calibrationCds, rates, PriceType.CLEAN, refData);
         if (computeJacobian)
         {
             CurrencyParameterSensitivities pufSensi = rates.parameterSensitivity(tradePricer.priceSensitivity(calibrationCds, rates, refData));
             CurrencyParameterSensitivities spSensi  = rates.parameterSensitivity(tradePricer.parSpreadSensitivity(calibrationCds, rates, refData));
             res[2] = spSensi.getSensitivity(curveName, currency).Sensitivity.get(0) / pufSensi.getSensitivity(curveName, currency).Sensitivity.get(0);
         }
     }
     else if (marketQuote.QuoteConvention.Equals(CdsQuoteConvention.POINTS_UPFRONT))
     {
         res[0] = calibrationCds.Product.FixedRate;
         res[1] = marketQuote.QuotedValue;
     }
     else
     {
         throw new System.ArgumentException("Unknown CDSQuoteConvention type " + marketQuote.GetType());
     }
     return(res);
 }
Exemple #21
0
 /// <summary>
 /// Function to open log on view.
 /// </summary>
 /// <param name="tupleData">The tuple data.</param>
 private void OpenLogonView(Tuple<LogOnMode, ReferenceData> tupleData)
 {
     this.referenceData = tupleData.Item2 != null ? tupleData.Item2 : null;
     Application.Current.ShowWindowAsDialog(() => new LogOn(tupleData.Item1));
 }
Exemple #22
0
        public WDC1Reader(Stream stream)
        {
            using (var reader = new BinaryReader(stream, Encoding.UTF8))
            {
                if (reader.BaseStream.Length < HeaderSize)
                {
                    throw new InvalidDataException("WDC1 file is corrupted!");
                }

                uint magic = reader.ReadUInt32();

                if (magic != WDC1FmtSig)
                {
                    throw new InvalidDataException("WDC1 file is corrupted!");
                }

                RecordsCount    = reader.ReadInt32();
                FieldsCount     = reader.ReadInt32();
                RecordSize      = reader.ReadInt32();
                StringTableSize = reader.ReadInt32();

                TableHash  = reader.ReadUInt32();
                LayoutHash = reader.ReadUInt32();
                MinIndex   = reader.ReadInt32();
                MaxIndex   = reader.ReadInt32();
                int locale        = reader.ReadInt32();
                int copyTableSize = reader.ReadInt32();
                Flags        = (DB2Flags)reader.ReadUInt16();
                IdFieldIndex = reader.ReadUInt16();

                int totalFieldsCount = reader.ReadInt32();
                PackedDataOffset = reader.ReadInt32();          // Offset within the field where packed data starts
                int lookupColumnCount  = reader.ReadInt32();    // count of lookup columns
                int sparseTableOffset  = reader.ReadInt32();    // absolute value, {uint offset, ushort size}[MaxId - MinId + 1]
                int indexDataSize      = reader.ReadInt32();    // int indexData[IndexDataSize / 4]
                int columnMetaDataSize = reader.ReadInt32();    // 24 * NumFields bytes, describes column bit packing, {ushort recordOffset, ushort size, uint additionalDataSize, uint compressionType, uint packedDataOffset or commonvalue, uint cellSize, uint cardinality}[NumFields], sizeof(DBC2CommonValue) == 8
                int commonDataSize     = reader.ReadInt32();
                int palletDataSize     = reader.ReadInt32();    // in bytes, sizeof(DBC2PalletValue) == 4
                int referenceDataSize  = reader.ReadInt32();    // uint NumRecords, uint minId, uint maxId, {uint id, uint index}[NumRecords], questionable usefulness...

                if (RecordsCount == 0)
                {
                    return;
                }

                // field meta data
                field_structure_data = reader.ReadArray <FieldMetaData>(FieldsCount);

                if (!Flags.HasFlagExt(DB2Flags.Sparse))
                {
                    // records data
                    RecordsData = reader.ReadBytes(RecordsCount * RecordSize);

                    Array.Resize(ref RecordsData, RecordsData.Length + 8); // pad with extra zeros so we don't crash when reading

                    // string data
                    StringTable = new Dictionary <long, string>(StringTableSize / 0x20);
                    for (int i = 0; i < StringTableSize;)
                    {
                        long oldPos = reader.BaseStream.Position;
                        StringTable[i] = reader.ReadCString();
                        i += (int)(reader.BaseStream.Position - oldPos);
                    }
                }
                else
                {
                    // sparse data with inlined strings
                    RecordsData = reader.ReadBytes(sparseTableOffset - HeaderSize - Marshal.SizeOf <FieldMetaData>() * FieldsCount);

                    if (reader.BaseStream.Position != sparseTableOffset)
                    {
                        throw new Exception("r.BaseStream.Position != sparseTableOffset");
                    }

                    int sparseCount = MaxIndex - MinIndex + 1;

                    offset_map_Entries = new List <offset_map_entry>(sparseCount);
                    CopyData           = new Dictionary <int, int>(sparseCount);
                    var sparseIdLookup = new Dictionary <uint, int>(sparseCount);

                    for (int i = 0; i < sparseCount; i++)
                    {
                        offset_map_entry sparse = reader.Read <offset_map_entry>();
                        if (sparse.Offset == 0 || sparse.Size == 0)
                        {
                            continue;
                        }

                        if (sparseIdLookup.TryGetValue(sparse.Offset, out int copyId))
                        {
                            CopyData[MinIndex + i] = copyId;
                        }
                        else
                        {
                            offset_map_Entries.Add(sparse);
                            sparseIdLookup.Add(sparse.Offset, MinIndex + i);
                        }
                    }
                }

                // index data
                id_list_data = reader.ReadArray <int>(indexDataSize / 4);

                // duplicate rows data
                if (CopyData == null)
                {
                    CopyData = new Dictionary <int, int>(copyTableSize / 8);
                }

                for (int i = 0; i < copyTableSize / 8; i++)
                {
                    CopyData[reader.ReadInt32()] = reader.ReadInt32();
                }

                // column meta data
                ColumnMeta = reader.ReadArray <ColumnMetaData>(FieldsCount);

                // pallet data
                PalletData = new Value32[ColumnMeta.Length][];
                for (int i = 0; i < ColumnMeta.Length; i++)
                {
                    if (ColumnMeta[i].CompressionType == CompressionType.Pallet || ColumnMeta[i].CompressionType == CompressionType.PalletArray)
                    {
                        PalletData[i] = reader.ReadArray <Value32>((int)ColumnMeta[i].AdditionalDataSize / 4);
                    }
                }

                // common data
                CommonData = new Dictionary <int, Value32> [ColumnMeta.Length];
                for (int i = 0; i < ColumnMeta.Length; i++)
                {
                    if (ColumnMeta[i].CompressionType == CompressionType.Common)
                    {
                        var commonValues = new Dictionary <int, Value32>((int)ColumnMeta[i].AdditionalDataSize / 8);
                        CommonData[i] = commonValues;

                        for (int j = 0; j < ColumnMeta[i].AdditionalDataSize / 8; j++)
                        {
                            commonValues[reader.ReadInt32()] = reader.Read <Value32>();
                        }
                    }
                }

                // reference data
                ReferenceData refData = new ReferenceData();
                if (referenceDataSize > 0)
                {
                    refData.NumRecords = reader.ReadInt32();
                    refData.MinId      = reader.ReadInt32();
                    refData.MaxId      = reader.ReadInt32();

                    var entries = reader.ReadArray <ReferenceEntry>(refData.NumRecords);
                    for (int i = 0; i < entries.Length; i++)
                    {
                        refData.Entries[entries[i].Index] = entries[i].Id;
                    }
                }

                int position = 0;
                for (int i = 0; i < RecordsCount; i++)
                {
                    BitReader bitReader = new BitReader(RecordsData)
                    {
                        Position = 0
                    };

                    if (Flags.HasFlagExt(DB2Flags.Sparse))
                    {
                        bitReader.Position = position;
                        position          += offset_map_Entries[i].Size * 8;
                    }
                    else
                    {
                        bitReader.Offset = i * RecordSize;
                    }

                    refData.Entries.TryGetValue(i, out int refId);

                    IDBRow rec = new WDC1Row(this, bitReader, indexDataSize != 0 ? id_list_data[i] : -1, refId, i);
                    _Records.Add(i, rec);
                }
            }
        }
Exemple #23
0
 public CurveMetadata metadata(LocalDate valuationDate, ReferenceData refData)
 {
     return(curveWithoutFixingDefinition.metadata(valuationDate, refData));
 }
 //-------------------------------------------------------------------------
 /// <summary>
 /// Creates an instance from an index and fixing date.
 /// <para>
 /// The reference data is used to find the maturity date from the fixing date.
 ///
 /// </para>
 /// </summary>
 /// <param name="index">  the index </param>
 /// <param name="fixingDate">  the fixing date </param>
 /// <param name="refData">  the reference data to use when resolving holiday calendars </param>
 /// <returns> the rate computation </returns>
 public static IborRateComputation of(IborIndex index, LocalDate fixingDate, ReferenceData refData)
 {
     return(new IborRateComputation(IborIndexObservation.of(index, fixingDate, refData)));
 }
Exemple #25
0
 public LocalDate date(LocalDate valuationDate, ReferenceData refData)
 {
     return(date_Renamed.calculate(() => calculateEnd(valuationDate, refData), () => calculateLastFixingDate(valuationDate)));
 }
Exemple #26
0
        private const uint WDC1FmtSig = 0x31434457; // WDC1

        public WDC1Writer(WDC1Reader reader, IDictionary <int, T> storage, Stream stream) : base(reader)
        {
            // always 2 empties
            StringTableSize++;

            WDC1RowSerializer <T> serializer = new WDC1RowSerializer <T>(this);

            serializer.Serialize(storage);
            serializer.GetCopyRows();

            RecordsCount = serializer.Records.Count - CopyData.Count;

            var(commonDataSize, palletDataSize, referenceDataSize) = GetDataSizes();

            using (var writer = new BinaryWriter(stream))
            {
                int minIndex      = storage.Keys.Min();
                int maxIndex      = storage.Keys.Max();
                int copyTableSize = Flags.HasFlagExt(DB2Flags.Sparse) ? 0 : CopyData.Count * 8;

                writer.Write(WDC1FmtSig);
                writer.Write(RecordsCount);
                writer.Write(FieldsCount);
                writer.Write(RecordSize);
                writer.Write(StringTableSize);
                writer.Write(reader.TableHash);
                writer.Write(reader.LayoutHash);
                writer.Write(minIndex);
                writer.Write(maxIndex);
                writer.Write(reader.Locale);
                writer.Write(copyTableSize);
                writer.Write((ushort)Flags);
                writer.Write((ushort)IdFieldIndex);

                writer.Write(FieldsCount);                     // totalFieldCount
                writer.Write(reader.PackedDataOffset);
                writer.Write(ReferenceData.Count > 0 ? 1 : 0); // RelationshipColumnCount
                writer.Write(0);                               // sparseTableOffset
                writer.Write(RecordsCount * 4);                // indexTableSize
                writer.Write(ColumnMeta.Length * 24);          // ColumnMetaDataSize
                writer.Write(commonDataSize);
                writer.Write(palletDataSize);
                writer.Write(referenceDataSize);

                if (storage.Count == 0)
                {
                    return;
                }

                // field meta
                writer.WriteArray(field_structure_data);

                // record data
                uint recordsOffset = (uint)writer.BaseStream.Position;
                foreach (var record in serializer.Records)
                {
                    if (!CopyData.TryGetValue(record.Key, out int parent))
                    {
                        record.Value.CopyTo(writer.BaseStream);
                    }
                }

                // string table
                if (!Flags.HasFlagExt(DB2Flags.Sparse))
                {
                    writer.WriteCString("");
                    foreach (var str in StringTableStingAsKeyPosAsValue)
                    {
                        writer.WriteCString(str.Key);
                    }
                }

                // sparse data
                if (Flags.HasFlagExt(DB2Flags.Sparse))
                {
                    // set the sparseTableOffset
                    long oldPos = writer.BaseStream.Position;
                    writer.BaseStream.Position = 60;
                    writer.Write((uint)oldPos);
                    writer.BaseStream.Position = oldPos;

                    WriteOffsetRecords(writer, serializer, recordsOffset, maxIndex - minIndex + 1);
                }

                // index table
                if (Flags.HasFlagExt(DB2Flags.Index))
                {
                    writer.WriteArray(serializer.Records.Keys.Except(CopyData.Keys).ToArray());
                }

                // copy table
                if (!Flags.HasFlagExt(DB2Flags.Sparse))
                {
                    foreach (var copyRecord in CopyData)
                    {
                        writer.Write(copyRecord.Key);
                        writer.Write(copyRecord.Value);
                    }
                }

                // column meta data
                writer.WriteArray(ColumnMeta);

                // pallet data
                for (int i = 0; i < ColumnMeta.Length; i++)
                {
                    if (ColumnMeta[i].CompressionType == CompressionType.Pallet || ColumnMeta[i].CompressionType == CompressionType.PalletArray)
                    {
                        foreach (var palletData in PalletData[i])
                        {
                            writer.WriteArray(palletData);
                        }
                    }
                }

                // common data
                for (int i = 0; i < ColumnMeta.Length; i++)
                {
                    if (ColumnMeta[i].CompressionType == CompressionType.Common)
                    {
                        foreach (var commondata in CommonData[i])
                        {
                            writer.Write(commondata.Key);
                            writer.Write(commondata.Value.GetValue <int>());
                        }
                    }
                }

                // reference data
                if (ReferenceData.Count > 0)
                {
                    writer.Write(ReferenceData.Count);
                    writer.Write(ReferenceData.Min());
                    writer.Write(ReferenceData.Max());

                    for (int i = 0; i < ReferenceData.Count; i++)
                    {
                        writer.Write(ReferenceData[i]);
                        writer.Write(i);
                    }
                }
            }
        }
Exemple #27
0
        //-------------------------------------------------------------------------
        public virtual Results calculateMultiScenario <T1>(CalculationRules calculationRules, IList <T1> targets, IList <Column> columns, ScenarioMarketData marketData, ReferenceData refData) where T1 : com.opengamma.strata.basics.CalculationTarget
        {
            CalculationTasks tasks = CalculationTasks.of(calculationRules, targets, columns, refData);

            return(taskRunner.calculateMultiScenario(tasks, marketData, refData));
        }
Exemple #28
0
        public ResolvedCapitalIndexedBondTrade resolve(ReferenceData refData)
        {
            ResolvedCapitalIndexedBond resolved = product.resolve(refData);

            return(new ResolvedCapitalIndexedBondTrade(info, resolved, Quantity, null));
        }
Exemple #29
0
        private static double TestPointEL(ReferenceData referenceData, TestDataCollection testDataCollection, string testType, string temp, int port, string pSetting)
        {
            var pointTestData = testDataCollection.GetTestData(testType, "Point", "PointPDL");

            if (pointTestData == null)
            {
                throw new MeasuringException("没有计算EL所需测试数据");
            }

            var wl = pSetting.CastTo(double.MaxValue);

            if (wl == double.MinValue)
            {
                throw new MeasuringException("波长设置错误");
            }

            var testData = pointTestData.GetTestData();

            if (!testData.ContainsKey(temp))
            {
                throw new MeasuringException("没有计算EL所需测试数据");
            }
            var data     = testData[temp];
            var allPower = 0D;
            var inPower  = 0D;
            var count    = 0;
            var setting  = TestPortSetting.Get(port);

            foreach (var item in data)
            {
                var ch = item.Key;
                if (ch < 1 || !item.Value.ContainsKey(wl))
                {
                    continue;
                }

                var chSetting = TestPortSetting.Get(ch);
                if (chSetting.DataID != setting.DataID)
                {
                    continue;
                }

                var testItem = item.Value[wl];
                if (testItem.Power == double.MinValue)
                {
                    continue;
                }

                var refpower = referenceData.GetReference(1, ch % TestPortSetting.DataDivide, wl);
                allPower += MeasuringManager.Convert_dBm2mW(testItem.Power);
                inPower  += refpower.Power;
                count++;
            }
            allPower = MeasuringManager.Convert_mW2dBm(allPower) + Windows.IniProfile <BusinessLogic.Setting.SystemSetting> .Instance.Profile.ExtraLosssCompensation;
            inPower  = inPower / count;

            var value = inPower == double.MinValue ?
                        double.MinValue :
                        Math.Abs(Math.Round(allPower - inPower, 3));

            return(value);
        }
Exemple #30
0
 public ResolvedSwapTrade resolve(ReferenceData refData)
 {
     return(new ResolvedSwapTrade(info, product.resolve(refData)));
 }
 public HttpResponseMessage RetrieveReferenceData(string userId)
 {
     ReferenceData referenceData = new ReferenceData();
     var masterDetail = this.clientService.RetrieveList(Convert.ToInt32(userId, CultureInfo.CurrentCulture));
     var projects = this.lookupService.RetrieveProjects(null, null, false, null, Convert.ToInt32(userId, CultureInfo.CurrentCulture));
     var developers = this.developerService.RetrieveListByDeveloperName(null, Convert.ToInt32(userId, CultureInfo.CurrentCulture));
     var ticketPriority = this.lookupService.RetrievePriorityListItem(Convert.ToInt32(userId, CultureInfo.CurrentCulture));
     var myTicketCount = this.lookupService.RetrieveMyTicketCountList(Convert.ToInt32(userId, CultureInfo.CurrentCulture));
     var tags = this.lookupService.RetrieveTagList();
     masterDetail.Where(a => !a.IsInactive).ToList().ForEach(masterData => referenceData.Clients.Add(MapToClients(masterData)));
     projects.ForEach(projectData => referenceData.Projects.Add(MapToProjects(projectData)));
     tags.ForEach(tagData => referenceData.Tags.Add(MapToTags(tagData)));
     ticketPriority.ForEach(priorityData => referenceData.Priorities.Add(MapToPriority(priorityData)));
     developers.Where(a => !a.InActive).ToList().ForEach(developerListItem => referenceData.Developers.Add(MapToDeveloper(developerListItem)));
     referenceData.AllUnreadTicketCount = myTicketCount.AllUnReadTicketCount;
     referenceData.ForMeUnreadTicketCount = myTicketCount.ForMeUnReadTicketCount;
     referenceData.ByMeUnreadTicketCount = myTicketCount.ByMeUnReadTicketCount;
     return Request.CreateResponse(HttpStatusCode.OK, referenceData);
 }
Exemple #32
0
 public Currency naturalCurrency(CalculationTarget trade, ReferenceData refData)
 {
     throw new System.InvalidOperationException("Function has no currency-convertible measures");
 }
        /// <summary>
        /// Maps the reference data.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>Reference data.</returns>
        internal static async Task<ReferenceData> MapReferenceData(SqlDataReader dataReader)
        {
            var referenceData = new ReferenceData();

            if (dataReader != null)
            {
                referenceData.AssignBrands(await MapBrands(dataReader));

                await dataReader.NextResultAsync();
                var dictionaryPortBrand = await MapBrandPorts(dataReader);
                MapBrandPortIds(referenceData.Brands, dictionaryPortBrand);

                await dataReader.NextResultAsync();
                referenceData.AssignCountries(await MapCountries(dataReader));

                await dataReader.NextResultAsync();
                referenceData.AssignLoyaltyLevelTypes(await MapLoyaltyLevelTypes(dataReader));

                await dataReader.NextResultAsync();
                referenceData.AssignPersonTypes(await MapPersonTypes(dataReader));

                await dataReader.NextResultAsync();
                referenceData.AssignPorts(await MapPorts(dataReader));

                await dataReader.NextResultAsync();
                referenceData.AssignStates(await MapStates(dataReader));

                await dataReader.NextResultAsync();
                referenceData.AssignDocumentTypes(await MapDocumentTypes(dataReader));

                if (!dataReader.IsClosed)
                {
                    dataReader.Close();
                }
            }

            return await Task.FromResult(referenceData);
        }
        private void SetUpData()
        {
            Domain.Dependencies.Register();
            DataAccess.Dependencies.Register();

            Workstation ws = DIContainer.Instance.Resolve<Workstation>();

            ws.Port = new Port { PortId = "1" };
            ws.Ship = new Ship { ShipId = "1" };
            ws.GangwayLocation = new GangwayLocation { LocationId = "1" };
            ws.GangwayServiceBaseAddress = "http://Localhost/";
            ws.ConfigurationServiceBaseAddress = "http://Localhost/";
            ws.AuthenticationServiceBaseAddress = "http://Localhost/";
            ws.AuthorizationServiceBaseAddress = "http://Localhost/";
            ws.ConnectionMode = ConnectionMode.Online;
            var intCollection = new Collection<int>();
            intCollection.Add(0);
            var brand = new Brand { BrandId = "3", Name = "Carnival Breeze", MediaItemAddress = "http://172.26.248.122/ImagingMediaService/MediaItems/23" };
            brand.AssignPortIds(intCollection);
            ws.Brand = brand;

            this.personServiceRepositoryMock = new Mock<PersonServiceRepository>();
            this.referenceDataRepositoryMock = new Mock<ReferenceDataRepository>();
            DIContainer.Instance.RegisterInstance<ReferenceDataRepository>(this.referenceDataRepositoryMock.Object);
            DIContainer.Instance.RegisterInstance<PersonServiceRepository>(this.personServiceRepositoryMock.Object);

            this.personServiceRepositoryMock.Setup(data => data.RetrievePersonsBySearchText(It.IsNotNull<string>(), It.IsAny<string>(), It.IsAny<IList<PersonType>>(), It.IsAny<SearchType>(), null, null, 0, 0, null, null)).Returns(Task.FromResult(this.person));

            this.personTypes = new List<PersonType>();
            personTypes.Add(PersonType.Guest);

            var documentTypes = new DocumentTypeCollection();
            documentTypes.Add(new DocumentType { CountryId = "232", Code = "USA", DocumentTypeId = "1", Name = "Passport" });
            var referencedata = new ReferenceData();
            referencedata.AssignDocumentTypes(documentTypes);
            this.referenceDataRepositoryMock.Setup(data => data.RetrieveReferenceDataAsync()).Returns(Task.FromResult(referencedata));
        }
        public static void InjectReferences(List<IComponentOld> components, ReferenceData[] references)
        {
            for (int i = 0; i < references.Length; i++)
            {
                var reference = references[i];

                try { components[reference.Index].SetValueToFieldAtPath(reference.PathSplit, reference.Reference); }
                catch { }
            }
        }
Exemple #36
0
 public FunctionRequirements requirements(CalculationTarget target, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData)
 {
     return(FunctionRequirements.empty());
 }
 // private constructor
 private SurfaceIborCapletFloorletVolatilityBootstrapper(VolatilityIborCapFloorLegPricer pricer, ReferenceData referenceData) : base(pricer, referenceData)
 {
 }
        /// <summary>
        /// Setups the data.
        /// </summary>
        private void SetupData()
        {
            Domain.Dependencies.Register();
            DataAccess.Dependencies.Register();

            this.workstationMock = new Mock<Workstation>();
            DIContainer.Instance.RegisterInstance<Workstation>(this.workstationMock.Object);
            Workstation ws = DIContainer.Instance.Resolve<Workstation>();

            ws.Port = new Port { PortId = "1" };
            ws.Ship = new Ship { ShipId = "5" };
            ws.GangwayLocation = new GangwayLocation { LocationId = "1" };
            ws.GangwayServiceBaseAddress = "http://Localhost/";
            ws.ConfigurationServiceBaseAddress = "http://Localhost/";
            ws.AuthenticationServiceBaseAddress = "http://Localhost/";
            ws.AuthorizationServiceBaseAddress = "http://Localhost/";
            ws.ConnectionMode = ConnectionMode.Online;
            var intCollection = new Collection<int>();
            intCollection.Add(0);
            var brand = new Brand { BrandId = "3", Name = "Carnival Breeze", MediaItemAddress = "http://172.26.248.122/ImagingMediaService/MediaItems/23" };
            var voyageList = new List<Voyage>();
            var voyage = new Voyage { DebarkPortId = "1", EmbarkPortId = "1", DestinationId = "1", MediaItemAddress = "http://172.26.248.122/", VoyageId = "31", Name = "Carnival Voyage", IsActive = true, ShipId = "5", Number = "ccl", DebarkDate = new DateTime(2015, 3, 3), EmbarkDate = new DateTime(2015, 3, 2) };
            voyageList.Add(voyage);
            ws.AssignVoyageList(voyageList);

            ////this.repository = new Mock<IRepository>();
            ////this.embarkationStatisticsRepositoryMock = new Mock<EmbarkationStatisticsRepository>();
            this.personServiceRepositoryMock = new Mock<PersonServiceRepository>();
            this.referenceDataRepositoryMock = new Mock<ReferenceDataRepository>();
            ////this.photoCaptureRepositoryMock = new Mock<PhotoCaptureRepository>();
            ////this.shipTimeRepositoryMock = new Mock<ShipTimeRepository>();
            ////this.referenceDataRepositoryMock = new Mock<ReferenceDataRepository>();
            ////this.gangwayEventRepositoryMock = new Mock<GangwayEventRepository>();
            ////this.guestClient = new Mock<IGuestClient>();
            ////this.personClient = new Mock<IPersonsClient>();
            ////DIContainer.Instance.RegisterInstance<IGuestClient>(this.guestClient.Object);
            ////DIContainer.Instance.RegisterInstance<IPersonsClient>(this.personClient.Object);

            ////DIContainer.Instance.RegisterInstance<IRepository>(this.repository.Object);
            DIContainer.Instance.RegisterInstance<ReferenceDataRepository>(this.referenceDataRepositoryMock.Object);
            ////DIContainer.Instance.RegisterInstance<EmbarkationStatisticsRepository>(this.embarkationStatisticsRepositoryMock.Object);
            ////DIContainer.Instance.RegisterInstance<GangwayEventRepository>(this.gangwayEventRepositoryMock.Object);
            ////DIContainer.Instance.RegisterInstance<PhotoCaptureRepository>(this.photoCaptureRepositoryMock.Object);
            DIContainer.Instance.RegisterInstance<PersonServiceRepository>(this.personServiceRepositoryMock.Object);
            ////DIContainer.Instance.RegisterInstance<ShipTimeRepository>(this.shipTimeRepositoryMock.Object);

            var cruiseDetails = new GuestCruiseDetail { BeaconId = string.Empty, BerthNumber = string.Empty, IdentificationId = string.Empty, LoyaltyLevelTypeId = string.Empty, ReservationId = string.Empty, Stateroom = "0000" };
            var personDetail = new PersonalDetail { CitizenshipCountryId = string.Empty, FirstName = string.Empty, LastName = string.Empty, MiddleName = string.Empty, Title = string.Empty, PreferredName = string.Empty, MaritalStatus = string.Empty, Nickname = string.Empty, Occupation = string.Empty, DocumentNumber = string.Empty, Suffix = string.Empty, DocumentTypeId = "1" };

            this.person = new Person { TotalResults = 1 };
            CrewmemberCollection crewMembers = new CrewmemberCollection();
            crewMembers.Add(new Crewmember { CrewmemberId = string.Empty, CrewmemberTypeId = "1", SecurityPhotoAddress = string.Empty, ChargeId = string.Empty, EmployeeNo = string.Empty, LastEvent = string.Empty, PersonalDetail = personDetail });
            person.AssignCrewmembers(crewMembers);

            GuestCollection guests = new GuestCollection();
            var checkInDetail = new CheckInDetail
            {
                ApplicationId = string.Empty,
                LocationId = "1",
                LocationTypeId = "1",
                MachineName = "Machine",
                Station = "station",
                UserId = "user"
            };
            var cruiseDetail = new GuestCruiseDetail
            {
                BeaconId = string.Empty,
                CheckInDetail = checkInDetail,
                LoyaltyLevelTypeId = "1",
                ReservationId = "1",
                Stateroom = "00000",
                ReservationStatusId = "0000089",
                StateroomCategoryTypeId = "aaasad"
            };
            guests.Add(new Guest
            {
                GuestId = "0001",
                PersonalDetail = personDetail,
                Age = 0,
                CruiseDetail = cruiseDetail,
                SecurityPhotoAddress = string.Empty,
            });

            VisitorCollection visitors = new VisitorCollection();
            visitors.Add(new Visitor
            {
                VisitorId = "0003",
                PersonalDetail = personDetail,
                SecurityPhotoAddress = string.Empty,
            });
            this.person.AssignGuests(guests);
            this.person.AssignVisitors(visitors);
            this.personTypes = new List<PersonType>();
            personTypes.Add(PersonType.Guest);
            this.personServiceRepositoryMock.Setup(data => data.RetrievePersonsBySearchText(It.IsNotNull<string>(), It.IsAny<string>(), It.IsAny<IList<PersonType>>(), It.IsAny<SearchType>(), It.IsAny<string>(), It.IsAny<string>(), 0, 0, It.IsAny<string>(), It.IsAny<string>())).Returns(Task.FromResult(this.person));
            var documentTypes = new DocumentTypeCollection();
            documentTypes.Add(new DocumentType { CountryId = "232", Code = "USA", DocumentTypeId = "1", Name = "Passport" });
            var referencedata = new ReferenceData();
            referencedata.AssignDocumentTypes(documentTypes);
            this.referenceDataRepositoryMock.Setup(data => data.RetrieveReferenceDataAsync()).Returns(Task.FromResult(referencedata));
            ////this.personClient.Setup(data => data.RetrievePersonsAsync("5", "ab", null, null, "0001", null, null, "Guest", null, null, null, null, null, 0, 0)).Returns(RetrieveData());
        }
Exemple #39
0
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: @Override public java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(com.opengamma.strata.basics.CalculationTarget target, java.util.Set<com.opengamma.strata.calc.Measure> measures, CalculationParameters parameters, com.opengamma.strata.data.scenario.ScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData)
        public IDictionary <Measure, Result <object> > calculate(CalculationTarget target, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData marketData, ReferenceData refData)
        {
            throw new System.InvalidOperationException(Messages.format("No function configured for measures {} on '{}'", measures, target.GetType().Name));
        }
        /// <summary>
        /// Initializes a new instance of the GangwaySettingsUserControl class.
        /// </summary>
        /// <param name="referenceData">The reference data.</param>
        /// <param name="isRedirectedForcefullyToSaveSettings">if set to <c>true</c> [is redirected to save settings].</param>
        public GangwaySettingsUserControl(ReferenceData referenceData, bool isRedirectedForcefullyToSaveSettings)
        {
            this.InitializeComponent();

            this.DataContext = new GangwaySettingsUserControlViewModel(referenceData, isRedirectedForcefullyToSaveSettings);
        }
Exemple #41
0
 public NodalCurveDefinition filtered(LocalDate valuationDate, ReferenceData refData)
 {
     return(curveWithoutFixingDefinition.filtered(valuationDate, refData));
 }
Exemple #42
0
        /// <summary>
        /// Shows the gangway settings.
        /// </summary>
        /// <param name="data">The tuple of reference data and is redirection to gangway setting forcefully done.</param>
        private void ShowGangwaySettings(Tuple<ReferenceData, bool> data)
        {
            if (data.Item2)
            {
                // Sets the variable.
                this.workstation.IsUserRedirectedToGangwaySettingForcefully = true;
                this.ResetFlowDirection();
            }

            this.referenceData = data.Item1 != null ? data.Item1 : this.referenceData;
            this.gangwaySettingsUserControl = new GangwaySettingsUserControl(this.referenceData, data.Item2);

            this.ShowViewOnShell(ViewType.GangwaySettings);
        }
        //-------------------------------------------------------------------------
        public ResolvedIborFutureOption resolve(ReferenceData refData)
        {
            ResolvedIborFuture resolved = underlyingFuture.resolve(refData);

            return(new ResolvedIborFutureOption(securityId, putCall, strikePrice, Expiry, premiumStyle, rounding, resolved));
        }