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 double FindMinimum(MinFunction fun, double p1, double p2)
{
function = fun;
ax = p1;
bx = p2;
BracketMinimum();
double xmin;
double minval = GoldenSectionSearch(out xmin);
return(minval);
}
public void MinTest()
{
GetConverter(out var varX, out _);
MathProgram prog1 = new MinFunction(varX, new Constant(double.MaxValue));
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, new Constant(double.PositiveInfinity));
simp = prog1.Simplify();
Console.WriteLine($"{prog1}->{simp}, {prog2}");
Assert.AreEqual(simp, prog2, $"{prog1} simplification ({simp}) should be equal to {prog2}");
}
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 HashTestProgram()
{
var const1 = new Constant(0);
var const2 = new Constant(1);
var variable = new Variable("a");
var sine = new SineFunction(const2);
var pow = new PowerFunction(const1, variable);
var subtr = new SubtractionFunction(const2, pow);
var min = new MinFunction(subtr, const1);
var div = new DivisionFunction(pow, variable);
var prog = new IfFunction(div, min, subtr, sine);
var hashCode = prog.GetHashCode();
Console.WriteLine($"{prog}:{hashCode}");
Assert.AreNotEqual(hashCode, 0, double.Epsilon, $"Hash code of {prog} should not be 0.");
}
/// <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[]> MinQueryAsync(MinFunction minFunction, BlockParameter blockParameter = null)
{
return(ContractHandler.QueryAsync <MinFunction, byte[]>(minFunction, blockParameter));
}
public void SettingAliasTest(MinFunction column, string expectedAlias) => column.Alias.Should().Be(expectedAlias);
public object Evaluate(MinFunction funcExp, object data, IEnumerable <object> parameters = null)
{
var paramValues = _GetParameterValues(funcExp, data, parameters);
return(((IEnumerable <object>)paramValues[0]).Min(i => (decimal)i));
}
public string ToSQL(MinFunction funcExp)
{
return(_FunctionToSQL(funcExp, "MIN"));
}
//C++ TO C# CONVERTER WARNING: The original C++ declaration of the following method implementation was not found:
public void AddFunction(MinFunction fun)
{
functions.Append(fun);
}
