/// <summary>
///
/// </summary>
/// <param name="function"></param>
public FormulaFunction(CalcFunction function)
{
Function = function;
Name = function.Name;
MinArgs = function.MinArgs;
MaxArgs = function.MaxArgs;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Dt.CalcEngine.Expressions.CalcFunctionExpression" /> class.
/// </summary>
/// <param name="functionName">Name of the function.</param>
/// <param name="args">List of parameters.</param>
/// <exception cref="T:System.ArgumentNullException">functionName or args is <see langword="null" />.</exception>
public CalcFunctionExpression(string functionName, CalcExpression[] args)
{
base.ThrowIfArgumentNull <CalcExpression[]>(args, "args");
this._functionName = functionName;
this._function = null;
this._arguments = args;
}
public void FuncitonButtonClicked(CalcFunction calcFunction)
{
string response = "";
switch (calcFunction)
{
case CalcFunction.UNDO:
response = Invoker.GetInstance().Undo();
Framework.TriggerRefreshUI(response);
break;
case CalcFunction.REDO:
response = Invoker.GetInstance().Redo();
Framework.TriggerRefreshUI(response);
break;
case CalcFunction.DOT:
if (!Framework.CurrentInput.Contains("."))
{
Framework.CurrentInput += ".";
Framework.TriggerRefreshUI("Added DOT");
}
else
{
Framework.TriggerRefreshUI("You already have DOT");
}
break;
}
}
/// <summary>
/// Removes the first occurrence of a specific object from the collection.
/// </summary>
/// <param name="function">The object to remove from the collection.</param>
/// <returns>true if item is successfully removed; otherwise, false. This method also returns false if item was not found in the collection.</returns>
public bool Remove(CalcFunction function)
{
if (List.Contains(function))
{
List.Remove(function);
return(true);
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Dt.CalcEngine.Expressions.CalcFunctionExpression" /> class.
/// </summary>
/// <param name="calcFunction">The function.</param>
/// <param name="args">List of parameters.</param>
/// <exception cref="T:System.ArgumentNullException">calcFunction or args is <see langword="null" />.</exception>
/// <exception cref="T:System.ArgumentException">calcFunction does not accept the number of parameters found in args.</exception>
public CalcFunctionExpression(CalcFunction calcFunction, CalcExpression[] args)
{
base.ThrowIfArgumentNull <CalcFunction>(calcFunction, "calcFunction");
if ((calcFunction.MinArgs > 0) && ((args == null) || (calcFunction.MinArgs > args.Length)))
{
throw new ArgumentException("args");
}
this._functionName = null;
this._function = calcFunction;
this._arguments = args;
}
private object EvaluateFunctionWithArrayFormulaMode(CalcFunction func, object[] args, CalcEvaluatorContext context, bool acceptsArray, bool acceptsReference)
{
if (args.Length == 0)
{
return(this.EvaluateFunction(func, args, context, acceptsArray, acceptsReference, 0, 0));
}
if (func.MaxArgs == 1)
{
return(this.EvaluateFunctionOneArg(func, args[0], context, acceptsArray, acceptsReference));
}
return(this.EvaluateFunctionTwoOrMoreArgs(func, args, context, acceptsArray, acceptsReference));
}
public async void Version2_algorithm(int inputValue, int expectedResult)
{
// Arrange
var request = TestFactory.CreateHttpRequest();
Environment.SetEnvironmentVariable("FF_USE_V2_ALGORITHM", "true", EnvironmentVariableTarget.Process);
// Act
var response = (OkObjectResult)await CalcFunction.Run(request, inputValue, logger);
// Assert
Assert.Equal(expectedResult, response.Value);
}
public void FuncitonButtonClicked(CalcFunction calcFunction)
{
switch (calcFunction)
{
case CalcFunction.DOT:
Framework.CurrentInput += ".";
Framework.TriggerRefreshUI("Added DOT");
break;
default:
Framework.TriggerRefreshUI("You are in PROG state.. Can't use that here");
break;
}
}
private object EvaluateFunction(CalcFunction func, object[] args, CalcEvaluatorContext context, bool acceptsArray, bool acceptsReference, int offsetRow, int offsetColumn)
{
try
{
CalcEvaluatorContext context2 = ((offsetRow != 0) && (offsetColumn != 0)) ? ((context != null) ? context.Offset(offsetRow, offsetColumn) : null) : context;
object obj2 = func.IsContextSensitive ? func.Evaluate(args, context2) : func.Evaluate(args);
if (obj2 is CalcReference)
{
if (context2 != null)
{
if (context2.ArrayFormulaMode)
{
if (context.ExpandArrayToMultiCall)
{
obj2 = CalcHelper.GetArrayValue(CalcConvert.ToArray(obj2), offsetRow, offsetColumn) ?? ((int)0);
}
}
else if (!acceptsReference)
{
obj2 = this.ExtractValueFromReference(obj2 as CalcReference, context2.Row, context2.Column) ?? ((int)0);
}
}
}
else if (obj2 is CalcArray)
{
if (context == null)
{
obj2 = CalcHelper.GetArrayValue(obj2 as CalcArray, offsetRow, offsetColumn);
}
else if (context.ArrayFormulaMode)
{
if (context.ExpandArrayToMultiCall)
{
obj2 = CalcHelper.GetArrayValue(obj2 as CalcArray, offsetRow, offsetColumn);
}
}
else if (!acceptsArray && context.ExpandArrayToMultiCall)
{
obj2 = CalcHelper.GetArrayValue(obj2 as CalcArray, offsetRow, offsetColumn);
}
}
return(obj2);
}
catch (InvalidCastException)
{
return(CalcErrors.Value);
}
}
private object EvaluateFunctionOneArg(CalcFunction func, object arg, CalcEvaluatorContext context, bool acceptsArray, bool acceptsReference)
{
if (func.AcceptsReference(0) || CalcHelper.TryExtractToSingleValue(arg, out arg))
{
return(this.EvaluateFunction(func, new object[] { arg }, context, acceptsArray, acceptsReference, 0, 0));
}
CalcArray array = arg as CalcArray;
object[,] values = new object[array.RowCount, array.ColumnCount];
for (int i = 0; i < array.RowCount; i++)
{
for (int j = 0; j < array.ColumnCount; j++)
{
values[i, j] = this.EvaluateFunction(func, new object[] { array.GetValue(i, j) }, context, acceptsArray, acceptsReference, i, j);
}
}
return(new ConcreteArray <object>(values));
}
/// <summary>
/// Inserts an element into the collection at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which item should be inserted.</param>
/// <param name="function">The CalcFunction object to insert.</param>
public void Insert(int index, CalcFunction function)
{
if (!List.Contains(function))
{
bool found = false;
foreach (CalcFunction f in List)
{
if (string.Compare(f.Code.Trim(), function.Code.Trim(), true) == 0)
{
found = true;
break;
}
}
if (!found)
{
List.Insert(index, function);
}
}
}
/// <summary>
/// Removes the first occurrence of a specific object from the collection.
/// </summary>
/// <param name="functionCode">The code of the function to remove from the collection.</param>
/// <returns>true if item is successfully removed; otherwise, false. This method also returns false if item was not found in the collection.</returns>
public bool Remove(string functionCode)
{
CalcFunction fx = null;
foreach (CalcFunction f in List)
{
if (string.Compare(f.Code.Trim(), functionCode.Trim(), true) == 0)
{
fx = f;
break;
}
}
if (fx != null)
{
List.Remove(fx);
return(true);
}
return(false);
}
/// <summary>
/// Adds a CalcFunction into the list.
/// </summary>
/// <param name="function">A CalcFunction object to be added into the collection.</param>
/// <returns>A CalcFunction object if the operation is succeeded, null, otherwise.</returns>
public CalcFunction Add(CalcFunction function)
{
if (!List.Contains(function))
{
bool found = false;
foreach (CalcFunction f in List)
{
if (string.Compare(f.Code.Trim(), function.Code.Trim(), true) == 0)
{
found = true;
break;
}
}
if (!found)
{
int index = List.Add(function);
function.List = this;
return((CalcFunction)List[index]);
}
}
return(null);
}
static FormulaFunctionList()
{
foreach (TypeInfo info in typeof(CalcFunction).GetTypeInfo().Assembly.DefinedTypes)
{
if ((info.IsPublic && !info.IsAbstract) && IntrospectionExtensions.GetTypeInfo((Type)typeof(CalcFunction)).IsAssignableFrom(info))
{
foreach (ConstructorInfo info2 in info.DeclaredConstructors)
{
if (Enumerable.Count <ParameterInfo>(info2.GetParameters()) == 0)
{
try
{
CalcFunction function = info2.Invoke(new object[0]) as CalcFunction;
_allList.Add(function.Name, new FormulaFunction(function));
}
catch
{
}
}
}
}
}
ReadFormulaInformation();
}
//constructor
public SingleMission(CalcFunction function, String mission)
{
sfunction = function;
Name = mission;
Type = "Single";
}
public void FuncitonButtonClicked(CalcFunction calcFunction)
{
Framework.TriggerRefreshUI("You are in Recall state.. Can't use that here");
}
//constructor
public ComposedMission(CalcFunction function, String mission)
{
Name = mission;
Type = "Composed";
composedFunctions.Add(function);
}
/// <summary>
/// Determines whether an element is in the collection.
/// </summary>
/// <param name="function">The object to locate in the collection.</param>
/// <returns>true if function is found in the collection; otherwise, false</returns>
public bool Contains(CalcFunction function)
{
return(List.Contains(function));
}
//add function to function list
public ComposedMission Add(CalcFunction function)
{
composedFunctions.Add(function);
return(this);
}
private bool PrepareFunctionArguments(CalcFunctionExpression expr, CalcEvaluatorContext context, out CalcFunction func, out object[] args, out List <int> expandArrayArgIndex, out object error)
{
if (!this.TryGetFunction(expr, context, out func, out error))
{
args = null;
expandArrayArgIndex = null;
return(false);
}
expandArrayArgIndex = new List <int>();
int argCount = expr.ArgCount;
args = new object[argCount];
error = null;
if (func.IsBranch)
{
int i = func.FindTestArgument();
if ((i >= 0) && (i < argCount))
{
object obj2;
if (!this.EvaluateFunctionArgument(expr.GetArg(i), context, func.AcceptsArray(i), func.AcceptsReference(i), func.AcceptsError(i), func.AcceptsMissingArgument(i), out obj2))
{
error = obj2;
expandArrayArgIndex = null;
return(false);
}
if ((context != null) && !context.ArrayFormulaMode)
{
if (obj2 is CalcReference)
{
obj2 = this.ExtractValueFromReference(obj2 as CalcReference, context.Row, context.Column);
if (!func.AcceptsError(i) && (obj2 is CalcError))
{
error = obj2;
expandArrayArgIndex = null;
return(false);
}
if (!func.AcceptsMissingArgument(i) && (obj2 is CalcMissingArgument))
{
obj2 = null;
}
}
else if ((obj2 is CalcArray) && !func.AcceptsArray(i))
{
if (!context.ExpandArrayToMultiCall)
{
obj2 = CalcHelper.GetArrayValue(obj2 as CalcArray, 0, 0);
if (!func.AcceptsError(i) && (obj2 is CalcError))
{
error = obj2;
expandArrayArgIndex = null;
return(false);
}
if (!func.AcceptsMissingArgument(i) && (obj2 is CalcMissingArgument))
{
obj2 = null;
}
}
else
{
expandArrayArgIndex.Add(i);
}
}
}
args[i] = obj2;
}
List <int> list = new List <int>();
CalcArray array = CalcConvert.ToArray(args[i]);
for (int j = 0; j < array.RowCount; j++)
{
for (int k = 0; k < array.ColumnCount; k++)
{
int item = -1;
try
{
item = func.FindBranchArgument(array.GetValue(j, k));
}
catch (InvalidCastException)
{
}
if (item != -1)
{
if (!list.Contains(item))
{
list.Add(item);
}
if (list.Count >= (func.MaxArgs - 1))
{
break;
}
}
}
}
if (list.Count == 0)
{
error = CalcErrors.Value;
expandArrayArgIndex = null;
return(false);
}
foreach (int num6 in list)
{
if ((num6 >= 0) && (num6 < argCount))
{
object obj3;
if (!this.EvaluateFunctionArgument(expr.GetArg(num6), context, func.AcceptsArray(num6), func.AcceptsReference(num6), func.AcceptsError(num6), func.AcceptsMissingArgument(num6), out obj3))
{
error = obj3;
expandArrayArgIndex = null;
return(false);
}
if (((context != null) && !context.ArrayFormulaMode) && ((obj3 is CalcArray) && !func.AcceptsArray(num6)))
{
if (!context.ExpandArrayToMultiCall)
{
obj3 = CalcHelper.GetArrayValue(obj3 as CalcArray, 0, 0);
if (!func.AcceptsError(num6) && (obj3 is CalcError))
{
error = obj3;
expandArrayArgIndex = null;
return(false);
}
if (!func.AcceptsMissingArgument(num6) && (obj3 is CalcMissingArgument))
{
obj3 = null;
}
}
else
{
expandArrayArgIndex.Add(num6);
}
}
args[num6] = obj3;
}
}
if (expandArrayArgIndex.Count > 0)
{
expandArrayArgIndex.Sort();
}
}
else
{
for (int m = 0; m < argCount; m++)
{
object obj4;
if (!this.EvaluateFunctionArgument(expr.GetArg(m), context, func.AcceptsArray(m), func.AcceptsReference(m), func.AcceptsError(m), func.AcceptsMissingArgument(m), out obj4))
{
error = obj4;
expandArrayArgIndex = null;
return(false);
}
if (((context != null) && !context.ArrayFormulaMode) && ((obj4 is CalcArray) && !func.AcceptsArray(m)))
{
if (!context.ExpandArrayToMultiCall)
{
obj4 = CalcHelper.GetArrayValue(obj4 as CalcArray, 0, 0);
if (!func.AcceptsError(m) && (obj4 is CalcError))
{
error = obj4;
expandArrayArgIndex = null;
return(false);
}
if (!func.AcceptsMissingArgument(m) && (obj4 is CalcMissingArgument))
{
obj4 = null;
}
}
else
{
expandArrayArgIndex.Add(m);
}
}
args[m] = obj4;
}
}
return(true);
}
private object EvaluateFunctionTwoOrMoreArgs(CalcFunction func, object[] args, CalcEvaluatorContext context, bool acceptsArray, bool acceptsReference)
{
int length = args.Length;
bool[] flagArray = new bool[length];
bool flag = true;
for (int i = 0; i < length; i++)
{
object obj2 = null;
bool flag2 = func.AcceptsReference(i);
bool flag3 = flag2 || CalcHelper.TryExtractToSingleValue(args[i], out obj2);
flag = flag && flag3;
flagArray[i] = flag3;
if (!flag2)
{
args[i] = obj2;
}
}
if (flag)
{
return(this.EvaluateFunction(func, args, context, acceptsArray, acceptsReference, 0, 0));
}
int[] numArray = new int[length];
int[] numArray2 = new int[length];
for (int j = 0; j < length; j++)
{
CalcArray array = args[j] as CalcArray;
numArray[j] = (flagArray[j] || (array == null)) ? -1 : array.RowCount;
numArray2[j] = (flagArray[j] || (array == null)) ? -1 : array.ColumnCount;
}
int num4 = -1;
int num5 = -1;
if (!flagArray[0])
{
num4 = numArray[0];
num5 = numArray2[0];
}
for (int k = 1; k < length; k++)
{
if (!flagArray[k])
{
int num7 = numArray[k];
int num8 = numArray2[k];
num4 = (num4 == -1) ? num7 : ((num7 > 1) ? ((num4 > 1) ? Math.Min(num7, num4) : num7) : num4);
num5 = (num5 == -1) ? num8 : ((num8 > 1) ? ((num5 > 1) ? Math.Min(num8, num5) : num8) : num5);
}
}
object[,] values = new object[num4, num5];
using (context.EnterExpandArrayToMultiCallMode())
{
for (int m = 0; m < num4; m++)
{
for (int n = 0; n < num5; n++)
{
object[] objArray2 = new object[length];
for (int num11 = 0; num11 < length; num11++)
{
objArray2[num11] = flagArray[num11] ? args[num11] : CalcHelper.GetArrayValue(args[num11] as CalcArray, m, n);
}
values[m, n] = this.EvaluateFunction(func, objArray2, context, acceptsArray, acceptsReference, m, n);
}
}
return(new ConcreteArray <object>(values));
}
}
private bool TryGetFunction(CalcFunctionExpression expr, CalcEvaluatorContext context, out CalcFunction func, out object error)
{
func = expr.Function;
int argCount = expr.ArgCount;
if (object.ReferenceEquals(func, null))
{
if (object.ReferenceEquals(context, null))
{
error = CalcErrors.Name;
return(false);
}
func = context.GetFunction(expr.FunctionName);
if (object.ReferenceEquals(func, null))
{
error = CalcErrors.Name;
return(false);
}
if ((argCount < func.MinArgs) || (func.MaxArgs < argCount))
{
error = CalcErrors.Value;
return(false);
}
}
error = null;
return(true);
}
public void FuncitonButtonClicked(CalcFunction calcFunction)
{
CurrentState.FuncitonButtonClicked(calcFunction);
}
/// <summary>
/// Returns the index within the collection of the specified function.
/// </summary>
/// <param name="function">A CalcFunction object representing the function to locate in the collection.</param>
/// <returns>The zero-based index where the function is located within the collection; otherwise, negative one (-1).</returns>
public int IndexOf(CalcFunction function)
{
return(List.IndexOf(function));
}
//Will take in the two numerals and the specified math operation to return an answer as an integer.
public int Calculate(CalcFunction calcFunction, String FirstNumber, String SecondNumber) {
return operationMap[calcFunction].Invoke(ConvertMulitpleChars(FirstNumber), ConvertMulitpleChars(SecondNumber));
}
public string FullFunction(string FirstNumber, string SecondNumber, CalcFunction calcFunction) {
return ConvertNumberstoRomanNumerals(Calculate(calcFunction, FirstNumber, SecondNumber));
}
