public void PowNegativeDecimal()
{
const decimal expected = 0.5380018430410047863745228634M;
decimal actual = DecimalMath.Pow(1.2M, -3.4M);
Assert.AreEqual <decimal>(expected, actual);
}
public void FloatingPower(decimal bas, decimal exp, decimal expect, decimal error)
{
var actual = DecimalMath.Pow(bas, exp);
var actualError = Math.Abs(expect - actual);
Assert.True(error >= actualError, $"Error of {actualError}, expected no more than error of {error}");
}
public void PowDecimal()
{
const decimal expected = 1.8587296919794811670420219951M;
decimal actual = DecimalMath.Pow(1.2M, 3.4M);
Assert.AreEqual <decimal>(expected, actual);
}
public void PowNegativeInt()
{
const decimal expected = 0.012345679012345679012345679M;
decimal actual = 9.0M;
actual = DecimalMath.Pow(actual, -2);
Assert.AreEqual <decimal>(expected, actual);
}
public void PowInt()
{
const decimal expected = 81.0M;
decimal actual = 9.0M;
actual = DecimalMath.Pow(actual, 2);
Assert.AreEqual <decimal>(expected, actual);
}
/// <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));
}
/// <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));
}
// TODO: incorporate hinting here
/// <summary>
/// Attempts to compile the operation with the given arguments.
/// </summary>
/// <param name="bas">the base of the operation</param>
/// <param name="exp">the exponent of the operation</param>
/// <param name="result">the result of the compilation</param>
/// <returns><see langword="true"/> if it was compiled, <see langword="false"/> otherwise.</returns>
public bool TryCompile(Expression bas, Expression exp, [MaybeNullWhen(false)] out Expression result)
{
result = null;
var powMethod = Helpers.GetMethod <Action <decimal> >(a => DecimalMath.Pow(a, a)) !;
Type outType = typeof(decimal);
if (CompilerHelpers.IsIntegral(bas.Type) &&
CompilerHelpers.IsIntegral(exp.Type) &&
!CompilerHelpers.IsSigned(exp.Type))
{
outType = CompilerHelpers.IsSigned(bas.Type) ? typeof(long) : typeof(ulong);
}
try
{
if (bas.Type != typeof(decimal))
{
bas = Expression.Convert(bas, typeof(decimal));
}
if (exp.Type != typeof(decimal))
{
exp = Expression.Convert(exp, typeof(decimal));
}
result = Expression.Call(powMethod, bas, exp);
if (result.Type != outType)
{
result = Expression.Convert(result, outType);
}
return(true);
}
catch
{
return(false);
}
}
public decimal calculate(Queue <string> polska, decimal x)
{
decimal answer = 0;
Stack <decimal> opers = new Stack <decimal>();
foreach (string s in polska)
{
if (standartOperators.Contains(s))
{
decimal a;
decimal b;
switch (s)
{
case "+":
opers.Push(opers.Pop() + opers.Pop());
break;
case "-":
b = opers.Pop();
a = opers.Pop();
opers.Push(a - b);
break;
case "*":
opers.Push(opers.Pop() * opers.Pop());
break;
case "/":
b = opers.Pop();
a = opers.Pop();
opers.Push(a / b);
break;
case "^":
b = opers.Pop();
a = opers.Pop();
opers.Push(DecimalMath.Pow(a, b));
break;
case "%":
b = opers.Pop();
a = opers.Pop();
opers.Push(a % b);
break;
case "sqrt":
opers.Push(DecimalMath.Sqrt(opers.Pop()));
break;
case "sin":
opers.Push(DecimalMath.Sin(opers.Pop()));
break;
case "cos":
opers.Push(DecimalMath.Cos(opers.Pop()));
break;
case "tan":
opers.Push(DecimalMath.Tan(opers.Pop()));
break;
case "atan":
opers.Push(DecimalMath.Atan(opers.Pop()));
break;
case "acos":
opers.Push(DecimalMath.Acos(opers.Pop()));
break;
case "asin":
opers.Push(DecimalMath.Asin(opers.Pop()));
break;
case "acotan":
opers.Push(DecimalMath.Atan(1 / opers.Pop()));
break;
case "exp":
opers.Push(DecimalMath.Exp(opers.Pop()));
break;
case "log":
opers.Push(DecimalMath.Log(opers.Pop()));
break;
case "ln":
opers.Push(DecimalMath.Log10(opers.Pop()));
break;
case "sinh":
opers.Push(DecimalMath.Sinh(opers.Pop()));
break;
case "cosh":
opers.Push(DecimalMath.Cosh(opers.Pop()));
break;
case "tanh":
opers.Push(DecimalMath.Tanh(opers.Pop()));
break;
case "abs":
opers.Push(DecimalMath.Abs(opers.Pop()));
break;
case "ceil":
opers.Push(DecimalMath.Ceiling(opers.Pop()));
break;
case "floor":
opers.Push(DecimalMath.Floor(opers.Pop()));
break;
case "fac":
opers.Push(factorial(opers.Pop()));
break;
case "sfac":
opers.Push(semifactorial(opers.Pop()));
break;
case "round":
opers.Push(DecimalMath.Round(opers.Pop()));
break;
case "fpart":
a = opers.Pop();
opers.Push(a - DecimalMath.Truncate(a));
break;
}
}
else if (s == "x")
{
opers.Push(x);
}
else
{
opers.Push(decimal.Parse(s));
}
}
answer = opers.Pop();
return(answer);
}
public void FloatingPowerThrow(decimal bas, decimal exp)
{
Assert.Throws <OverflowException>(() => DecimalMath.Pow(bas, exp));
}
public void IntegerPower(long bas, long exp, long expect)
{
Assert.Equal((decimal)expect, DecimalMath.Pow(bas, exp));
}