public void MinMaxRangeTest()
{
var converter = GetConverter(out var xVar, out var yVar);
var prog1 = new MaxFunction(xVar, yVar);
var prog2 = new MinFunction(xVar, yVar);
Console.WriteLine($"{prog1}:{prog1.GetRange()}\n{prog2}:{prog2.GetRange()}");
Assert.AreEqual(prog1.GetRange(), yVar.Range, $"{prog1.GetRange()} should be equal to {yVar.Range}");
Assert.AreEqual(prog2.GetRange(), xVar.Range, $"{prog2.GetRange()} should be equal to {xVar.Range}");
}
public void CanAddNoParameterCountFunctionAndRetrieveIt()
{
LanguageDefiner definer = new LanguageDefiner();
IFunctionDefiner max = new MaxFunction();
max.AddFunction(definer);
MeVariable[] vars = { new MeNumber(100), new MeNumber(20) };
MeVariable[] vars2 = { new MeNumber(100), new MeNumber(20), new MeNumber(400) };
Function maxFunc = definer.GetFunction(LConstants.MAX_F, vars);
Function maxFunc2 = definer.GetFunction(LConstants.MAX_F, vars2);
Assert.IsNotNull(maxFunc);
Assert.IsNotNull(maxFunc2);
Assert.AreEqual(maxFunc2, maxFunc);
}
public void MinMaxWithSelfTest()
{
GetConverter(out var varX, out _);
MathProgram prog1 = new MaxFunction(varX, varX);
var prog2 = varX;
var simp = prog1.Simplify();
Console.WriteLine($"{prog1}->{simp}, {prog2}");
Assert.AreEqual(simp, prog2, $"{prog1} simplification ({simp}) should be equal to {prog2}");
prog1 = new MinFunction(varX, varX);
simp = prog1.Simplify();
Console.WriteLine($"{prog1}->{simp}, {prog2}");
Assert.AreEqual(simp, prog2, $"{prog1} simplification ({simp}) should be equal to {prog2}");
}
public void MaxTest()
{
GetConverter(out var varX, out _);
MathProgram prog1 = new MaxFunction(varX, new Constant(double.MinValue));
var prog2 = varX;
var simp = prog1.Simplify();
Console.WriteLine($"{prog1}->{simp}, {prog2}");
Assert.AreEqual(simp, prog2, $"{prog1} simplification ({simp}) should be equal to {prog2}");
prog1 = new MaxFunction(varX, new Constant(double.NegativeInfinity));
simp = prog1.Simplify();
Console.WriteLine($"{prog1}->{simp}, {prog2}");
Assert.AreEqual(simp, prog2, $"{prog1} simplification ({simp}) should be equal to {prog2}");
}
void Start()
{
// default fallbacks, if shaders are unspecified
if (!uberReplacementShader)
{
uberReplacementShader = Shader.Find("Hidden/UberReplacement");
}
if (!OFmagShader)
{
OFmagShader = Shader.Find("Hidden/OFmag");
}
OFmagMat = new Material(OFmagShader);
maximum = GetComponent <MaxFunction>();
}
/// <summary>
/// Tries to create an ARQ Function expression if the function Uri correseponds to a supported ARQ Function.
/// </summary>
/// <param name="u">Function Uri.</param>
/// <param name="args">Function Arguments.</param>
/// <param name="scalarArgs">Scalar Arguments.</param>
/// <param name="expr">Generated Expression.</param>
/// <returns>Whether an expression was successfully generated.</returns>
public bool TryCreateExpression(Uri u, List <ISparqlExpression> args, Dictionary <String, ISparqlExpression> scalarArgs, out ISparqlExpression expr)
{
// If any Scalar Arguments are present then can't possibly be an ARQ Function
if (scalarArgs.Count > 0)
{
expr = null;
return(false);
}
String func = u.AbsoluteUri;
if (func.StartsWith(ArqFunctionsNamespace))
{
func = func.Substring(ArqFunctionsNamespace.Length);
ISparqlExpression arqFunc = null;
switch (func)
{
case BNode:
if (args.Count == 1)
{
arqFunc = new BNodeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ bnode() function");
}
break;
case E:
if (args.Count == 0)
{
arqFunc = new EFunction();
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ e() function");
}
break;
case LocalName:
if (args.Count == 1)
{
arqFunc = new LocalNameFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ localname() function");
}
break;
case Max:
if (args.Count == 2)
{
arqFunc = new MaxFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ max() function");
}
break;
case Min:
if (args.Count == 2)
{
arqFunc = new MinFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ min() function");
}
break;
case Namespace:
if (args.Count == 1)
{
arqFunc = new NamespaceFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ namespace() function");
}
break;
case Now:
if (args.Count == 0)
{
arqFunc = new NowFunction();
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ now() function");
}
break;
case Pi:
if (args.Count == 0)
{
arqFunc = new PiFunction();
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ pi() function");
}
break;
case Sha1Sum:
if (args.Count == 1)
{
arqFunc = new Sha1Function(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ sha1sum() function");
}
break;
case StrJoin:
if (args.Count >= 2)
{
arqFunc = new StringJoinFunction(args.First(), args.Skip(1));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ strjoing() function");
}
break;
case Substr:
case Substring:
if (args.Count == 2)
{
arqFunc = new SubstringFunction(args.First(), args.Last());
}
else if (args.Count == 3)
{
arqFunc = new SubstringFunction(args.First(), args[1], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the ARQ " + func + "() function");
}
break;
}
if (arqFunc != null)
{
expr = arqFunc;
return(true);
}
}
expr = null;
return(false);
}
public Task <byte[]> MaxQueryAsync(MaxFunction maxFunction, BlockParameter blockParameter = null)
{
return(ContractHandler.QueryAsync <MaxFunction, byte[]>(maxFunction, blockParameter));
}
public object Evaluate(MaxFunction funcExp, object data, IEnumerable <object> parameters = null)
{
var paramValues = _GetParameterValues(funcExp, data, parameters);
return(((IEnumerable <object>)paramValues[0]).Max(i => (decimal)i));
}
public string ToSQL(MaxFunction funcExp)
{
return(_FunctionToSQL(funcExp, "MAX"));
}
public void SettingAliasTest(MaxFunction column, string expectedAlias) => column.Alias.Should().Be(expectedAlias);
