public void BetweenTest() { AssertPasses(10.000000000000001D, ADouble.Between(10, 13)); AssertPasses(11D, ADouble.Between(10, 13)); AssertPasses(12.999999999999999D, ADouble.Between(10, 13)); AssertFails(13D, ADouble.Between(10, 13)); }
public static void ResultSetTestOnBlackScholes() { ADouble vol = 0.2; ADouble spot = 100.0; ADouble rate = 0.05; ADouble time = 0.0; ADouble mat = 1.0; ADouble strike = 90.0; ADouble[] parameters = new ADouble[] { vol, spot, rate, time, mat, strike }; //List<Ref<ADouble>> parameters = new List<Ref<ADouble>>(); //parameters.Add(new Ref<ADouble> { Value = vol }); //parameters.Add(new Ref<ADouble> { Value = spot }); //parameters.Add(new Ref<ADouble> { Value = rate }); //parameters.Add(new Ref<ADouble> { Value = time }); //parameters.Add(new Ref<ADouble> { Value = mat }); //parameters.Add(new Ref<ADouble> { Value = strike }); string[] identifiers = new string[] { "Vol", "Spot", "Rate", "Time0", "Mat", "Strike" }; AADTape.Initialize(parameters, identifiers); AADTestFunctions.BlackScholesNoReset(vol, spot, rate, time, mat, strike); AADTape.InterpretTape(); AADTape.PrintResultSet(); AADTape.PrintTape(); AADTape.ResetTape(); }
public static void GoalFunctionTest() { AADTape.ResetTape(); ADouble x1 = 10.0; List <ADouble> activeVariables = new List <ADouble>(); activeVariables.Add(x1); // Initialize tape with x1 and x2 AADTape.Initialize(activeVariables.ToArray()); // Compute the function value of f. Tape is now running ADouble result = AADTestFunctions.TestingPow(x1); // Once complete, interpret the tape AADTape.InterpretTape(); AADTape.PrintTape(); AADTape.ResetTape(); /////////// activeVariables = new List <ADouble>(); activeVariables.Add(x1); // Initialize tape with x1 and x2 AADTape.Initialize(activeVariables.ToArray()); // Compute the function value of f. Tape is now running ADouble result2 = AADTestFunctions.TestingPowInverse(x1); // Once complete, interpret the tape AADTape.InterpretTape(); AADTape.PrintTape(); }
public void ReportIsCorrectlyGeneratedTest() { PerformanceMetricsWriter metricsWriter; PerformanceReport report; Scenario() .Given(metricsWriter = PerformanceMetricsWriter.With().TestName("ReportIsCorrectlyGeneratedTest")) .When(PerformanceSuite.With() .NumRuns(2) .PerRunTimeout(20).Seconds() .LoadRunner(ContentionLoadRunner.With() .Tests(new MyPerfTest()) .RunTimeout(15).Seconds()) .Listener(metricsWriter) .Build()) .When(report = metricsWriter.BuildReport()) .When(report.PrintToConsole) .Then( Expect(report.GetMetricSummaryNamed("metric1").ValueMean), Is(ADouble.EqualTo(4.75))) .Then( Expect(report.GetMetricSummaryNamed("metric1").ValueMedian), Is(ADouble.EqualTo(5))) .Then( Expect(report.GetMetricSummaryNamed("metric1").ValueMax), Is(ADouble.EqualTo(10))) .Then( Expect(report.GetMetricSummaryNamed("metric1").ValueMin), Is(ADouble.EqualTo(0))) .Then( Expect(report.GetMetricSummaryNamed("metric1").MetricName), Is(AString.EqualTo("metric1"))); }
public void BetweenIncludingTest() { AssertFails(9.999999999999999D, ADouble.BetweenIncluding(10, 13)); AssertPasses(10D, ADouble.BetweenIncluding(10, 13)); AssertPasses(11D, ADouble.BetweenIncluding(10, 13)); AssertPasses(12D, ADouble.BetweenIncluding(10, 13)); AssertPasses(13D, ADouble.BetweenIncluding(10, 13)); AssertFails(13.000000000000001D, ADouble.BetweenIncluding(10, 13)); }
public static void CalculateDerivativesByAd() { Console.Title = "AD Example."; ADouble x1 = 10.0; ADouble x2 = 2.0; List <ADouble> activeVariables = new List <ADouble>(); activeVariables.Add(x1); activeVariables.Add(x2); string[] identifiers = new string[] { "x1", "x2" }; // Initialize tape with x1 and x2 AADTape.Initialize(activeVariables.ToArray(), identifiers); // Compute the function value of f. Tape is now running ADouble result = AADTestFunctions.ExampleFunctionThesis(x1, x2); // Once complete, interpret the tape AADTape.InterpretTape(); AADTape.PrintTape(); var gradient = AADTape.GetGradient(); }
public ATestDto MyPrimDoubleProp(double expect) { MyPrimDoubleProp(ADouble.EqualTo(expect)); return(this); }
public void LessThanTest() { AssertPasses(9D, ADouble.LessThan(10)); AssertPasses(9.999999999999999D, ADouble.LessThan(10)); AssertFails(10D, ADouble.LessThan(10)); }
public void NotTest() { AssertPasses(9.999999999999999D, ADouble.Not(10)); AssertFails(10D, ADouble.Not(10)); AssertPasses(10.000000000000001D, ADouble.Not(10)); }
public void NullTest() { AssertPasses(null, ADouble.Null()); AssertFails(10D, ADouble.Null()); }
public void EqualToTestMin() { AssertPasses(double.MinValue, ADouble.EqualTo(double.MinValue)); AssertFails(double.MinValue + 0.000000000000001D, ADouble.EqualTo(double.MaxValue)); }
public void EqualToTest() { AssertFails(4.999999999999999D, ADouble.EqualTo(5)); AssertPasses(5D, ADouble.EqualTo(5)); AssertFails(5.000000000000001D, ADouble.EqualTo(5)); }
public void EqualToNull() { AssertPasses(null, ADouble.EqualTo(null)); AssertFails(null, ADouble.EqualTo(1D)); AssertFails(1D, ADouble.EqualTo(null)); }
public ATestDto MyNullDoublePropNull() { MyNullDoubleProp(ADouble.Null()); return(this); }
public void EqualToTestMax() { AssertFails(1.797689999999e+308, ADouble.EqualTo(double.MaxValue)); AssertPasses(double.MaxValue, ADouble.EqualTo(double.MaxValue)); }
public void GreaterOrEqualToTest() { AssertFails(0.999999999999999D, ADouble.GreaterOrEqualTo(1)); AssertPasses(1D, ADouble.GreaterOrEqualTo(1)); AssertPasses(1.000000000000001D, ADouble.GreaterOrEqualTo(1)); }
public void GreaterThanTest() { AssertFails(10D, ADouble.GreaterThan(10)); AssertPasses(10.000000000000001D, ADouble.GreaterThan(10)); }
public void LessThanOrEqualToTest() { AssertPasses(9D, ADouble.LessThanOrEqualTo(10)); AssertPasses(10D, ADouble.LessThanOrEqualTo(10)); AssertFails(10.000000000000001D, ADouble.LessThanOrEqualTo(10)); }
public ATestDto MyNullDoubleProp(double?expect) { MyNullDoubleProp(ADouble.EqualTo(expect)); return(this); }