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