public void CheckZeroVolForward(AssetMarket assetMkt)
{
var zcCurve = assetMkt.RiskFreeDiscount;
var market = new Market(new[] { zcCurve }, new[] { assetMkt });
var zeroVol = new MapRawDatas <DateOrDuration, double>(new[] { new DateOrDuration(assetMkt.RefDate) }, new[] { 0.0 });
var blackScholesDesc = new BlackScholesModelDescription(assetMkt.Asset.Name, zeroVol, true);
var mcConfig = new MonteCarloConfig(1, RandomGenerators.GaussianSobol(SobolDirection.Kuo3));
var blackScholesModel = ModelFactory.Instance.Build(blackScholesDesc, market);
var fwdDates = new[] { Duration.Month, 6 * Duration.Month, Duration.Year, 2 * Duration.Year, 5 * Duration.Year }
.Map(d => assetMkt.RefDate + d);
IProduct fwdLeg = ForwardLeg(fwdDates);
PriceResult priceResult = (PriceResult)McPricer.WithDetails(mcConfig).Price(fwdLeg, blackScholesModel, market);
double[] fwds = priceResult.Details.Map(kv => kv.Item3.Value);
var assetFwdCurve = assetMkt.Forward();
double[] refFwds = fwdDates.Map(d => assetFwdCurve.Fwd(d) * zcCurve.Zc(d));
foreach (var i in Enumerable.Range(0, fwdDates.Length))
{
var err = Math.Abs(fwds[i] / refFwds[i] - 1.0);
Assert.LessOrEqual(err, 20.0 * DoubleUtils.MachineEpsilon);
}
}
public void Test()
{
var market = Market();
const double lambda = 0.01;
var sigma = new StepFunction(new[] { 0.0, 1.0, 2.0 }, new[] { 0.007, 0.004, 0.0065 }, 0.0);
var hw1 = new Hw1Model(TimeMeasure.Act365(market.RefDate), Currency.Eur, lambda, sigma);
var mcConfig = new MonteCarloConfig(20000,
RandomGenerators.GaussianSobol(SobolDirection.JoeKuoD5));
var mcPricer = McPricer.WithDetails(mcConfig);
var fixedLeg = FixedLeg(market.RefDate);
var mcPriceResult = (PriceResult)mcPricer.Price(fixedLeg, hw1, market);
var mcCoupons = mcPriceResult.Details.Map(p => p.Item3.Value);
var refCoupons = mcPriceResult.Details.Map(pi => market.DiscountCurve(pi.Item2.Financing).Zc(pi.Item2.Date));
var errAbs = Math.Abs(mcCoupons.Sum() - refCoupons.Sum());
Assert.LessOrEqual(errAbs, 7.0e-5);
var errRel = Math.Abs(mcCoupons.Sum() / refCoupons.Sum() - 1.0);
Assert.LessOrEqual(errRel, 8.0e-6);
}
public void Should_Generate_Random_64_Bit_Number()
{
var rg = new RandomGenerators();
var number64Bit = rg.GenerateRandom64BitNumberFromByteLength(32);
Assert.IsTrue(number64Bit > 0);
Assert.IsTrue(number64Bit.ToString().Length < 20);
}
public void Should_Generate_Random_32_Bit_Number()
{
var rg = new RandomGenerators();
var number32Bit = rg.GenerateRandom32BitNumberFromByteLength(16);
Assert.IsTrue(number32Bit > 0);
Assert.IsTrue(number32Bit.ToString().Length < 11);
}
public void Should_Generate_256Bit_Hexadecimal_String()
{
var rg = new RandomGenerators();
var str = rg.Generate256BitKey();
Assert.IsNotNull(str);
Assert.IsTrue(str.Length == 64);
}
public void Should_Generate_Random_Bytes()
{
var rg = new RandomGenerators();
var bytesContainer = new byte[32];
rg.GenerateRandomBytes(bytesContainer);
Assert.IsTrue(bytesContainer.Length == 32);
}
public void Should_Generate_Random_Hexadecimal_String_From_Byte_Array_Length()
{
var rg = new RandomGenerators();
const int byteLength = 4;
var hexString = rg.GenerateHexKeyFromByteLength(byteLength);
Assert.IsNotNull(hexString);
Assert.IsTrue(hexString.Length == byteLength * 2);
}
private static MonteCarloConfig BuildMonteCarloConfig(object[,] bag)
{
int nbPaths = bag.ProcessScalarInteger("NbPaths");
Duration mcStep = bag.Has("McStep") ? bag.ProcessScalarDateOrDuration("McStep").Duration : null;
//TODO investigate which generator is the best
var randomGenerator = RandomGenerators.GaussianSobol(SobolDirection.Kuo3);
return(new MonteCarloConfig(nbPaths, randomGenerator, mcStep));
}
public void HashPassword_Should_Return_Success_And_PasswordHashingData_Object()
{
var rg = new RandomGenerators();
var phs = new PasswordHashingSvc(rg.Generate512BitKey());
const string password = "******";
var hashed = phs.HashPassword(password);
Assert.IsTrue(hashed.IsSuccessful);
Assert.AreEqual(hashed.Value.HashedPassword.Length, 128);
}
public void HashPassword_Should_Return_Different_HashedValues_For_The_Same_Value_Computed_Twice()
{
var rg = new RandomGenerators();
var phs = new PasswordHashingSvc(rg.Generate512BitKey());
const string password = "******";
var hashedResult1 = phs.HashPassword(password);
var hashedResult2 = phs.HashPassword(password);
Assert.AreNotEqual(hashedResult1.Value.HashedPassword, hashedResult2.Value.HashedPassword);
}
public void TestCallBachelier(int dim, SobolDirection direction)
{
var gaussianGen = RandomGenerators.GaussianSobol(direction).Build(dim);
var chrono = new Stopwatch();
chrono.Start();
var atmCalls = new double[dim];
var strikeCall1 = new double[dim];
var strikeCall2 = new double[dim];
var strikePut1 = new double[dim];
var strikePut2 = new double[dim];
const int nbPaths = 1000000;
for (int index = 0; index < nbPaths; index++)
{
var sample = gaussianGen.Next();
for (int i = 0; i < dim; i++)
{
var gaussian = sample[i];
atmCalls[i] += Math.Max(0.0, gaussian);
strikeCall1[i] += Math.Max(0.0, gaussian - 1.0);
strikeCall2[i] += Math.Max(0.0, gaussian - 2.0);
strikePut1[i] += Math.Max(0.0, -1.0 - gaussian);
strikePut2[i] += Math.Max(0.0, -2.0 - gaussian);
}
}
for (int i = 0; i < dim; i++)
{
atmCalls[i] /= nbPaths;
strikeCall1[i] /= nbPaths;
strikeCall2[i] /= nbPaths;
strikePut1[i] /= nbPaths;
strikePut2[i] /= nbPaths;
}
chrono.Stop();
Console.WriteLine("Elapsed " + chrono.Elapsed);
var refAtmCalls = atmCalls.Select(c => BachelierOption.Price(0.0, 0.0, 1.0, 1.0, 1)).ToArray();
var refStrikeCall1 = atmCalls.Select(c => BachelierOption.Price(0.0, 1.0, 1.0, 1.0, 1)).ToArray();
var refStrikeCall2 = atmCalls.Select(c => BachelierOption.Price(0.0, 2.0, 1.0, 1.0, 1)).ToArray();
var refStrikePut1 = atmCalls.Select(c => BachelierOption.Price(0.0, -1.0, 1.0, 1.0, -1)).ToArray();
var refStrikePut2 = atmCalls.Select(c => BachelierOption.Price(0.0, -2.0, 1.0, 1.0, -1)).ToArray();
UnitTestUtils.EqualDoubleArray(atmCalls, refAtmCalls, 2.0e-5, true);
UnitTestUtils.EqualDoubleArray(strikeCall1, refStrikeCall1, 8.0e-5, true);
UnitTestUtils.EqualDoubleArray(strikeCall2, refStrikeCall2, 6.0e-4, true);
UnitTestUtils.EqualDoubleArray(strikePut1, refStrikePut1, 8.0e-5, true);
UnitTestUtils.EqualDoubleArray(strikePut2, refStrikePut2, 6.0e-4, true);
}
public static void Main(string[] args)
{
RandomGenerators r = new RandomGenerators(125);
for (int i = 0; i < 50; i++)
{
Console.WriteLine("lcg: " + r.next_LCG());
Console.WriteLine("bbs: " + r.next_BlumBlumShub());
Console.WriteLine("mwc: " + r.next_MWC());
Console.WriteLine("xor: " + r.next_xorshift());
Console.WriteLine("***********");
}
}
public void ComputePasswordAndSaltBytes_Should_Generate_Sha512_ByteArray()
{
var rg = new RandomGenerators();
var phs = new PasswordHashingSvc(rg.Generate512BitKey());
var salt = new byte[32];
rg.GenerateRandomBytes(salt);
var rand = new Random();
var computeResult = phs.ComputePasswordAndSaltBytes(salt, "my password 1234 #*@", rand.Next(8200, 14000));
Assert.IsTrue(computeResult.IsSuccessful);
Assert.AreEqual(computeResult.Value.Length, 64);
}
public UsersSeed()
{
Moderators = new List<User>();
Advisers = new List<User>();
Teachers = new List<User>();
Students = new List<User>();
rand = new Random();
Generator = new UserGameDetailsGenerator();
RandomGenerator = new RandomGenerators();
experience = 0;
level = 0;
firstName = "";
lastName = "";
}
public static async Task CreateMockAccount()
{
try
{
var locator = RandomGenerators.GetRandomString(5);
var secret = RandomGenerators.GetRandomString(5);
var invitation = RandomGenerators.GetRandomString(5);
_authenticator = await Authenticator.CreateAccountAsync(locator, secret, invitation);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw ex;
}
}
async Task StartOrJoinSession()
{
_activeUser = new User {
Id = RandomGenerators.GenerateRandomId(), Name = _userName
};
var request = new StartJoinSessionRequest {
SessionId = SessionId, User = _activeUser
};
//Call Start Or Join
var session = await Http.PostJsonAsync <Session>("Session/startOrJoin", request);
var action = new LoadSessionAction(_activeUser, session);
Dispatcher.Dispatch(action);
NavManager.NavigateTo($"/activeSession/{SessionState.Value.Session.Id}");
}
public void Should_Generate_Random_Base64_String_From_Byte_Array_Length()
{
var rg = new RandomGenerators();
const int byteLength = 32;
var base64String = rg.GenerateBase64KeyFromByteLength(byteLength);
bool isBase64;
byte[] fromBase64String;
try
{
fromBase64String = Convert.FromBase64String(base64String);
isBase64 = true;
}
catch (Exception)
{
isBase64 = false;
fromBase64String = null;
}
Assert.IsNotNull(base64String);
Assert.IsTrue(isBase64);
Assert.IsNotNull(fromBase64String);
}
public IParamsView CreateView(RandomGenerators.Params.IRandomNetGenParamMgr mgr)
{
return new RandomNetGenParamsCtrl(mgr.ParentId, mgr.Bag as RandomGenerators.Params.IRandomNetGenParamBag);
}
