//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void test2() public virtual void test2() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray x = com.opengamma.strata.collect.array.DoubleArray.of(1.3423, 0.235); DoubleArray x = DoubleArray.of(1.3423, 0.235); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleMatrix anJac = G2.apply(x); DoubleMatrix anJac = G2.apply(x); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleMatrix fdFwdJac = FORWARD.differentiate(F2).apply(x); DoubleMatrix fdFwdJac = FORWARD.differentiate(F2).apply(x); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleMatrix fdCentGrad = CENTRAL.differentiate(F2).apply(x); DoubleMatrix fdCentGrad = CENTRAL.differentiate(F2).apply(x); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleMatrix fdBackGrad = BACKWARD.differentiate(F2).apply(x); DoubleMatrix fdBackGrad = BACKWARD.differentiate(F2).apply(x); for (int i = 0; i < 3; i++) { for (int j = 0; j < 2; j++) { assertEquals(fdFwdJac.get(i, j), anJac.get(i, j), 10 * EPS); assertEquals(fdCentGrad.get(i, j), anJac.get(i, j), 10 * EPS * EPS); assertEquals(fdBackGrad.get(i, j), anJac.get(i, j), 10 * EPS); } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void test() public virtual void test() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray x = com.opengamma.strata.collect.array.DoubleArray.of(.2245, -1.2344); DoubleArray x = DoubleArray.of(.2245, -1.2344); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray anGrad = G.apply(x); DoubleArray anGrad = G.apply(x); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray fdFwdGrad = FORWARD.differentiate(F).apply(x); DoubleArray fdFwdGrad = FORWARD.differentiate(F).apply(x); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray fdCentGrad = CENTRAL.differentiate(F).apply(x); DoubleArray fdCentGrad = CENTRAL.differentiate(F).apply(x); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray fdBackGrad = BACKWARD.differentiate(F).apply(x); DoubleArray fdBackGrad = BACKWARD.differentiate(F).apply(x); for (int i = 0; i < 2; i++) { assertEquals(fdFwdGrad.get(i), anGrad.get(i), 10 * EPS); assertEquals(fdCentGrad.get(i), anGrad.get(i), EPS * EPS); assertEquals(fdBackGrad.get(i), anGrad.get(i), 10 * EPS); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testNormal() public virtual void testNormal() { assertEquals(SAMPLE_VARIANCE.apply(NORMAL_DATA), STD * STD, EPS); assertEquals(POPULATION_VARIANCE.apply(NORMAL_DATA), STD * STD, EPS); assertEquals(SAMPLE_STD.apply(NORMAL_DATA), STD, EPS); assertEquals(POPULATION_STD.apply(NORMAL_DATA), STD, EPS); assertEquals(SAMPLE_SKEWNESS.apply(NORMAL_DATA), 0.0, EPS); assertEquals(SAMPLE_FISHER_KURTOSIS.apply(NORMAL_DATA), 0.0, EPS); }
//------------------------------------------------------------------------- private double[] bracketRoot(double optionPrice, double sigma) { BracketRoot bracketer = new BracketRoot(); System.Func <double, double> func = (double?volatility) => { return(priceFunc.apply(volatility) / optionPrice - 1.0); }; return(bracketer.getBracketedPoints(func, Math.Max(0.0, sigma - BRACKET_STEP), sigma + BRACKET_STEP, 0d, double.PositiveInfinity)); }
public override IEnumerable <string> KeySet() { IList <string> keys = SizeConflict >= 0 ? new List <string>(SizeConflict) : new List <string>(); Foreach((key, value) => { if (Filter.apply(key, value)) { keys.Add(key); } }); return(keys); }
private string GetName(Element procedure) { T annotation = procedure.getAnnotation(_annotationType); Optional <string> customName = _customNameExtractor.apply(annotation); return(customName.orElse(DefaultQualifiedName(procedure))); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: protected void assertYieldCurveBootstrap(final com.opengamma.strata.math.impl.rootfinding.VectorRootFinder rootFinder, final double eps) protected internal virtual void assertYieldCurveBootstrap(VectorRootFinder rootFinder, double eps) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int n = TIME_GRID.length; int n = TIME_GRID.Length; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double[] flatCurve = new double[n]; double[] flatCurve = new double[n]; for (int i = 0; i < n; i++) { flatCurve[i] = 0.05; } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray x0 = com.opengamma.strata.collect.array.DoubleArray.copyOf(flatCurve); DoubleArray x0 = DoubleArray.copyOf(flatCurve); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray x1 = rootFinder.getRoot(SWAP_RATES, x0); DoubleArray x1 = rootFinder.getRoot(SWAP_RATES, x0); for (int i = 0; i < n; i++) { assertEquals(-Math.Log(DUMMY_YIELD_CURVE.apply(TIME_GRID[i])) / TIME_GRID[i], x1.get(i), eps); } }
public CurrencyParameterSensitivities sensitivities(T trade, RatesProvider provider) { PointSensitivities pts = sensitivityFn.apply(trade, provider); CurrencyParameterSensitivities ps = provider.parameterSensitivity(pts); return(MQC.sensitivity(ps, provider)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void test() public virtual void test() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double x = RANDOM.nextDouble(); double x = RANDOM.NextDouble(); assertEquals(Math.Log(GAMMA.applyAsDouble(x)), LN_GAMMA.apply(x), EPS); }
/// <summary> /// {@inheritDoc} /// The inverse cdf is given by: /// $$ /// \begin{align*} /// F(P) &= \mathrm{sign}(p - \frac{1}{2})\sqrt{\frac{\nu}{x - 1}}\\ /// x &= B(2 \min(p, 1-p)) /// \end{align*} /// $$ /// where $B$ is the inverse incomplete Beta function (<seealso cref="InverseIncompleteBetaFunction"/>). /// </summary> public virtual double getInverseCDF(double?p) { ArgChecker.notNull(p, "p"); ArgChecker.isTrue(p >= 0 && p <= 1, "Probability must be >= 0 and <= 1"); double x = _beta.apply(2 * Math.Min(p, 1 - p)); return(Math.Sign(p - 0.5) * Math.Sqrt(_degFreedom * (1.0 / x - 1))); }
public override bool Process <T1>(ISet <T1> annotations, RoundEnvironment roundEnv) where T1 : javax.lang.model.element.TypeElement { ProcessElements(roundEnv); if (roundEnv.processingOver()) { _duplicationValidator.apply(_visitedElements).forEach(_messagePrinter.print); } return(false); }
//------------------------------------------------------------------------- public virtual void test_values() { ParameterizedFunctionalCurve test = ParameterizedFunctionalCurve.of(METADATA, PARAMETERS, VALUE_FUNCTION, DERIVATIVE_FUNCTION, SENSITIVITY_FUNCTION); double x = 5.2; assertEquals(test.yValue(x), VALUE_FUNCTION.apply(PARAMETERS, x)); assertEquals(test.firstDerivative(x), DERIVATIVE_FUNCTION.apply(PARAMETERS, x)); assertEquals(test.yValueParameterSensitivity(x), UnitParameterSensitivity.of(METADATA.CurveName, METADATA.ParameterMetadata.get(), SENSITIVITY_FUNCTION.apply(PARAMETERS, x))); }
internal override Value AsValue(GenericKey state) { T[] array = _arrayCreator.apply(state.ArrayLength); for (int i = 0; i < state.ArrayLength; i++) { array[i] = _valueFactory.from(state, i); } return(Values.of(array)); }
public override void Init(ProcessingEnvironment processingEnv) { lock (this) { base.Init(processingEnv); _messagePrinter = new MessagePrinter(processingEnv.Messager); _duplicationValidator = new DuplicatedExtensionValidator <ICollection <Element>, Stream <CompilationMessage> >(processingEnv.ElementUtils, _supportedAnnotationType, _customNameFunction); _visitor = _visitorSupplier.apply(processingEnv); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void test() public virtual void test() { double a = 2.3; double theta = 0.34; DoubleArray x = DoubleArray.of(a, theta); VectorFieldSecondOrderDifferentiator fd = new VectorFieldSecondOrderDifferentiator(); System.Func <DoubleArray, DoubleMatrix[]> fdFuncs = fd.differentiate(FUNC); DoubleMatrix[] fdValues = fdFuncs(x); DoubleMatrix t1 = DW1.apply(x); DoubleMatrix t2 = DW2.apply(x); for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { assertEquals("first observation " + i + " " + j, t1.get(i, j), fdValues[0].get(i, j), 1e-6); assertEquals("second observation " + i + " " + j, t2.get(i, j), fdValues[1].get(i, j), 1e-6); } } }
public virtual ProtocolSelection <U, T> GetAll(Org.Neo4j.causalclustering.protocol.Protocol_Category <T> category, ICollection <U> versions) { //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: ISet <U> selectedVersions = _protocolMap.SetOfKeyValuePairs().Select(DictionaryEntry.getKey).Where(pair => pair.first().Equals(category.CanonicalName())).Select(Pair::other).Where(version => versions.Count == 0 || versions.Contains(version)).collect(Collectors.toSet()); if (selectedVersions.Count == 0) { throw new System.ArgumentException(string.Format("Attempted to select protocols for {0} versions {1} but no match in known protocols {2}", category, versions, _protocolMap)); } else { return(_protocolSelectionFactory.apply(category.CanonicalName(), selectedVersions)); } }
public override double?apply(double[] x) { ArgChecker.notNull(x, "x"); ArgChecker.isTrue(x.Length >= 3, "Need at least three points to calculate sample skewness"); double sum = 0; double variance = 0; double mean = MEAN.apply(x); foreach (double d in x) { double diff = d - mean; variance += diff * diff; sum += diff * diff * diff; } int n = x.Length; variance /= n - 1; return(Math.Sqrt(n - 1.0) * sum / (Math.Pow(variance, 1.5) * Math.Sqrt(n) * (n - 2))); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public java.util.Optional<org.neo4j.internal.kernel.api.procs.DefaultParameterValue> defaultValue(org.neo4j.procedure.Name parameter) throws org.neo4j.internal.kernel.api.exceptions.ProcedureException public Optional <DefaultParameterValue> DefaultValue(Name parameter) { string defaultValue = parameter.defaultValue(); if (defaultValue.Equals(Name.DEFAULT_VALUE)) { return(null); } else { try { return(Parser.apply(defaultValue)); } catch (Exception) { throw new ProcedureException(Org.Neo4j.Kernel.Api.Exceptions.Status_Procedure.ProcedureRegistrationFailed, "Default value `%s` could not be parsed as a %s", parameter.defaultValue(), JavaClass.Name); } } }
public virtual Stream <CompilationMessage> ValidateName(ExecutableElement method) { Optional <string> customName = _customNameExtractor.apply(method.getAnnotation(_annotationType)); if (customName.Present) { if (IsInRootNamespace(customName.get())) { return(Stream.of(RootNamespaceError(method, customName.get()))); } return(Stream.empty()); } PackageElement @namespace = _elements.getPackageOf(method); if (@namespace == null) { return(Stream.of(RootNamespaceError(method))); } return(Stream.empty()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void test() public virtual void test() { System.Func <DoubleArray, DoubleMatrix[]> analDiffFunc = DIFF.differentiate(F); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray x = com.opengamma.strata.collect.array.DoubleArray.of(1.3423, 0.235); DoubleArray x = DoubleArray.of(1.3423, 0.235); DoubleMatrix[] alRes = analDiffFunc(x); DoubleMatrix[] fdRes = G.apply(x); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int p = fdRes.length; int p = fdRes.Length; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int n = fdRes[0].rowCount(); int n = fdRes[0].rowCount(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int m = fdRes[0].columnCount(); int m = fdRes[0].columnCount(); assertEquals(p, alRes.Length); assertEquals(n, alRes[0].rowCount()); assertEquals(m, alRes[0].columnCount()); for (int k = 0; k < p; k++) { for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { assertEquals(fdRes[k].get(i, j), alRes[k].get(i, j), 1e-8); } } } }
public override double?apply(double[] x) { ArgChecker.notNull(x, "x"); ArgChecker.isTrue(x.Length >= 2, "Need at least two points to calculate standard deviation"); return(Math.Sqrt(VARIANCE.apply(x))); }
internal virtual string Describe() { return(Descriptor.apply(Entity)); }
public virtual void AvailableMember(MemberIsAvailable memberIsAvailable) { AvailableMembers = asList(NextSnapshotFunction.apply(AvailableMembers, memberIsAvailable)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testLimits() public virtual void testLimits() { assertEquals(FUNCTION.apply(0.0), 0, EPS); assertEquals(FUNCTION.apply(100.0), 1, EPS); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testNullArray() public virtual void testNullArray() { GEOMETRIC.apply(null); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void test() public virtual void test() { assertEquals(GEOMETRIC.apply(FLAT), 2, 0); assertEquals(GEOMETRIC.apply(X), Math.Exp(ARITHMETIC.apply(LN_X)), 1e-15); }
public override string Name() { return(_scopingRule.apply(ProvideName())); }
static GeneralizedLeastSquareTest() { SIN_FUNCTIONS = new List <>(); for (int i = 0; i < WEIGHTS.Length; i++) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int k = i; int k = i; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.function.Function<double, double> func = new java.util.function.Function<double, double>() System.Func <double, double> func = (final double?x) => { return(Math.Sin((2 * k + 1) * x)); }; SIN_FUNCTIONS.Add(func); } TEST_FUNCTION = new BasisFunctionAggregation <>(SIN_FUNCTIONS, WEIGHTS); VECTOR_TRIG_FUNCTIONS = new List <>(); for (int i = 0; i < WEIGHTS.Length; i++) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int k = i; int k = i; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.function.Function<com.opengamma.strata.collect.array.DoubleArray, double> func = new java.util.function.Function<com.opengamma.strata.collect.array.DoubleArray, double>() System.Func <DoubleArray, double> func = (final DoubleArray x) => { ArgChecker.isTrue(x.size() == 2); return(Math.Sin((2 * k + 1) * x.get(0)) * Math.Cos((2 * k + 1) * x.get(1))); }; VECTOR_TRIG_FUNCTIONS.Add(func); } VECTOR_TEST_FUNCTION = new BasisFunctionAggregation <>(VECTOR_TRIG_FUNCTIONS, WEIGHTS); SIN_EXP_FUNCTION = (final double[] x) => { return(Math.Sin(Math.PI * x[0] / 10.0) * Math.Exp(-x[1] / 5.0)); }; const int n = 10; X = new double?[n]; Y = new double[n]; SIGMA = new double[n]; X_TRIG = new List <>(); Y_TRIG = new List <>(); SIGMA_TRIG = new List <>(); for (int i = 0; i < n; i++) { X[i] = i / 5.0; Y[i] = TEST_FUNCTION.apply(X[i]); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double[] temp = new double[2]; double[] temp = new double[2]; temp[0] = 2.0 * RANDOM.NextDouble(); temp[1] = 2.0 * RANDOM.NextDouble(); X_TRIG.Add(DoubleArray.copyOf(temp)); Y_TRIG.Add(VECTOR_TEST_FUNCTION.apply(X_TRIG[i])); SIGMA[i] = 0.01; SIGMA_TRIG.Add(0.01); } SIGMA_COS_EXP = new List <>(); X_SIN_EXP = new List <>(); Y_SIN_EXP = new List <>(); for (int i = 0; i < 20; i++) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double[] temp = new double[2]; double[] temp = new double[2]; temp[0] = 10.0 * RANDOM.NextDouble(); temp[1] = 10.0 * RANDOM.NextDouble(); X_SIN_EXP.Add(temp); Y_SIN_EXP.Add(SIN_EXP_FUNCTION.apply(X_SIN_EXP[i])); SIGMA_COS_EXP.Add(0.01); } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.math.impl.interpolation.BasisFunctionGenerator generator = new com.opengamma.strata.math.impl.interpolation.BasisFunctionGenerator(); BasisFunctionGenerator generator = new BasisFunctionGenerator(); BASIS_FUNCTIONS = generator.generateSet(BasisFunctionKnots.fromUniform(0.0, 2.0, 20, 3)); BasisFunctionKnots[] knots = new BasisFunctionKnots[2]; knots[0] = BasisFunctionKnots.fromUniform(0, 10, 10, 3); knots[1] = BasisFunctionKnots.fromUniform(0, 10, 10, 3); BASIS_FUNCTIONS_2D = generator.generateSet(knots); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Override protected Logger getBulkLogger(@Nonnull PrintWriter out, @Nonnull Object lock) protected internal override Logger GetBulkLogger(PrintWriter @out, object @lock) { return(new FormattedLogger(_formattedLog, Suppliers.singleton(@out), _prefix, DateTimeFormatter, () => DefaultCurrentDateTime.apply(_formattedLog.zoneId))); }
/// <summary> /// Inserts a bunch of new nodes with the label and property key currently set in the fields in this class, where /// running this method twice will insert nodes with duplicate property values, assuming property key or label has /// not changed. /// </summary> //JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: //ORIGINAL LINE: private org.neo4j.test.OtherThreadExecutor.WorkerCommand<Object,int> performInserts(final HighlyAvailableGraphDatabase slave, final boolean constraintCompliant) private WorkerCommand <object, int> PerformInserts(HighlyAvailableGraphDatabase slave, bool constraintCompliant) { return(state => { int i = 0; try { for ( ; i < 100; i++) { using (Transaction tx = slave.BeginTx()) { ConstraintOps.createEntity(slave, _labelOrRelType, _property, ValueGenerator.apply(i), constraintCompliant); tx.success(); } } } catch (Exception e) when(e is TransactionFailureException || e is TransientTransactionFailureException || e is ComException || e is ConstraintViolationException) { // TransactionFailureException and TransientTransactionFailureException // Swallowed on purpose, we except it to fail sometimes due to either // - constraint violation on master // - concurrent schema operation on master // ConstraintViolationException // Constraint violation detected on slave while building transaction // ComException // Happens sometimes, cause: // - The lock session requested to start is already in use. // Please retry your request in a few seconds. } return i; }); }