public void DifferentTypes()
{
var poly3 = KtPolynomial.Create(2, 1);
Term term1 = poly3;
var poly1 = KtPolynomial.Create(3, 5, 2, 5);
var poly2 = KtPolynomial.Create(3, 12, -2);
Term term2 = new DiscontinuousTerm(poly1, poly2, Limit.Create(-12, 20));
var actualResult = term1 - term2;
Assert.AreEqual(actualResult.Length, 3);
Term expectedResult1 = new DiscontinuousTerm(poly3, KtPolynomial.Create(1), ForwardLimit.Create(-12));
Assert.AreEqual(actualResult[0], expectedResult1);
Term expectedResult2 = new DiscontinuousTerm((poly3 * poly2) - poly1, poly2, Limit.Create(-12, 20));
Assert.AreEqual(actualResult[1], expectedResult2);
Term expectedResult3 = new DiscontinuousTerm(poly3, KtPolynomial.Create(1), BackwardLimit.Create(20));
Assert.AreEqual(actualResult[2], expectedResult3);
actualResult = term2 - term1; //reversed
Assert.AreEqual(actualResult.Length, 3);
expectedResult1 = new DiscontinuousTerm(-poly3, KtPolynomial.Create(1), ForwardLimit.Create(-12));
Assert.AreEqual(actualResult[0], expectedResult1);
expectedResult2 = new DiscontinuousTerm(poly1 - (poly3 * poly2), poly2, Limit.Create(-12, 20));
Assert.AreEqual(actualResult[1], expectedResult2);
expectedResult3 = new DiscontinuousTerm(-poly3, KtPolynomial.Create(1), BackwardLimit.Create(20));
Assert.AreEqual(actualResult[2], expectedResult3);
}
private static Limit GetLimit(LimitType limitType, FeatureType featureType)
{
var limit = Limit.Create(limitType, featureType);
limit.AddCycles(GetCycles());
return(limit);
}
public async Task AddNewCustomerComplex()
{
//arrange
var random = new Random();
var customer = LimitCustomer.Create($"ACESSO", $"document{random.Next(1000, 10000)}");
var limitLevel = LimitLevel.Create(LevelType.Card, 1000, 30);
var cycle = Cycle.Create(CycleType.Transaction);
cycle.AddLimitLevel(limitLevel);
var limit = Limit.Create(LimitType.CashIn, FeatureType.TED);
limit.AddCycle(cycle);
customer.AddLimit(limit);
//act
await _repositoryCommand.SaveAsync(customer);
var customerFound = await _repositoryQuery.GetAsync(customer.Id);
//assert
Assert.NotNull(customerFound);
Assert.Equal(customer.Id, customerFound.Id);
Assert.True(customerFound.Limits.Count == 1);
Assert.True(customerFound.Limits.First().Cycles.Count == 1);
Assert.True(customerFound.Limits.First().Cycles.First().LimitLevels.Count == 1);
}
public void MultTest()
{
var poly3 = KtPolynomial.Create(2, 1);
Term term1 = poly3;
var poly1 = KtPolynomial.Create(3, 5, 2, 5);
var poly2 = KtPolynomial.Create(3, 12, -2);
Term term2 = new DiscontinuousTerm(poly1, poly2, Limit.Create(-12, 20));
var actualResult = term1 * term2;
Term expectedResult2 = new DiscontinuousTerm(poly3 * poly1, poly2, Limit.Create(-12, 20));
Assert.AreEqual(actualResult, expectedResult2);
}
public void LimitHaveAddNewCycle()
{
//arrange
var cycle = Cycle.Create(CycleType.Daily);
var limit = Limit.Create(LimitType.CashIn, FeatureType.TED);
limit.AddCycle(cycle);
//act
var result = limit.Validate();
//assert
Assert.True(result.IsValid);
}
public void LimitCompanyHaveAddNewLimit()
{
//arrange
var limit = Limit.Create(LimitType.CashIn, FeatureType.TED);
var limitCompany = LimitCompany.Create("123456");
limitCompany.AddLimit(limit);
//act
var result = limitCompany.Validate();
//assert
Assert.True(result.IsValid);
}
public void BothDiscontinuousNotTouching()
{
var poly3 = KtPolynomial.Create(2, 1);
var poly4 = KtPolynomial.Create(3, 1);
Term term1 = new DiscontinuousTerm(poly3, poly4, Limit.Create(-12, 9));
var poly1 = KtPolynomial.Create(3, 5, 2, 5);
var poly2 = KtPolynomial.Create(3, 12, -2);
Term term2 = new DiscontinuousTerm(poly1, poly2, Limit.Create(10, 20));
var actualResult = term1 + term2;
Assert.AreEqual(actualResult.Length, 2);
Assert.AreEqual(actualResult[0], term1);
Assert.AreEqual(actualResult[1], term2);
}
public static LimitCustomer CreateLimitCustomer(LimitType limitType, FeatureType featureType, CycleType cycleType, LimitLevel limitLevel)
{
var customer = LimitCustomer.Create("ACESSO", "document123");
var cycle = Cycle.Create(cycleType);
cycle.AddLimitLevel(limitLevel);
var limit = Limit.Create(limitType, featureType);
limit.AddCycle(cycle);
customer.AddLimit(limit);
return(customer);
}
private IEnumerable <Limit> LimitsParse(List <LimitDto> limitsDto)
{
if (limitsDto?.Any() == true)
{
foreach (var limitDto in limitsDto)
{
var limit = Limit.Create(limitDto.Type, limitDto.FeatureType, limitDto.RegistrationCompleted);
var cycles = CyclesParse(limitDto.Cycles);
limit.AddCycles(cycles);
yield return(limit);
}
}
}
public void LimitDontHaveTwoCycleEquals()
{
//arrange
var cycle = Cycle.Create(CycleType.Daily);
var cycleDouble = Cycle.Create(CycleType.Daily);
var limit = Limit.Create(LimitType.CashIn, FeatureType.TED);
limit.AddCycle(cycle);
//act
limit.AddCycle(cycleDouble);
var result = limit.Validate();
//assert
Assert.True(result.IsInvalid);
}
public void GaussianEliminationTest()
{
var mat1 = new Matrix(new[, ] {
{ 1936.0 / 45, 692.0 / 15 },
{ 692.0 / 15, 324.0 / 5 }
});
var polyu = KtPolynomial.Create(1);
var poly1 = KtPolynomial.Create(0, 572.0 / 45, 0, -11.0 / 90);
var poly2 = KtPolynomial.Create(-32.0 / 3, 932.0 / 45, -2, 2.0 / 45);
var expression1 = new Expression(
((poly1, polyu), Limit.Create(0, 4)),
((poly2, polyu), Limit.Create(4, 9)),
((poly2, polyu), Limit.Create(9, 15)));
var poly3 = KtPolynomial.Create(0, 63.0 / 5, 0, -1 / 15.0);
var poly4 = KtPolynomial.Create(-243 / 2.0, 531.0 / 10, -9.0 / 2, 1.0 / 10);
var expression2 = new Expression(
((poly3, polyu), Limit.Create(0, 4)),
((poly3, polyu), Limit.Create(4, 9)),
((poly4, polyu), Limit.Create(9, 15)));
var mat2 = new Matrix(new[, ] {
{ expression1 }, { expression2 }
});
var actual = MatrixMethods.GaussianElimination(mat1, mat2);
//GetEllapsedTime(mat1, mat2);
var expPoly1a = KtPolynomial.Create(0, 2727.0 / 7420, 0, -109.0 / 14840);
var expPoly1b = KtPolynomial.Create(-1944.0 / 1855, 8559.0 / 7420, -729.0 / 3710, 67.0 / 7420);
var expPoly1c = KtPolynomial.Create(3159.0 / 424, -24921.0 / 14840, 351.0 / 2968, -39.0 / 14840);
var expPoly2a = KtPolynomial.Create(0, -374.0 / 5565, 0, 187.0 / 44520);
var expPoly2b = KtPolynomial.Create(1384.0 / 1855, -3488.0 / 5565, 519.0 / 3710, -83.0 / 11130);
var expPoly2c = KtPolynomial.Create(-761.0 / 106, 22427.0 / 11130, -57.0 / 371, 19.0 / 5565);
var expected1 = new Expression(
((expPoly1a, polyu), Limit.Create(0, 4)),
((expPoly1b, polyu), Limit.Create(4, 9)),
((expPoly1c, polyu), Limit.Create(9, 15)));
var expected2 = new Expression(
((expPoly2a, polyu), Limit.Create(0, 4)),
((expPoly2b, polyu), Limit.Create(4, 9)),
((expPoly2c, polyu), Limit.Create(9, 15)));
var expected = new Matrix(new[, ] {
{ expected1 }, { expected2 }
});
Assert.AreEqual(expected1, actual[0, 0]);
Assert.AreEqual(expected2, actual[1, 0]);
Assert.AreEqual(expected, actual);
}
public void Subtracting()
{
var poly1 = KtPolynomial.Create(4, 0, -2, 0, 4, 1);
var poly2 = KtPolynomial.Create(3, -4.3, 1);
var poly3 = KtPolynomial.Create(4, 3, 7);
var denom = KtPolynomial.Create(1);
var term1 = new DiscontinuousTerm(poly1, denom, Limit.Create(-20, -10));
var term2 = new DiscontinuousTerm(poly2, denom, Limit.Create(-15, -5));
Term term3 = poly3;
var expression = new Expression(term1, term3, term2);
var actual = expression - expression;
_ = new Zero();
var expected = new Expression((Number)0);
Assert.AreEqual(actual, expected);
}
public void LimitCompanyDontHaveTwoLimitEquals()
{
//arrange
var limit = Limit.Create(LimitType.CashIn, FeatureType.TED);
var limitDouble = Limit.Create(LimitType.CashIn, FeatureType.TED);
var limitCompany = LimitCompany.Create("123456");
limitCompany.AddLimit(limit);
//act
limitCompany.AddLimit(limitDouble);
var result = limitCompany.Validate();
//assert
Assert.True(result.IsInvalid);
}
public void BothDiscontinuousBarelyInclusive()
{
var poly3 = KtPolynomial.Create(2, 1);
var poly4 = KtPolynomial.Create(3, 1);
Term term1 = new DiscontinuousTerm(poly3, poly4, Limit.Create(-12, 10));
var poly1 = KtPolynomial.Create(3, 5, 2, 5);
var poly2 = KtPolynomial.Create(3, 12, -2);
Term term2 = new DiscontinuousTerm(poly1, poly2, Limit.Create(-12, 20));
var actualResult = term1 - term2;
Assert.AreEqual(actualResult.Length, 2);
Term expectedResult2 = new DiscontinuousTerm((poly3 * poly2) - (poly1 * poly4), poly4 * poly2, Limit.Create(-12, 10));
Assert.AreEqual(actualResult[0], expectedResult2);
Term expectedResult3 = new DiscontinuousTerm(-poly1, poly2, Limit.Create(10, 20));
Assert.AreEqual(actualResult[1], expectedResult3);
}
public async Task AddNewCustomerSimple()
{
//arrange
var random = new Random();
var company = Fixture.GetLimitCompanyValid();
company.AddLimit(Limit.Create(LimitType.CashIn, FeatureType.TED));
//act
await _repositoryCommand.SaveAsync(company);
var companyFound = await _repositoryQuery.GetAsync(company.Id);
//assert
Assert.NotNull(companyFound);
Assert.Equal(company.Id, companyFound.Id);
Assert.True(companyFound.Limits.Count > 0);
}
public async Task AddNewCustomerSimple()
{
//arrange
var random = new Random();
var customer = LimitCustomer.Create($"ACESSO", $"document{random.Next(1000, 10000)}");
customer.AddLimit(Limit.Create(LimitType.CashIn, FeatureType.TED));
//act
await _repositoryCommand.SaveAsync(customer);
var customerFound = await _repositoryQuery.GetAsync(customer.Id);
//assert
Assert.NotNull(customerFound);
Assert.Equal(customer.Id, customerFound.Id);
Assert.True(customerFound.Limits.Count > 0);
}
public void BothDiscontinuousOverlap()
{
var poly3 = KtPolynomial.Create(2, 1);
var poly4 = KtPolynomial.Create(3, 1);
Term term1 = new DiscontinuousTerm(poly3, poly4, Limit.Create(-12, 15));
var poly1 = KtPolynomial.Create(3, 5, 2, 5);
var poly2 = KtPolynomial.Create(3, 12, -2);
Term term2 = new DiscontinuousTerm(poly1, poly2, Limit.Create(10, 20));
var actualResult = term1 + term2;
Assert.AreEqual(actualResult.Length, 3);
Term term3 = new DiscontinuousTerm(poly3, poly4, Limit.Create(-12, 10));
Term term4 = new DiscontinuousTerm((poly3 * poly2) + (poly1 * poly4), poly4 * poly2, Limit.Create(10, 15));
Term term5 = new DiscontinuousTerm(poly1, poly2, Limit.Create(15, 20));
Assert.AreEqual(actualResult[0], term3);
Assert.AreEqual(actualResult[1], term4);
Assert.AreEqual(actualResult[2], term5);
}
public void Adding()
{
var poly1 = KtPolynomial.Create(4, 0, -2, 0, 4, 1);
var poly2 = KtPolynomial.Create(3, -4.3, 1);
var poly3 = KtPolynomial.Create(4, 3, 7);
var denom = KtPolynomial.Create(1);
var term1 = new DiscontinuousTerm(poly1, denom, Limit.Create(-20, -10));
var term2 = new DiscontinuousTerm(poly2, denom, Limit.Create(-15, -5));
Term term3 = poly3;
var expression = new Expression(term1, term3, term2);
var expected = new Expression(
new DiscontinuousTerm(2 * poly3, denom, ForwardLimit.Create(-20)),
new DiscontinuousTerm(2 * (poly3 + poly1), denom, Limit.Create(-20, -15)),
new DiscontinuousTerm(2 * (poly3 + poly1 + poly2), denom, Limit.Create(-15, -10)),
new DiscontinuousTerm(2 * (poly3 + poly2), denom, Limit.Create(-10, -5)),
new DiscontinuousTerm(2 * poly3, denom, BackwardLimit.Create(-5)));
Assert.AreEqual(expression + expression, expected);
}
public void ContinuousAndNot()
{
var poly3 = KtPolynomial.Create(2, 1);
Term term1 = poly3;
var poly1 = KtPolynomial.Create(3, 5, 2, 5);
var poly2 = KtPolynomial.Create(3, 12, -2);
Term term2 = new DiscontinuousTerm(poly1, poly2, Limit.Create(-12, 20));
var actualResult = term1 + term2;
Assert.AreEqual(actualResult.Length, 3);
Term expectedResult1 = new DiscontinuousTerm(poly3, KtPolynomial.Create(1), ForwardLimit.Create(-12));
Assert.AreEqual(actualResult[0], expectedResult1);
Term expectedResult2 = new DiscontinuousTerm((poly3 * poly2) + poly1, poly2, Limit.Create(-12, 20));
Assert.AreEqual(actualResult[1], expectedResult2);
Term expectedResult3 = new DiscontinuousTerm(poly3, KtPolynomial.Create(1), BackwardLimit.Create(20));
Assert.AreEqual(actualResult[2], expectedResult3);
Assert.IsTrue(actualResult.SequenceEqual(term2 + term1));
}
public void MultiplicationOfExpressionAndNumber()
{
var mat1 = new Matrix(new[, ] {
{ 1.0 / 2, -2, -30, 20 },
{ 15, 2.1, 4, 3 },
{ 3, 2, 1, 3 },
{ 4, -4, 3, 2 }
});
var expression1 = new Expression(((KtPolynomial.Create(3, 2), KtPolynomial.Create(1, 2)), Limit.Create(3, 12)));
var expression2 = new Expression(((KtPolynomial.Create(2), KtPolynomial.Create(1, 2)), Limit.Create(3, 12)));
var mat2 = new Matrix(new[, ] {
{ expression1 }, { expression2 }, { expression1 }, { expression2 }
});
_ = mat1 * mat2;
}
