private string SubContent(string content)
{
if (content == errorInfo)
{
return(content);
}
if (content.Length == 1)
{
bufferStr = num_zero.ToString();
bufferType = CalculatorData.GetKeyTypeByValue(num_zero);
return(num_zero.ToString());
}
Stack <char> characters = new Stack <char>(content.ToCharArray());
characters.Pop();
char Pop_Char = characters.Peek();
if (Pop_Char == num_zero)
{
Pop_Char = magic_value;
}
bufferStr = Pop_Char.ToString();
bufferType = CalculatorData.GetKeyTypeByValue(Pop_Char);
var outCharacters = characters.ToArray();
Array.Reverse(outCharacters);
return(new string(outCharacters));
}
private string AddContent(string content, KeyName name, KeyType type)
{
if (defaultNum == errorInfo)
{
return(content);
}
char s = CalculatorData.GetKeyValueByName(name);
if (content == defaultNum)
{
if (AddOnDefalut(s, type))
{
content += s;
}
else
{
content = s.ToString();
}
}
else
{
if (AddOnEquation(s, type))
{
content += s;
}
}
return(content);
}
public string UpdateContent(string content, KeyName name)
{
string resultContent = "";
KeyType type = CalculatorData.GetKeyTypeByName(name);
switch (type)
{
case KeyType.NumberKey:
case KeyType.NumberPointKey:
case KeyType.OperatorKey:
case KeyType.BacketLeftKey:
case KeyType.BacketRightKey:
resultContent = AddContent(content, name, type);
break;
case KeyType.BackKey:
resultContent = SubContent(content);
break;
case KeyType.ClearKey:
resultContent = ClearContent();
break;
case KeyType.ResultKey:
resultContent = GetResultContent(content);
break;
}
return(resultContent);
}
private bool AddOnEquation(char operation, KeyType type)
{
Debug.Log("AddOnEquation():" + " bufferStr = " + bufferStr + ", bufferType = " + bufferType.ToString());
Debug.Log("AddOnEquation():" + " operation = " + operation + ", type = " + type.ToString());
if (bufferType == KeyType.NumberKey && (type == KeyType.NumberKey || type == KeyType.NumberPointKey))
{
if (bufferStr == num_zero.ToString())
{
return(false);
}
else
{
char point = CalculatorData.GetKeyValueByName(KeyName.Number_point);
if (bufferStr.Contains(point.ToString()) && type == KeyType.NumberPointKey)
{
return(false);
}
bufferStr += operation;
return(true);
}
}
bufferStr = operation.ToString();
bufferType = type;
return(true);
}
/// <summary>
/// Calculates prices of the given shipping option.
/// </summary>
/// <param name="shippingInfo">Shipping option info object (<see cref="ShippingOptionInfo"/>) for which the prices are calculated.</param>
/// <param name="cart">Shopping cart (<see cref="ShoppingCart"/>) used to gather the price calculation information.</param>
/// <returns><see cref="ShippingPrice"/> object containing the shipping's prices.</returns>
public virtual ShippingPrice CalculateShippingOptionPrice(ShippingOptionInfo shippingInfo, ShoppingCart cart)
{
if (shippingInfo == null)
{
throw new ArgumentNullException(nameof(shippingInfo));
}
if (cart == null)
{
throw new ArgumentNullException(nameof(cart));
}
var originalCart = cart.OriginalCart;
// Evaluate the cart to get total items price
originalCart.Evaluate();
var request = Service.Resolve <IShoppingCartAdapterService>().GetCalculationRequest(originalCart);
request.ShippingOption = shippingInfo;
var calculatorData = new CalculatorData(request, new CalculationResult());
// Get shipping price
var shippingPrice = Service.Resolve <IShippingPriceService>().GetShippingPrice(calculatorData, originalCart.TotalItemsPrice).Price;
var roundingService = Service.Resolve <IRoundingServiceFactory>().GetRoundingService(originalCart.ShoppingCartSiteID);
return(new ShippingPrice
{
Currency = cart.Currency,
Price = roundingService.Round(shippingPrice, cart.Currency.OriginalCurrency),
Tax = 0m
});
}
private void InputOperatorStack_BacketRightKey()
{
while (operatorsStack.Peek() != CalculatorData.GetKeyValueByName(KeyName.Bracket_Left))
{
Calculate();
}
operatorsStack.Pop();
}
public ActionResult Index(CalculatorData data)
{
ViewBag.Success = true;
data.ConvertUnits();
return(View(data));
}
public void SetFork(Fork fork, int maxBett)
{
var coeff1 = Convert.ToDouble(fork.Cof1);
var coeff2 = Convert.ToDouble(fork.Cof2);
var bet = maxBett;
Data = Calculator.CalculatorBet(coeff1, coeff2, bet);
}
/// <summary>
/// Save the financial calculator to a stream.
/// </summary>
/// <param name="stream">Stream to save data to. Stream will not be closed by this method.</param>
public void Save(Stream stream)
{
var data = new CalculatorData(this);
var text = Native.Serializer.Serialize(data);
var writer = new StreamWriter(stream);
writer.Write(text);
writer.Flush();
}
public IActionResult Calculate([FromForm] CalculatorData myData)
{
var svc = new CompoundCalculatorService();
var result = svc.CalculateCompoundInterest(myData);
if (result != -1)
{
myData.CalcResults = result;
}
return(View(myData));
}
public void LandingReportRunwayTooShort()
{
var d = new CalculatorData()
{
Table = LoaderTest.GetTable(),
Parameters = GetParameters
};
d.Parameters.RwyLengthMeter = 100;
Assert.Throws <RunwayTooShortException>(() => Calculator.LandingReport(d));
}
public void NoCorrection()
{
var d = new CalculatorData()
{
Table = LoaderTest.GetTable(),
Parameters = GetParameters
};
var dis = Calculator.LandingDistanceMeter(d);
Assert.AreEqual(2460 * Constants.FtMeterRatio, dis, 10);
}
protected void btnAdd_Click(object sender, EventArgs e)
{
int a = int.Parse(txta.Text);
int b = int.Parse(txtb.Text);
ChannelFactory <ICalculatorService> factory = new ChannelFactory <ICalculatorService>("SelfhostCalculator");
ICalculatorService client = factory.CreateChannel();
CalculatorData c = client.Add(a, b);
lblResult.Text = c.Result.ToString();
}
public void BothReversersCorrectionDry()
{
var d = new CalculatorData()
{
Table = LoaderTest.GetTable(),
Parameters = GetParameters
};
d.Parameters.Reverser = 1;
var dis = Calculator.LandingDistanceMeter(d);
Assert.AreEqual(2460 * Constants.FtMeterRatio * 0.97, dis, 10);
}
public void TailwindCorrectionDry()
{
var d = new CalculatorData()
{
Table = LoaderTest.GetTable(),
Parameters = GetParameters
};
d.Parameters.HeadwindKts = -10;
var dis = Calculator.LandingDistanceMeter(d);
Assert.AreEqual(2460 * Constants.FtMeterRatio * 1.20, dis, 10);
}
public void LandingReportTest()
{
var d = new CalculatorData()
{
Table = LoaderTest.GetTable(),
Parameters = GetParameters
};
var r = Calculator.LandingReport(d);
Assert.IsTrue(r.AllBrakes.All(x => x.RemainingDistanceMeter >= 0));
Assert.IsTrue(r.SelectedBrake.RemainingDistanceMeter >= 0);
}
public void ElevationCorrectionDry()
{
var d = new CalculatorData()
{
Table = LoaderTest.GetTable(),
Parameters = GetParameters
};
d.Parameters.ElevationFT = 1000;
var dis = Calculator.LandingDistanceMeter(d);
Assert.AreEqual(2460 * Constants.FtMeterRatio * 1.03, dis, 10);
}
public void SpeedCorrection()
{
var d = new CalculatorData()
{
Table = LoaderTest.GetTable(),
Parameters = GetParameters
};
d.Parameters.AppSpeedIncrease = 5;
var dis = Calculator.LandingDistanceMeter(d);
Assert.AreEqual(2460 * Constants.FtMeterRatio * 1.08, dis, 10);
}
public void HeadwindCorrectionWet()
{
var d = new CalculatorData()
{
Table = LoaderTest.GetTable(),
Parameters = GetParameters
};
d.Parameters.HeadwindKts = 10;
d.Parameters.SurfaceCondition = 1;
var dis = Calculator.LandingDistanceMeter(d);
Assert.AreEqual(2952 * Constants.FtMeterRatio, dis, 10);
}
public void ElevationCorrectionWet()
{
var d = new CalculatorData()
{
Table = LoaderTest.GetTable(),
Parameters = GetParameters
};
d.Parameters.SurfaceCondition = 1;
d.Parameters.ElevationFT = -1000;
var dis = Calculator.LandingDistanceMeter(d);
Assert.AreEqual(2952 * Constants.FtMeterRatio * 0.97, dis, 10);
}
public Employee GetEmployeeWithCalculation(string empId)
{
var emp = DataContext.Employees.Single(p => p.Id == empId);
var salaryList = new List <Employee>();
var data = new CalculatorData
{
CalculationDate = DateTime.Now,
Employee = emp,
EmpSalaries = salaryList
};
var calculator = CalculationHelper.FactoryCalculator(data);
calculator.CalculateSalary();
return(data.Employee);
}
private double Execute()
{
operatorsStack = new Stack <char>();
numbersStack = new Stack <double>();
var bufferNumString = "";
var operations = equation.ToCharArray();
foreach (var operation in operations)
{
var type = CalculatorData.GetKeyTypeByValue(operation);
var name = CalculatorData.GetKeyNameByValue(operation);
switch (type)
{
case KeyType.NumberKey:
case KeyType.NumberPointKey:
bufferNumString += operation;
break;
case KeyType.OperatorKey:
case KeyType.BacketLeftKey:
case KeyType.BacketRightKey:
if (bufferNumString != "")
{
InputNumberStack(bufferNumString);
bufferNumString = "";
}
InputOperatorStack(type, name);
break;
}
}
if (bufferNumString != "")
{
InputNumberStack(bufferNumString);
bufferNumString = "";
}
var result = OutputResult();
return(result);
}
public static AbstractCalculator FactoryCalculator(CalculatorData calcData)
{
AbstractCalculator calc = null;
switch (calcData.Employee.TypeId)
{
case (int)EmployeeType.EmployeeTypes.Employee:
calc = new EmployeeCalculator(calcData);
break;
case (int)EmployeeType.EmployeeTypes.Manager:
calc = new ManagerCalculator(calcData);
break;
case (int)EmployeeType.EmployeeTypes.Salesman:
calc = new SalesmanCalculator(calcData);
break;
}
return(calc);
}
public decimal CalculateCompoundInterest(CalculatorData myData)
{
if (myData == null)
{
return(-1);
}
decimal result = 0m;
//Math.Pow(100.00, 3.00); // 100.00 ^ 3.00
//Principal=5000;
//InterestRate=0.05;
//Number of times the interest is compounded: 12
//Time=10 years
// example: 1+ 0.05 /12
var temp1 = Decimal.ToDouble(1 + (myData.InterestRate / 100) / myData.NoOfTimesInterestComp);
var temp2 = (decimal)Math.Pow(temp1, myData.NoOfTimesInterestComp * myData.Time);
result = myData.Principal * temp2;
return(result);
}
public override double CalculateSalary()
{
var check = CalculationHelper.HaveCircularDependency(CalcData.Employee.Id, CalcData.Employee.Dependants);
if (check)
{
throw new HandledException("Circular dependency error.");
}
double dependantsSum = 0;
double dependantsSumRec = 0;
if (CalcData.Employee.Dependants != null)
{
foreach (var emp in CalcData.Employee.Dependants)
{
var item = CalcData.EmpSalaries.SingleOrDefault(p => p.Id == emp.Id);
if (item != null)
{
dependantsSum += item.Salary;
continue;
}
var data = new CalculatorData
{
CalculationDate = CalcData.CalculationDate,
Employee = emp,
EmpSalaries = CalcData.EmpSalaries,
Recursively = CalcData.Recursively
};
var calculator = CalculationHelper.FactoryCalculator(data);
dependantsSumRec += calculator.CalculateSalary();
dependantsSum += data.EmpSalaries.Single(p => p.Id == emp.Id).Salary;
}
}
double salary = CalcData.Employee.BasicRate + CalcData.Employee.CalculateAllowance(CalcData.CalculationDate) + dependantsSum * CalcData.Employee.Type.DependantsAllowance / 100;
CalcData.Employee.Salary = NotAvailableSalary() ? 0 : salary;
CalcData.EmpSalaries.Add(CalcData.Employee);
return(CalcData.Recursively ? salary + dependantsSumRec : salary);
}
public IEnumerable <Employee> CalculateSalary(DateTime date)
{
var employees = GetEmployees().Result.Where(p => p.BossId == null);
var salaryList = new List <Employee>();
foreach (var emp in employees)
{
var data = new CalculatorData
{
CalculationDate = date,
Employee = emp,
EmpSalaries = salaryList
};
var calculator = CalculationHelper.FactoryCalculator(data);
calculator.CalculateSalary();
}
if (salaryList.Count != DataContext.Employees.Count())
{
throw new HandledException("Circular dependency error.");
}
return(salaryList);
}
private void InputOperatorStack_Operator(KeyName newName)
{
char newOperator = CalculatorData.GetKeyValueByName(newName);
int newLevel = OperatorFactory.OperatorPriority(newOperator);
while (operatorsStack.Count != 0 &&
operatorsStack.Peek() != CalculatorData.GetKeyValueByName(KeyName.Bracket_Left))
{
var oldOperator = operatorsStack.Peek();
var oldLevel = OperatorFactory.OperatorPriority(oldOperator);
if (newLevel <= oldLevel)
{
Calculate();
}
else
{
operatorsStack.Push(newOperator);
return;
}
}
operatorsStack.Push(newOperator);
}
/// <summary>
/// Load a financial calculator from a stream.
/// </summary>
/// <param name="stream">Stream to load data from. Stream will not be closed by this method.</param>
public static FinancialCalculator Load(Stream stream)
{
var reader = new StreamReader(stream);
var text = reader.ReadToEnd();
CalculatorData data = null;
try
{
data = DoLoadAsXml(text);
}
catch
{
}
if (data == null)
{
data = DoLoadAsTxt(text);
}
var result = data.CreateCalculator();
return(result);
}
public SalesmanCalculator(CalculatorData calcData) : base(calcData)
{
}
public ManagerCalculator(CalculatorData calcData) : base(calcData)
{
}
