// Private (methods)
private void AddOrUpdateIfNewMatrixPoints(CalculationData calculationData)
{
// Here, no code is needed to update the matrix due to the Point's object
// reference already passed in the list of points, when the last point on
// the list is updated the Matrix will already have itself updated.
// So you just need to redraw the pattern on the chart
if (!IsNewMatrixTheSameTheLastOne(calculationData.pointsList))
{
switch (calculationData.whichTrend)
{
// Add long pattern if the first point was an low
case MatrixPoints.WhichTrendSideSignal.Bullish:
matrixPointsList.Add(new MatrixPoints(calculationData.pointsList,
matrixPointsList.Count,
MatrixPoints.WhichTrendSideSignal.Bullish,
calculationData.whichGraphic));
break;
// Add short pattern if the first point was an high
case MatrixPoints.WhichTrendSideSignal.Bearish:
matrixPointsList.Add(new MatrixPoints(calculationData.pointsList,
matrixPointsList.Count,
MatrixPoints.WhichTrendSideSignal.Bearish,
calculationData.whichGraphic));
break;
}
}
}
public override void Calculate(CalculationData data)
{
data.CalculatedValue = new object[][] {
new object[] { new DateTime(2015, 6, 12, 10, 6, 30), 2 },
new object[] { 3.0, "Test" }
};
}
public CheckData Calculate()
{
var result = new CheckData();
//Do all discount calculation only when category discount is not null.
//Applying discount to Check is optional.
if (_categoryDiscount != null)
{
var invoiceProducts = new List <InvoiceProduct>();
_products.ForEach(product =>
{
if (IsValidForDiscount(product))
{
var calculationData = new CalculationData(product.Price, _categoryDiscount);
CalculateDiscountedPrice(calculationData);
invoiceProducts.Add(new InvoiceProduct(product.Name, Math.Round(product.Price, 2), Math.Round(calculationData.OutputAmount, 2), product.Category));
}
else
{
invoiceProducts.Add(new InvoiceProduct(product.Name, product.Price, product.Price, product.Category));
}
});
result.Items = invoiceProducts;
}
else
{
result.Items = _products.Select(_ => new InvoiceProduct(_.Name, _.Price, _.Price, _.Category)).ToList();
}
return(result);
}
public void Calculate()
{
SetValues();
calculationData = new CalculationData();
if (pointsList.Count == 0)
{
calculationData = OnCalculationOfFirstSwingPointRequest();
}
else if (owner.State == State.Historical)
{
calculationData = OnCalculationOfEachBarSwingPointRequest();
calculationStage = CalculationStage.EachBarSwingPoint;
}
else if (owner.State == State.Realtime)
{
calculationData = OnCalculationOFEachTickSwingPointRequest();
calculationStage = CalculationStage.EachTickSwingPoint;
}
if (calculationData.isNewSwing)
{
AddOrUpdatePointsIfNewSwing(calculationData, calculationStage);
}
}
private void CalculateButtonClick(object sender, RoutedEventArgs e)
{
try
{
double l = Double.Parse(lengthInput.Text);
double w = double.Parse(widthInput.Text);
double b = double.Parse(breadthInput.Text);
CalculationData obj = new CalculationData();
CalculationData.length = Math.Abs(l);
CalculationData.breadth = Math.Abs(b);
CalculationData.width = Math.Abs(w);
CalculationData.unit = comboBox.SelectionBoxItem as string;
if (parameter.Equals("c1") || parameter.Equals("c2") || parameter.Equals("c3") || parameter.Equals("c4"))
{
Frame.Navigate(typeof(ResultPage), parameter);
}
else
{
Frame.Navigate(typeof(PyramidResultPage), parameter);
}
}
catch (Exception ex)
{
warningText.Visibility = Visibility.Visible;
}
}
public OperationResult Calculate(CalculationData data)
{
Func <decimal, decimal, decimal> mathExpression;
var operation = data.MathOperation;
try
{
mathExpression = _mathExpressionProvider.Get(operation);
}
catch (Exception)
{
return(new OperationResult($"Operation '{operation}' is not supported"));
}
if (operation == MathOperations.Divide && data.Operand2 == 0)
{
return(new OperationResult("Attempt to divide by zero"));
}
try
{
var value = mathExpression(data.Operand1, data.Operand2);
return(new OperationResult(value));
}
catch (Exception ex)
{
return(new OperationResult($"Error executing '{operation}' operation between {data.Operand1} and {data.Operand2}"));
}
}
public void Add(CalculationData data, long applicationId)
{
_executor.Execute("[dbo].[Calculation_Add]", new
{
data.ClientId,
ApplicationHistoryId = applicationId,
data.AirWaybillDisplay,
data.ApplicationDisplay,
data.MarkName,
data.Weight,
data.TariffPerKg,
data.ScotchCost,
data.InsuranceRate,
data.FactureCost,
data.FactureCostEx,
data.TransitCost,
data.PickupCost,
data.FactoryName,
data.CreationTimestamp,
ClassId = data.Class,
data.Count,
data.Invoice,
data.Value,
data.Profit,
data.TotalTariffCost
});
}
public CalculationDataDrawable(CalculationData data, string clientNick, int columnCount, ExcelWorksheet excel)
{
_data = data;
_clientNick = clientNick;
_excel = excel;
_columnCount = columnCount;
}
private void AddOrUpdatePointsIfNewSwing(CalculationData calculationData, CalculationStage calculationStage)
{
switch (calculationStage)
{
case CalculationStage.FirstPoint:
if (calculationData.sideSwing == Point.SidePoint.High)
{
AddHigh(pointsList.Count, calculationData.price, calculationData.barIndex, calculationData.sideSwing);
}
else if (calculationData.sideSwing == Point.SidePoint.Low)
{
AddLow(pointsList.Count, calculationData.price, calculationData.barIndex, calculationData.sideSwing);
}
else if (calculationData.sideSwing == Point.SidePoint.Unknow && pointsList.Count == 0)
{
AddUnknow(pointsList.Count, owner.Open.GetValueAt(0), 0, calculationData.sideSwing);
}
break;
case CalculationStage.EachBarSwingPoint:
DefaultAddUpdatePointsManagement(calculationData);
break;
case CalculationStage.EachTickSwingPoint:
DefaultAddUpdatePointsManagement(calculationData);
break;
}
}
/// <summary>
/// Berechnet den Abschreibungs- und Restbuchwert und rundet das Ergebnis entsprechend der Implementation.
/// </summary>
/// <param name="method">Das Verfahren für die Abschreibungsberechnung</param>
/// <param name="data">Die Basis-Daten anhand derer der Abschreibungswert berechnet wird.</param>
/// <param name="period">Das Abrechnungsjahr (beginnend bei 0 = keine Abschreibung)</param>
/// <returns>Das Ergebnis der Berechnung und Rundung</returns>
public CalculationResult Calculate(ICalculationMethod method, CalculationData data, int period)
{
if (period < 0 || period > data.DepreciationRange)
throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater or equal than 0 and less than the value of depreciationRange.");
if (period == 0)
return new CalculationResult(period, 0, data.AcquisitionValue);
var result = method.CalculateDepreciation(data, period);
CalculationResult resultOld;
if (period == 1)
{
// Nicht jede Berechnungsart funktioniert für period == 0!
resultOld = new CalculationResult(0, 0, data.AcquisitionValue);
}
else
{
resultOld = method.CalculateDepreciation(data, period - 1);
}
var remainingValue = Math.Round(result.RemainingValue, _decimals);
var remainingValueOld = Math.Round(resultOld.RemainingValue, _decimals);
return new CalculationResult(period, remainingValueOld - remainingValue, remainingValue);
}
/// <summary>
/// Berechnet den Abschreibungs- und Restbuchwert und rundet das Ergebnis entsprechend der Implementation.
/// </summary>
/// <param name="method">Das Verfahren für die Abschreibungsberechnung</param>
/// <param name="data">Die Basis-Daten anhand derer der Abschreibungswert berechnet wird.</param>
/// <param name="period">Das Abrechnungsjahr (beginnend bei 0 = keine Abschreibung)</param>
/// <returns>Das Ergebnis der Berechnung und Rundung</returns>
public CalculationResult Calculate(ICalculationMethod method, CalculationData data, int period)
{
if (period < 0 || period > data.DepreciationRange)
{
throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater or equal than 0 and less than the value of depreciationRange.");
}
if (period == 0)
{
return(new CalculationResult(period, 0, data.AcquisitionValue));
}
var result = method.CalculateDepreciation(data, period);
CalculationResult resultOld;
if (period == 1)
{
// Nicht jede Berechnungsart funktioniert für period == 0!
resultOld = new CalculationResult(0, 0, data.AcquisitionValue);
}
else
{
resultOld = method.CalculateDepreciation(data, period - 1);
}
var remainingValue = Math.Round(result.RemainingValue, _decimals);
var remainingValueOld = Math.Round(resultOld.RemainingValue, _decimals);
return(new CalculationResult(period, remainingValueOld - remainingValue, remainingValue));
}
public async Task SavingResult(CalculationData resultToSave)
{
using (var context = new CalculatorContext())
{
context.LogFile.Add(resultToSave);
await context.SaveChangesAsync();
}
}
// Override the Calculate method with custom logic
public override void Calculate(CalculationData data)
{
// Check the forumla name and calculate it yourself
if (data.FunctionName == "MyCompany.CustomFunction")
{
// This is our calculated value
data.CalculatedValue = "Aspose.Cells.";
}
}
public void Calculate(PriceActionSwingClass priceActionSwingClass)
{
currentCalculationData = OnCalculationRequest(priceActionSwingClass);
if (currentCalculationData.isNewMatrixPoints)
{
AddOrUpdateIfNewMatrixPoints(currentCalculationData);
}
}
// Override the Calculate method with custom logic
public override void Calculate(CalculationData data)
{
// Check the forumla name and calculate it yourself
if (data.FunctionName == "MyCompany.CustomFunction")
{
// This is our calculated value
data.CalculatedValue = "Aspose.Cells.";
}
}
public void Calculate_WhenCall_CalledProvider()
{
var data = new CalculationData {
MathOperation = MathOperations.Multiply
};
var result = _service.Calculate(data);
_providerMock.Verify(x => x.Get(MathOperations.Multiply), Times.Once);
}
/// <summary>
/// Berechnung des Abschreibungs- und Restbuchwertes (<see cref="CalculationResult"/>) für das Abschreibungsjahr (<paramref name="period"/>).
/// </summary>
/// <param name="data">Die grundlegenden Daten für die Abschreibungsberechnung</param>
/// <param name="period">Das Abschreibungsjahr für das die Daten errechnet werden sollen.</param>
/// <returns>Die errechneten Abschreibungs- und Restbuchwerte</returns>
public CalculationResult CalculateDepreciation(CalculationData data, int period)
{
if (period < 1 || period > data.DepreciationRange)
throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater than 0 and less than the value of depreciationRange.");
var depreciation = (data.AcquisitionValue - data.TargetRemainingValue) / data.DepreciationRange;
var remainingValue = data.AcquisitionValue - depreciation * period;
return new CalculationResult(period, depreciation, remainingValue);
}
public void Calculate_Markup_When_Markup_Type_Is_Absolute_Successfully()
{
InvoiceItemDiscountCalculator calculator = new InvoiceItemDiscountCalculator();
var calculationData = new CalculationData(10, new MarkupDataStub {
MarkupType = MarkupType.Absolute, Value = 2d
});
calculator.Calculate(calculationData);
Assert.Equal(8f, calculationData.OutputAmount);
}
public void Calculate_WhenDivideByZero_ReturnedError()
{
var data = new CalculationData {
MathOperation = MathOperations.Divide, Operand2 = 0
};
var result = _service.Calculate(data);
Assert.IsFalse(result.IsOk);
Assert.AreEqual("Attempt to divide by zero", result.ErrorMessage);
}
public void Calculate_WhenCalculationThrowsException_ReturnedError()
{
var data = new CalculationData();
_providerMock.Setup(x => x.Get(It.IsAny <MathOperations>())).Returns((x, y) => throw new Exception());
var result = _service.Calculate(data);
Assert.IsFalse(result.IsOk);
Assert.AreEqual("Error executing 'Add' operation between 0 and 0", result.ErrorMessage);
}
public static RulePoint GetCalculationPoint(CalculationData data, string name)
{
try
{
return(data.Points.CalculationPoints.SingleOrDefault(j => j.Name == name));
}
catch (Exception ex)
{
throw exceptionConvertor(ex, name);
}
}
// Override the Calculate method with custom logic
public override void Calculate(CalculationData data)
{
// Check the forumla name and change the implementation
if (data.FunctionName.ToUpper() == "SUM")
{
double val = (double)data.CalculatedValue;
val = val + 30;
// Assign the CalculationData.CalculatedValue
data.CalculatedValue = val;
}
}
// Override the Calculate method with custom logic
public override void Calculate(CalculationData data)
{
//Check the forumla name and change the implementation
if (data.FunctionName.ToUpper() == "SUM")
{
double val = (double)data.CalculatedValue;
val = val + 30;
// Assign the CalculationData.CalculatedValue
data.CalculatedValue = val;
}
}
/// <summary>
/// Berechnung des Abschreibungs- und Restbuchwertes (<see cref="CalculationResult"/>) für das Abschreibungsjahr (<paramref name="period"/>).
/// </summary>
/// <param name="data">Die grundlegenden Daten für die Abschreibungsberechnung</param>
/// <param name="period">Das Abschreibungsjahr für das die Daten errechnet werden sollen.</param>
/// <returns>Die errechneten Abschreibungs- und Restbuchwerte</returns>
public CalculationResult CalculateDepreciation(CalculationData data, int period)
{
if (period < 1 || period > data.DepreciationRange)
{
throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater than 0 and less than the value of depreciationRange.");
}
var depreciation = (data.AcquisitionValue - data.TargetRemainingValue) / data.DepreciationRange;
var remainingValue = data.AcquisitionValue - depreciation * period;
return(new CalculationResult(period, depreciation, remainingValue));
}
public void Calculate_WhenProviderThrowsException_ReturnedError()
{
var data = new CalculationData {
MathOperation = MathOperations.Multiply
};
_providerMock.Setup(x => x.Get(It.IsAny <MathOperations>())).Throws <Exception>();
var result = _service.Calculate(data);
Assert.IsFalse(result.IsOk);
Assert.AreEqual("Operation 'Multiply' is not supported", result.ErrorMessage);
}
public void TestArithmetischDegressiv1()
{
var data = new CalculationData(150000, 18000, 5);
var rounding = new DefaultRounding();
var calc = new ArithmeticDegressive();
TestResult(rounding.Calculate(calc, data, 0), 150000, 0);
TestResult(rounding.Calculate(calc, data, 1), 106000, 44000);
TestResult(rounding.Calculate(calc, data, 2), 70800, 35200);
TestResult(rounding.Calculate(calc, data, 3), 44400, 26400);
TestResult(rounding.Calculate(calc, data, 4), 26800, 17600);
TestResult(rounding.Calculate(calc, data, 5), 18000, 8800);
}
public void TestLinear1()
{
var data = new CalculationData(10000, 0, 5);
var rounding = new DefaultRounding();
var calc = new Linear();
TestResult(rounding.Calculate(calc, data, 0), 10000, 0);
TestResult(rounding.Calculate(calc, data, 1), 8000, 2000);
TestResult(rounding.Calculate(calc, data, 2), 6000, 2000);
TestResult(rounding.Calculate(calc, data, 3), 4000, 2000);
TestResult(rounding.Calculate(calc, data, 4), 2000, 2000);
TestResult(rounding.Calculate(calc, data, 5), 0, 2000);
}
public void TestLinear1()
{
var data = new CalculationData(10000, 0, 5);
var rounding = new DefaultRounding();
var calc = new Linear();
TestResult(rounding.Calculate(calc, data, 0), 10000, 0);
TestResult(rounding.Calculate(calc, data, 1), 8000, 2000);
TestResult(rounding.Calculate(calc, data, 2), 6000, 2000);
TestResult(rounding.Calculate(calc, data, 3), 4000, 2000);
TestResult(rounding.Calculate(calc, data, 4), 2000, 2000);
TestResult(rounding.Calculate(calc, data, 5), 0, 2000);
}
public void TestArithmetischProgressiv1()
{
var data = new CalculationData(150000, 18000, 5);
var rounding = new DefaultRounding();
var calc = new ArithmeticProgressive();
TestResult(rounding.Calculate(calc, data, 0), 150000, 0);
TestResult(rounding.Calculate(calc, data, 1), 141200, 8800);
TestResult(rounding.Calculate(calc, data, 2), 123600, 17600);
TestResult(rounding.Calculate(calc, data, 3), 97200, 26400);
TestResult(rounding.Calculate(calc, data, 4), 62000, 35200);
TestResult(rounding.Calculate(calc, data, 5), 18000, 44000);
}
public void TestGeometrischProgressiv1()
{
var data = new CalculationData(150000, 18000, 5);
var rounding = new DefaultRounding();
var calc = new GeometricProgressive();
TestResult(rounding.Calculate(calc, data, 0), 150000, 0);
TestResult(rounding.Calculate(calc, data, 1), 140493, 9507);
TestResult(rounding.Calculate(calc, data, 2), 125966, 14527);
TestResult(rounding.Calculate(calc, data, 3), 103766, 22200);
TestResult(rounding.Calculate(calc, data, 4), 69842, 33924);
TestResult(rounding.Calculate(calc, data, 5), 18000, 51842);
}
public void TestGeometrischProgressiv1()
{
var data = new CalculationData(150000, 18000, 5);
var rounding = new DefaultRounding();
var calc = new GeometricProgressive();
TestResult(rounding.Calculate(calc, data, 0), 150000, 0);
TestResult(rounding.Calculate(calc, data, 1), 140493, 9507);
TestResult(rounding.Calculate(calc, data, 2), 125966, 14527);
TestResult(rounding.Calculate(calc, data, 3), 103766, 22200);
TestResult(rounding.Calculate(calc, data, 4), 69842, 33924);
TestResult(rounding.Calculate(calc, data, 5), 18000, 51842);
}
public async Task <string> PreparingResult(string query, double calculatedResult)
{
var resultToSave = new CalculationData();
resultToSave.UserQuery = query;
resultToSave.CalculationResult = calculatedResult;
resultToSave.OperationTime = DateTime.Now;
var save = new SaveResult();
await save.SavingResult(resultToSave);
return(MyResult = calculatedResult.ToString());
}
public void TestGeometrischDegressiv2()
{
var data = new CalculationData(60000, 10678.71m, 6);
var rounding = new DefaultRounding(2);
var calc = new GeometricDegressive();
TestResult(rounding.Calculate(calc, data, 0), 60000.00m, 0);
TestResult(rounding.Calculate(calc, data, 1), 45000.00m, 15000.00m);
TestResult(rounding.Calculate(calc, data, 2), 33750.00m, 11250.00m);
TestResult(rounding.Calculate(calc, data, 3), 25312.50m, 8437.50m);
TestResult(rounding.Calculate(calc, data, 4), 18984.37m, 6328.13m);
TestResult(rounding.Calculate(calc, data, 5), 14238.28m, 4746.09m);
TestResult(rounding.Calculate(calc, data, 6), 10678.71m, 3559.57m);
}
public void TestArithmetischDegressiv3()
{
var data = new CalculationData(42000, 0, 6);
var rounding = new DefaultRounding();
var calc = new ArithmeticDegressive();
TestResult(rounding.Calculate(calc, data, 0), 42000, 0);
TestResult(rounding.Calculate(calc, data, 1), 30000, 12000);
TestResult(rounding.Calculate(calc, data, 2), 20000, 10000);
TestResult(rounding.Calculate(calc, data, 3), 12000, 8000);
TestResult(rounding.Calculate(calc, data, 4), 6000, 6000);
TestResult(rounding.Calculate(calc, data, 5), 2000, 4000);
TestResult(rounding.Calculate(calc, data, 6), 0, 2000);
}
/// <summary>
/// Berechnung des Abschreibungs- und Restbuchwertes (<see cref="CalculationResult"/>) für das Abschreibungsjahr (<paramref name="period"/>).
/// </summary>
/// <param name="data">Die grundlegenden Daten für die Abschreibungsberechnung</param>
/// <param name="period">Das Abschreibungsjahr für das die Daten errechnet werden sollen.</param>
/// <returns>Die errechneten Abschreibungs- und Restbuchwerte</returns>
public CalculationResult CalculateDepreciation(CalculationData data, int period)
{
if (period < 1 || period > data.DepreciationRange)
throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater than 0 and less than the value of depreciationRange.");
var factor = CalculateFactor(data);
var factorForOldValue = DecimalMath.Pow(factor, period - 1);
var oldValue = data.AcquisitionValue * factorForOldValue;
var remainingValue = factor * oldValue;
var depreciation = oldValue - remainingValue;
return new CalculationResult(period, depreciation, remainingValue);
}
public void TestArithmetischProgressiv2()
{
var data = new CalculationData(420000, 0, 6);
var rounding = new DefaultRounding();
var calc = new ArithmeticProgressive();
TestResult(rounding.Calculate(calc, data, 0), 420000, 0);
TestResult(rounding.Calculate(calc, data, 1), 400000, 20000);
TestResult(rounding.Calculate(calc, data, 2), 360000, 40000);
TestResult(rounding.Calculate(calc, data, 3), 300000, 60000);
TestResult(rounding.Calculate(calc, data, 4), 220000, 80000);
TestResult(rounding.Calculate(calc, data, 5), 120000, 100000);
TestResult(rounding.Calculate(calc, data, 6), 0, 120000);
}
public void TestGeometrischDegressiv2()
{
var data = new CalculationData(60000, 10678.71m, 6);
var rounding = new DefaultRounding(2);
var calc = new GeometricDegressive();
TestResult(rounding.Calculate(calc, data, 0), 60000.00m, 0);
TestResult(rounding.Calculate(calc, data, 1), 45000.00m, 15000.00m);
TestResult(rounding.Calculate(calc, data, 2), 33750.00m, 11250.00m);
TestResult(rounding.Calculate(calc, data, 3), 25312.50m, 8437.50m);
TestResult(rounding.Calculate(calc, data, 4), 18984.37m, 6328.13m);
TestResult(rounding.Calculate(calc, data, 5), 14238.28m, 4746.09m);
TestResult(rounding.Calculate(calc, data, 6), 10678.71m, 3559.57m);
}
public void Calculate_WhenCall_ReturnedResult()
{
const decimal expectedValue = 5;
var data = new CalculationData {
MathOperation = MathOperations.Multiply, Operand1 = 1, Operand2 = 1
};
_providerMock.Setup(x => x.Get(It.IsAny <MathOperations>())).Returns((x, y) => expectedValue);
var result = _service.Calculate(data);
Assert.IsTrue(result.IsOk);
Assert.AreEqual(expectedValue, result.Value);
}
public void TestLinear1()
{
var data = new CalculationData(10000, 0, 5);
var rounding = new DefaultRounding();
var calc = new DegressiveToLinear(new PercentDegressive(0.30m));
TestResult(rounding.Calculate(calc, data, 0), 10000, 0);
TestResult(rounding.Calculate(calc, data, 1), 7000, 3000);
TestResult(rounding.Calculate(calc, data, 2), 4900, 2100);
// Ab hier wird zur linearen Abrechnung gewechselt
TestResult(rounding.Calculate(calc, data, 3), 3267, 1633);
TestResult(rounding.Calculate(calc, data, 4), 1633, 1634);
TestResult(rounding.Calculate(calc, data, 5), 0, 1633);
}
public CalculationResponse <double> DegreeToRadian(double degree)
{
CalculationData calculation = new CalculationData("Grad zu Radian", "Umrechnung vom Winkelmaß ins Bogenmaß");
double radian = (degree * (Math.PI / 180)) / Math.PI;
calculation.Steps.Add(
new CalculationStep(
"Umrechnen",
"Zum Umrechnen muss die Zahl im Gradmaß einfach nur mit π/180 multipliziert werden und anschließend durch π geteilt werden.",
MainWindow.GetIfRounded(radian)
? string.Format("({0}*(π/180))/π≈{1}π", degree, Math.Round(radian, 3))
: string.Format("({0}*(π/180))/π={1}π", degree, radian)
));
return(new CalculationResponse <double>(radian, calculation));
}
public CalculationResponse <double> RadianToDegree(double radian)
{
CalculationData calculation = new CalculationData("Radian zu Grad", "Umrechnung vom Bogenmaß ins Winkelmaß");
double degree = radian * Math.PI * (180 / Math.PI);
calculation.Steps.Add(
new CalculationStep(
"Umrechnen",
"Zum Umrechnen muss die Zahl im Bogenmaß einfach nur mit 180/π multiplizieren.",
MainWindow.GetIfRounded(radian)
? string.Format("{0}π*(180/π)≈{1}°", radian, Math.Round(degree, 3))
: string.Format("{0}π*(180/π)={1}°", radian, degree)
));
return(new CalculationResponse <double>(degree, calculation));
}
/// <summary>
/// Berechnung des Abschreibungs- und Restbuchwertes (<see cref="CalculationResult"/>) für das Abschreibungsjahr (<paramref name="period"/>).
/// </summary>
/// <param name="data">Die grundlegenden Daten für die Abschreibungsberechnung</param>
/// <param name="period">Das Abschreibungsjahr für das die Daten errechnet werden sollen.</param>
/// <returns>Die errechneten Abschreibungs- und Restbuchwerte</returns>
public CalculationResult CalculateDepreciation(CalculationData data, int period)
{
if (period < 1 || period > data.DepreciationRange)
throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater than 0 and less than the value of depreciationRange.");
var bookingValue = data.AcquisitionValue - data.TargetRemainingValue;
decimal depreciation;
var currentPeriod = 0;
do
{
currentPeriod += 1;
depreciation = bookingValue * Percent;
bookingValue -= depreciation;
}
while (currentPeriod != period);
return new CalculationResult(period, depreciation, bookingValue);
}
public void TestArithmetischDegressiv2()
{
var data = new CalculationData(100000, 0, 10);
var rounding = new DefaultRounding(2);
var calc = new ArithmeticDegressive();
TestResult(rounding.Calculate(calc, data, 0), 100000, 0);
TestResult(rounding.Calculate(calc, data, 1), 81818.18m, 18181.82m);
TestResult(rounding.Calculate(calc, data, 2), 65454.55m, 16363.63m);
TestResult(rounding.Calculate(calc, data, 3), 50909.09m, 14545.46m);
TestResult(rounding.Calculate(calc, data, 4), 38181.82m, 12727.27m);
TestResult(rounding.Calculate(calc, data, 5), 27272.73m, 10909.09m);
TestResult(rounding.Calculate(calc, data, 6), 18181.82m, 9090.91m);
TestResult(rounding.Calculate(calc, data, 7), 10909.09m, 7272.73m);
TestResult(rounding.Calculate(calc, data, 8), 5454.55m, 5454.54m);
TestResult(rounding.Calculate(calc, data, 9), 1818.18m, 3636.37m);
TestResult(rounding.Calculate(calc, data, 10), 0, 1818.18m);
}
/// <summary>
/// Berechnung des Abschreibungs- und Restbuchwertes (<see cref="CalculationResult"/>) für das Abschreibungsjahr (<paramref name="period"/>).
/// </summary>
/// <param name="data">Die grundlegenden Daten für die Abschreibungsberechnung</param>
/// <param name="period">Das Abschreibungsjahr für das die Daten errechnet werden sollen.</param>
/// <returns>Die errechneten Abschreibungs- und Restbuchwerte</returns>
public CalculationResult CalculateDepreciation(CalculationData data, int period)
{
if (period < 1 || period > data.DepreciationRange)
throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater than 0 and less than the value of depreciationRange.");
var deprecationParts = CalculateWeight(period, data.DepreciationRange);
var previousParts = Enumerable.Range(1, period)
.Select(x => CalculateWeight(x, data.DepreciationRange))
.Sum();
var maxParts = previousParts + Enumerable.Range(1 + period, data.DepreciationRange - period)
.Select(x => CalculateWeight(x, data.DepreciationRange))
.Sum();
var amount = CalculateFactor(data, maxParts);
var depreciation = amount * deprecationParts;
var remainingValue = data.AcquisitionValue - amount * previousParts;
return new CalculationResult(period, depreciation, remainingValue);
}
/// <summary>
/// Berechnung des Abschreibungs- und Restbuchwertes (<see cref="CalculationResult"/>) für das Abschreibungsjahr (<paramref name="period"/>).
/// </summary>
/// <param name="data">Die grundlegenden Daten für die Abschreibungsberechnung</param>
/// <param name="period">Das Abschreibungsjahr für das die Daten errechnet werden sollen.</param>
/// <returns>Die errechneten Abschreibungs- und Restbuchwerte</returns>
public CalculationResult CalculateDepreciation(CalculationData data, int period)
{
if (period < 1 || period > data.DepreciationRange)
throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater than 0 and less than the value of depreciationRange.");
var factor = CalculateFactor(data);
var depreciations =
Enumerable.Range(0, 6)
.Select(x => DecimalMath.Pow(factor, x))
.Select(x => data.AcquisitionValue * x)
.SelectWithPrevious((prev, current) => prev - current)
.Reverse()
.ToList();
var depreciation = depreciations[period - 1];
var remainingValue = data.AcquisitionValue - depreciations.Take(period).Sum();
return new CalculationResult(period, depreciation, remainingValue);
}
/// <summary>
/// Berechnung des Abschreibungs- und Restbuchwertes (<see cref="CalculationResult"/>) für das Abschreibungsjahr (<paramref name="period"/>).
/// </summary>
/// <param name="data">Die grundlegenden Daten für die Abschreibungsberechnung</param>
/// <param name="period">Das Abschreibungsjahr für das die Daten errechnet werden sollen.</param>
/// <returns>Die errechneten Abschreibungs- und Restbuchwerte</returns>
public CalculationResult CalculateDepreciation(CalculationData data, int period)
{
if (period < 1 || period > data.DepreciationRange)
throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater than 0 and less than the value of depreciationRange.");
var switchedToLinear = false;
var linearYear = 1;
CalculationData linearData = null;
decimal bookingValue = data.AcquisitionValue;
decimal depreciation;
var currentPeriod = 0;
do
{
currentPeriod += 1;
if (switchedToLinear)
{
Debug.Assert(linearData != null, "Kann nicht NULL sein, weil - solange der Abschreibungswert des degressiven Verfahren errechnet wird - linearData gesetzt wird.");
linearYear += 1;
var linearResult = LinearMethod.CalculateDepreciation(linearData, linearYear);
depreciation = linearResult.Depreciation;
}
else
{
var degressiveResult = DegressiveMethod.CalculateDepreciation(data, currentPeriod);
linearData = new CalculationData(bookingValue, data.TargetRemainingValue, data.DepreciationRange - currentPeriod + 1);
var linearResult = LinearMethod.CalculateDepreciation(linearData, linearYear);
if (degressiveResult.Depreciation < linearResult.Depreciation)
{
switchedToLinear = true;
depreciation = linearResult.Depreciation;
}
else
{
depreciation = degressiveResult.Depreciation;
}
}
bookingValue -= depreciation;
}
while (currentPeriod != period);
return new CalculationResult(period, depreciation, bookingValue);
}
public void TestGeometrischDegressiv1()
{
var data = new CalculationData(150000, 18000, 5);
var rounding = new DefaultRounding();
var calc = new GeometricDegressive();
// Das waren die Werte aus dem Beispiel, doch die scheinen ungenau zu sein:
// http://www.rechnungswesen-portal.de/Fachinfo/Anlagevermoegen/Geometrisch-degressive-Abschreibung.html
//TestResult(rounding.Calculate(calc, data, 0), 150000, 0);
//TestResult(rounding.Calculate(calc, data, 1), 98160, 51840);
//TestResult(rounding.Calculate(calc, data, 2), 64236, 33924);
//TestResult(rounding.Calculate(calc, data, 3), 42036, 22200);
//TestResult(rounding.Calculate(calc, data, 4), 27508, 14528);
//TestResult(rounding.Calculate(calc, data, 5), 18000, 9508);
TestResult(rounding.Calculate(calc, data, 0), 150000, 0);
TestResult(rounding.Calculate(calc, data, 1), 98158, 51842);
TestResult(rounding.Calculate(calc, data, 2), 64234, 33924);
TestResult(rounding.Calculate(calc, data, 3), 42034, 22200);
TestResult(rounding.Calculate(calc, data, 4), 27507, 14527);
TestResult(rounding.Calculate(calc, data, 5), 18000, 9507);
}
private decimal CalculateFactor(CalculationData data)
{
return DecimalMath.Root(data.TargetRemainingValue / data.AcquisitionValue, data.DepreciationRange);
}
private decimal CalculateFactor(CalculationData data, int maxParts)
{
return (data.AcquisitionValue - data.TargetRemainingValue) / maxParts;
}
